123

<!
DOCTYPE html>
<html lang="en" dir="ltr" class="client-nojs">
<head>
<title>24 game/Solve - Rosetta Code</title>
<meta charset="UTF-8"/>
<meta name="generator" content="MediaWiki 1.20.3"/>
<script type="text/javascript">
//<![CDATA[
try{if (!window.CloudFlare) {var CloudFlare=[{verbose:0,p:0,byc:0,owlid:"cf",bag
2:1,mirage2:0,oracle:0,paths:{cloudflare:"/cdn-cgi/nexp/dok3v=1613a3a185/"},atok
:"1d41b6e8edcbbca654dbf2320c50ff5c",petok:"84b867db920efc7777e89c4b0e97a6ec18990
0a9-1444512962-1800",zone:"rosettacode.org",rocket:"a",apps:{"ga_key":{"ua":"UA1219419-1","ga_bs":"2"}}}];document.write('<script type="text/javascript" src="/
/ajax.cloudflare.com/cdn-cgi/nexp/dok3v=e9627cd26a/cloudflare.min.js"><'+'\/scri
pt>');}}catch(e){};
//]]>
</script>
<link rel="alternate" type="application/x-wiki" title="Edit" href="/mw/index.php
?title=24_game/Solve&action=edit"/>
<link rel="edit" title="Edit" href="/mw/index.php?title=24_game/Solve&action
=edit"/>
<link rel="shortcut icon" href="/favicon.ico"/>
<link rel="search" type="application/opensearchdescription+xml" href="/mw/opense
arch_desc.php" title="Rosetta Code (en)"/>
<link rel="EditURI" type="application/rsd+xml" href="http://rosettacode.org/mw/a
pi.php?action=rsd"/>
<link rel="copyright" href="http://www.gnu.org/licenses/fdl-1.2.html"/>
<link rel="alternate" type="application/atom+xml" title="Rosetta Code Atom feed"
href="/mw/index.php?title=Special:RecentChanges&feed=atom"/>
<link rel="stylesheet" href="http://rosettacode.org/mw/load.php?debug=false&
lang=en&modules=mediawiki.legacy.commonPrint%2Cshared%7Cskins.vector&onl
y=styles&skin=vector&*"/>
<meta name="ResourceLoaderDynamicStyles" content=""/>
<link rel="stylesheet" href="http://rosettacode.org/mw/load.php?debug=false&
lang=en&modules=site&only=styles&skin=vector&*"/>
<style>a:lang(ar),a:lang(ckb),a:lang(fa),a:lang(kk-arab),a:lang(mzn),a:lang(ps),
a:lang(ur){text-decoration:none}</style>
<script data-rocketsrc="http://rosettacode.org/mw/load.php?debug=false&lang=
en&modules=startup&only=scripts&skin=vector&*" type="text/rocket
script"></script>
<script type="text/rocketscript">if(window.mw){
mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgN
amespaceNumber":0,"wgPageName":"24_game/Solve","wgTitle":"24 game/Solve","wgCurR
evisionId":210398,"wgArticleId":4940,"wgIsArticle":true,"wgAction":"view","wgUse
rName":null,"wgUserGroups":["*"],"wgCategories":["Programming Tasks","Solutions
by Programming Task","ABAP","Argile","AutoHotkey","BBC BASIC","C","C++","Clojure
","CoffeeScript","Common Lisp","D","ERRE","Euler Math Toolbox","F Sharp","Fortra
n","GAP","Go","Gosu","Haskell","Icon","Unicon","Icon Programming Library","J","J
ava","JavaScript","Jq","Julia","Liberty BASIC","Lua","Mathematica","Wolfram Lang
uage","OCaml","Perl","Perl 6","Phix","PicoLisp","ProDOS","Prolog","Python","R","
Racket","REXX","Ruby","Scala","Sidef","Swift","Tcl","Tcllib","Ursala","Zkl","GUI
SS/Omit","ML/I/Omit"],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgSepa
ratorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateForma
t":"dmy","wgMonthNames":["","January","February","March","April","May","June","J
uly","August","September","October","November","December"],"wgMonthNamesShort":[
"","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgR
elevantPageName":"24_game/Solve","wgRestrictionEdit":[],"wgRestrictionMove":[],"
sfgRemoveText":"Remove","sfgAutocompleteOnAllChars":false,"sfgAutocompleteValues
":{},"sfgShowOnSelect":{},"sfgFormErrorsHeader":"There were errors with your for
m input; see below","sfgBlankErrorStr":"cannot be blank","sfgBadURLErrorStr":"mu

st have the correct URL format, starting with \"http\"","sfgBadEmailErrorStr":"m
ust have a valid email address format","sfgBadNumberErrorStr":"must be a valid n
umber","sfgBadDateErrorStr":"must be a valid date","sfgAnonEditWarning":"Warning
: You are not logged in. Your IP address will be recorded in this page\'s edit h
istory."});
}</script><script type="text/rocketscript">if(window.mw){
mw.loader.implement("user.options",function(){mw.user.options.set({"ccmeonemails
":0,"cols":80,"date":"default","diffonly":0,"disablemail":0,"disablesuggest":0,"
editfont":"default","editondblclick":0,"editsection":1,"editsectiononrightclick"
:0,"enotifminoredits":0,"enotifrevealaddr":0,"enotifusertalkpages":1,"enotifwatc
hlistpages":0,"extendwatchlist":0,"externaldiff":0,"externaleditor":0,"fancysig"
:0,"forceeditsummary":0,"gender":"unknown","hideminor":0,"hidepatrolled":0,"imag
esize":2,"justify":0,"math":1,"minordefault":0,"newpageshidepatrolled":0,"nocach
e":0,"noconvertlink":0,"norollbackdiff":0,"numberheadings":0,"previewonfirst":0,
"previewontop":1,"quickbar":5,"rcdays":7,"rclimit":50,"rememberpassword":0,"rows
":25,"searchlimit":20,"showhiddencats":0,"showjumplinks":1,"shownumberswatching"
:1,"showtoc":1,"showtoolbar":1,"skin":"vector","stubthreshold":0,"thumbsize":2,"
underline":2,"uselivepreview":0,"usenewrc":0,"watchcreations":0,"watchdefault":0
,"watchdeletion":0,"watchlistdays":3,
"watchlisthideanons":0,"watchlisthidebots":0,"watchlisthideliu":0,"watchlisthide
minor":0,"watchlisthideown":0,"watchlisthidepatrolled":0,"watchmoves":0,"wllimit
":250,"variant":"en","language":"en","searchNs0":true,"searchNs1":false,"searchN
s2":false,"searchNs3":false,"searchNs4":false,"searchNs5":false,"searchNs6":fals
e,"searchNs7":false,"searchNs8":false,"searchNs9":false,"searchNs10":false,"sear
chNs11":false,"searchNs12":false,"searchNs13":false,"searchNs14":false,"searchNs
15":false,"searchNs102":false,"searchNs103":false,"searchNs106":false,"searchNs1
75":false});;},{},{});mw.loader.implement("user.tokens",function(){mw.user.token
s.set({"editToken":"+\\","watchToken":false});;},{},{});
/* cache key: rosettacode:resourceloader:filter:minify-js:7:2ce58c77cc7227488637
c1087f1776c6 */
}</script>
mw.loader.load(["mediawiki.page.startup","mediawiki.legacy.wikibits","mediawiki.
legacy.ajax"]);
}</script>
<link rel="alternate" type="application/rdf+xml" title="24 game/Solve" href="/mw
/index.php?title=Special:ExportRDF/24_game/Solve&xmlmime=rdf"/>
<script type="text/javascript">
/* <![CDATA[ */
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-1219419-1']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async
= true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www')
+ '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga
, s);
})();
(function(b){(function(a){"__CF"in b&&"DJS"in b.__CF?b.__CF.DJS.push(a):"addEven
tListener"in b?b.addEventListener("load",a,!1):b.attachEvent("onload",a)})(funct
ion(){"FB"in b&&"Event"in FB&&"subscribe"in FB.Event&&(FB.Event.subscribe("edge.
create",function(a){_gaq.push(["_trackSocial","facebook","like",a])}),FB.Event.s
ubscribe("edge.remove",function(a){_gaq.push(["_trackSocial","facebook","unlike"
,a])}),FB.Event.subscribe("message.send",function(a){_gaq.push(["_trackSocial","
facebook","send",a])}));"twttr"in b&&"events"in twttr&&"bind"in twttr.events&&tw
ttr.events.bind("tweet",function(a){if(a){var b;if(a.target&&a.target.nodeName==
"IFRAME")a:{if(a=a.target.src){a=a.split("#")[0].match(/[^?=&]+=([^&]*)?/g);b=0;
for(var c;c=a[b];++b)if(c.indexOf("url")===0){b=unescape(c.split("=")[1]);break
a}}b=void 0}_gaq.push(["_trackSocial","twitter","tweet",b])}})})})(window);
/* ]]> */
</script>
</head>
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-24_game_Solve skin-v
ector action-view vector-animateLayout">
<div id="mw-page-base" class="noprint"></div>
<div id="mw-head-base" class="noprint"></div>
<div id="content" class="mw-body">
<a id="top"></a>
<div id="mw-js-message" style="display:none;"></div>
<h1 id="firstHeading" class="firstHeading">24 game/Solve
</h1>
<div id="bodyContent">
<div id="siteSub">From Rosetta Code</div>
<div id="contentSub">< <a href="/wiki/24_game" title="
24 game">24 game</a></div>
<div id="jump-to-nav" class="mw-jump">
Jump to: <a href="#mw-head">navigation</a>, <a href="#p-search">search</a>
</div>
<div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr"><div class=
"infobox" style="width: 2in"><div class="floatleft"><a href="/wiki/Category:Solu
tions_by_Programming_Task" title="Category:Solutions by Programming Task"><img a
lt="Task" src="/mw/images/b/ba/Rcode-button-task-crushed.png" width="64" height=
"64"/></a></div>24 game/Solve 
You are encouraged to <a href="/wiki/Rosetta_Code:Solve_a_Task" title="Rosetta C
ode:Solve a Task">solve this task</a> according to the task description, using a
ny language you may know.</div>
Write a program that takes four digits, either from user input or by random g
eneration, and computes arithmetic expressions following the rules of the <a hre
f="/wiki/24_game" title="24 game">24 game</a>.
Show examples of solutions generated by the program.
C.F: <a href="/wiki/Arithmetic_Evaluator" title="Arithmetic Evaluator" cl
ass="mw-redirect">Arithmetic Evaluator</a>

<table id="toc" class="toc"><tr><td><div id="toctitle"><h2>Contents</h2></div>
<ul>
<li class="toclevel-1 tocsection-1"><a href="#ABAP">1</s
pan> ABAP</a></li>
<li class="toclevel-1 tocsection-2"><a href="#Argile">2 Argile</a></li>
<li class="toclevel-1 tocsection-3"><a href="#AutoHotkey">3 AutoHotkey</a></li>

<li class="toclevel-1 tocsection-4"><a href="#BBC_BASIC">4 BBC BASIC</a></li>
<li class="toclevel-1 tocsection-5"><a href="#C">5 C</a></li>
<li class="toclevel-1 tocsection-6"><a href="#C.2B.2B">6
 C++</a></li>
<li class="toclevel-1 tocsection-7"><a href="#Clojure">7
 Clojure</a></li>
<li class="toclevel-1 tocsection-8"><a href="#CoffeeScript">8 CoffeeScript</a></li>
<li class="toclevel-1 tocsection-9"><a href="#Common_Lisp">9 Common Lisp</a></li>
<li class="toclevel-1 tocsection-10"><a href="#D">10</sp
an> D</a></li>
<li class="toclevel-1 tocsection-11"><a href="#ERRE">11 ERRE</a></li>
<li class="toclevel-1 tocsection-12"><a href="#Euler_Math_Toolbox">12 Euler Math Toolbox</a></li>
<li class="toclevel-1 tocsection-13"><a href="#F.23">13 F#</a></li>
<li class="toclevel-1 tocsection-14"><a href="#Fortran">
14 Fortran</a></li>
<li class="toclevel-1 tocsection-15"><a href="#GAP">15 GAP</a></li>
<li class="toclevel-1 tocsection-16"><a href="#Go">16</s
pan> Go</a></li>
<li class="toclevel-1 tocsection-17"><a href="#Gosu">17 Gosu</a></li>
<li class="toclevel-1 tocsection-18"><a href="#Haskell">
18 Haskell</a>
<ul>
<li class="toclevel-2 tocsection-19"><a href="#Alternative_version">18.1 Alternative version</a></li
>
</ul>
</li>
<li class="toclevel-1 tocsection-20"><a href="#Icon_and_Unicon">19 Icon and Unicon</a></li>
<li class="toclevel-1 tocsection-21"><a href="#J">20</sp
an> J</a></li>
<li class="toclevel-1 tocsection-22"><a href="#Java">21 Java</a></li>
<li class="toclevel-1 tocsection-23"><a href="#JavaScript">22 JavaScript</a></li>
<li class="toclevel-1 tocsection-24"><a href="#jq">23</s
pan> jq</a></li>
<li class="toclevel-1 tocsection-25"><a href="#Julia">24
 Julia</a></li>
<li class="toclevel-1 tocsection-26"><a href="#Liberty_BASIC">25 Liberty BASIC</a></li>
<li class="toclevel-1 tocsection-27"><a href="#Lua">26 Lua</a></li>
<li class="toclevel-1 tocsection-28"><a href="#Mathematica_.2F_Wolfram_Language"
>27 Mathematica / Wolfram L
anguage</a></li>
<li class="toclevel-1 tocsection-29"><a href="#OCaml">28
 OCaml</a></li>
<li class="toclevel-1 tocsection-30"><a href="#Perl">29 Perl</a></li>
<li class="toclevel-1 tocsection-31"><a href="#Perl_6">3

0 Perl 6</a></li>
<li class="toclevel-1 tocsection-32"><a href="#Phix">31 Phix</a></li>
<li class="toclevel-1 tocsection-33"><a href="#PicoLisp">32 PicoLisp</a></li>
<li class="toclevel-1 tocsection-34"><a href="#ProDOS">3
3 ProDOS</a></li>
<li class="toclevel-1 tocsection-35"><a href="#Prolog">3
4 Prolog</a>
<ul>
<li class="toclevel-2 tocsection-36"><a href="#Minimal_version">34.1 Minimal version</a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-37"><a href="#Python">3
5 Python</a>
<ul>
<li class="toclevel-2 tocsection-38"><a href="#Difficult_case_requiring_precise_
division">35.1 Difficult ca
se requiring precise division</a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-39"><a href="#R">36</sp
an> R</a></li>
<li class="toclevel-1 tocsection-40"><a href="#Racket">3
7 Racket</a></li>
<li class="toclevel-1 tocsection-41"><a href="#REXX">38 REXX</a></li>
<li class="toclevel-1 tocsection-42"><a href="#Ruby">39 Ruby</a></li>
<li class="toclevel-1 tocsection-43"><a href="#Scala">40
 Scala</a></li>
<li class="toclevel-1 tocsection-44"><a href="#Sidef">41
 Sidef</a></li>
<li class="toclevel-1 tocsection-45"><a href="#Swift">42
 Swift</a></li>
<li class="toclevel-1 tocsection-46"><a href="#Tcl">43 Tcl</a></li>
<li class="toclevel-1 tocsection-47"><a href="#Ursala">4
4 Ursala</a></li>
<li class="toclevel-1 tocsection-48"><a href="#zkl">45 zkl</a></li>
</ul>
</td></tr></table>
<h2>[<a href="/mw/index.php?title=24_game/Solve&ac
tion=edit&section=1" title="Edit section: ABAP">edit</a>] <a href="/wiki/Category:ABAP" title="Category:ABAP">ABA
P</a></h2>
Will generate all possible solutions of any given four numbers according to t
he rules of the 24 game.
Note: the permute function was locally from <a href="/wiki/Permutations#A
BAP" title="Permutations">here</a>

<pre class="abap highlighted_source"><a href="http://help.sap.com/abapdocu/en/AB
APDATA.htm">data</a>: lv_flag
type c, 
lv_number <s
pan class="kw4">type i, 
lt_numbers <sp
an class="kw4">type table of i. <a href="http://help.sap.com/ab
apdocu/en/ABAPCONSTANTS.htm">constants</a>: c_no_val type i value 9999. <a
href="http://help.sap.com/abapdocu/en/ABAPAPPEND.htm">append</a> 1 to lt_numbers. <a href="http://help.sap.com/abapdocu/en/ABAPAPPEND.ht
m">append</a> 1 to lt_numbers. <a href="http://help.sap.
com/abapdocu/en/ABAPAPPEND.htm">append</a> 2 to lt_numbers. <a href="http://help.sap.com/abapdocu/en/ABAPAPPEND.htm">a
ppend</a> 7 to lt_numbe
rs. <a href="http://help.sap.com/abapdoc
u/en/ABAPWRITE.htm">write</a> 'Evalua
ting 24 with the following input: '. <a href="http://help.sap.com/abapdocu/en/ABAPLOOP.htm">loop</a> at lt_numbers into lv_number
. <a href="http://help.sap.com/abapdocu/en/ABAPWR
ITE.htm">write</a> lv_number. <a href="http://help.sap.com/abapdocu/en/ABAPENDLOOP.htm">
endloop</a>. <a href="http://help.sap.com/
abapdocu/en/ABAPPERFORM.htm">perform</a> solve_24 using lt_numbers. <a
href="http://help.sap.com/abapdocu/en/ABAPFORM.htm">form</spa
n></a> eval_formula using iv_eval typ
e string changing ev_ou
t type i. call function 'EVAL_FORMULA' "analysis of a syntactically correct formula 
exporting 
formula = iv_eval 
importing 
value
= ev_out 
exceptions others
= 1. <a href="http://help
.sap.com/abapdocu/en/ABAPIF.htm">if</a> sy-subrc <> 0. 
ev_out = -1. <a href
="http://help.sap.com/abapdocu/en/ABAPENDIF.htm">endif<
/a>. <a href="http://help.sap.com/abapdocu/en/ABAPE
NDFORM.htm">endform</a>. &
#160; " Solve a 24 puzzle. <a href="http:/
/help.sap.com/abapdocu/en/ABAPFORM.htm">form</a> solve_
24 using it_numbers like lt_nu
mbers. <a href="http://help.sap.com/abapdocu/en/A
BAPDATA.htm">data</a>: lv_flag
lv_op1
lv_op2
lv_op3
lv_var1
lv_var2
lv_var3
lv_var4
lv_eval
type string, 
lv_result type i, 
lv_var
type i. <a href="http://help.sap.com/abapdocu/en/ABAPDEFINE
.htm">define</a> retrieve_var.
 
read table it_numbers index &1 into lv_var. 
&2 = lv_var. <a href="http://help.sap.com/abapdocu/en/ABAPEND-OF-DEFINITION
.htm">end-of-definition</a>. <a href="http://help.sap.com/abapdocu/en/ABAPDEFINE.htm">define</a> retrieve_val. 
<a h
ref="http://help.sap.com/abapdocu/en/ABAPPERFORM.htm">perform</a> eval_formula using lv_eval changing lv_result. 
<a href="http://hel
p.sap.com/abapdocu/en/ABAPIF.htm">if</a> lv_result <spa
n class="sy1">= 24. 
<a href="http://help.sap.com/abapdocu/en/ABAPWRITE.htm">write</a> / lv_eval.
 
<a href="http://help.sap.com/abapdocu/en/ABAPENDIF.htm">endif</a>. <a href="http://help.sap.com
/abapdocu/en/ABAPEND-OF-DEFINITION.htm">end-of-definition</spa
n></a>. " Loop through all
the possible number permutations. <a href="http://help.sap.com/aba
pdocu/en/ABAPDO.htm">do</a>.
" Init. the operations table. 
retrieve_var: 1 lv_var1, 2 lv_var2, 3 lv_var3, 4 lv_var4. 
<a href="http://help.sa
p.com/abapdocu/en/ABAPDO.htm">do</a> 
4 times. 
<a h
ref="http://help.sap.com/abapdocu/en/ABAPCASE.htm">case
</a> sy-index. 
<a href="http://help.sap.com/abapdocu/en/ABAPWHEN.htm"><sp
an class="kw1">when</a> 1.</sp
an> 
lv_op1 = '+'
. 
<a href="http://help.sap.com/abapdocu/en/
ABAPWHEN.htm">when</a> 2. 
lv_op1 = '*'. 
<a href="http://help.sap
.com/abapdocu/en/ABAPWHEN.htm">when</a> 3. 
lv_op1 = '-'. 
<a href
="http://help.sap.com/abapdocu/en/ABAPWHEN.htm">when</a
> 4. 
lv_op1 <spa
n class="sy1">= '/'. 
<a href="http://help.sap.com/abapdocu/en/ABAPENDCASE.htm">endcase</a>. 
<a href="http://help.
sap.com/abapdocu/en/ABAPDO.htm">do</a> 4 times. 
<a href="http://help.sap.com/abapdocu/en/ABAPCASE.htm">case</s
pan></a> sy-index. 
<a href="http://help.sap.com/abapdocu/en/ABAPWHEN.htm"
>when</a> 1.
 
lv_op2 = '+'</s
pan>. 
<a href="http://help.sap.com/abapdocu
/en/ABAPWHEN.htm">when</a> 2<s
pan class="sy0">. 
lv_op2 = '*'. 
<a href="http://help
.sap.com/abapdocu/en/ABAPWHEN.htm">when</a> 3. 
lv_op2 = '-'. 
<a
href="http://help.sap.com/abapdocu/en/ABAPWHEN.htm">when</a> 4. 
lv_op2
= '/'. 
<a href="http://help.sap.com/abapdocu/en/ABAPENDCASE.htm">endcase</a>. 
<a href="http
://help.sap.com/abapdocu/en/ABAPDO.htm">do</a> 4 times. 
<a href="http://help.sap.com/abapdocu/en/ABAPCASE.htm">case</a> sy-index<sp
an class="sy0">. 
<a href="http://help.sap.com/abapdocu/en/A
BAPWHEN.htm">when</a> 1. 
lv_op3 = '+'. 
<a href="http://help.
sap.com/abapdocu/en/ABAPWHEN.htm">when</a> 2. 
lv_op3 = '*'. 
<a href="http://help.sap.com/abapdocu/en/ABAPWHEN.htm">when</s
pan></a> 3. 
lv
_op3 = '-'. 
<a href="http://help.sap.com/abapdocu/en/ABAPWHEN.htm"><spa
n class="kw1">when</a> 4.</spa
n> 
lv_op3 = '/'. 
<a href="http://help.sap.com/abapdocu/
en/ABAPENDCASE.htm">endcase</a>.</spa
n> 
<a href="http://help.sap.com/abapdocu/en/ABAPCONCATENATE.htm">concatenate</a> '(' '(' lv_var1 lv_op1 lv_var2 ')' lv_op2 lv_
var3 ')' lv_op3 lv_var4 into
lv_eval separated by space<spa
n class="sy0">. 
retrieve_val. 
<a href="http://help.sap.com/abapdocu/en/ABAPCONCATENATE.htm">concatenate</a> '(' lv_var1 lv_op1 lv_
var2 ')' lv_op2 '(' lv_var3 lv
_op3 lv_var4 ')' into lv_eval
separated by space. 
<a href="http://help.sap.com/abapdocu/en/ABAPCONCATENATE.htm">concatenate</a> '(' lv_var1 lv_op1 '(' lv_var2 lv_op2 lv_var3 ')' ')' lv_op3 lv_var4 into lv_eval separated by space
. 
<a h
ref="http://help.sap.com/abapdocu/en/ABAPCONCATENATE.htm">conc
atenate</a> lv_var1 lv_op1 '(' '(' lv_var2 lv_op2 lv_var3 ')' lv_op3 lv_var4 ')' into lv_eval separated by space. 
<a href="ht
tp://help.sap.com/abapdocu/en/ABAPCONCATENATE.htm">concatenate
</a> lv_var1 lv_op1 '(' lv_var2 lv_op2 '(' lv_var3 lv_op3 lv_var4 ')' ')' into lv_eval se
parated by space. 
.sap.com/abapdocu/en/ABAPENDDO.htm">enddo</a>. 
<a href="http://help.sap.com/abapdocu/en/ABAPENDDO.ht
m">enddo</a>. 
<a href=
"http://help.sap.com/abapdocu/en/ABAPENDDO.htm">enddo</
a>. 
" Once we
've reached the last permutation -> Exit. 
.sap.com/abapdocu/en/ABAPPERFORM.htm">perform</a> permu
te using it_numbers changing l
v_flag. 
<a href="http://help.sap.com/abapdocu/e
n/ABAPIF.htm">if</a> lv_flag =
'X'. 
<a href="http:
//help.sap.com/abapdocu/en/ABAPEXIT.htm">exit</a>. 
<a href="http://help.sap.com/abapdocu/en/ABAPENDIF.
htm">endif</a>. <a href=
"http://help.sap.com/abapdocu/en/ABAPENDDO.htm">enddo</
a>. <a href="http://help.sap.com/abapdocu/en/ABAPEN
DFORM.htm">endform</a>. &#
160; " Permutation function - this is used
to permute: " A = {A1...AN} -> Set of supp
lied variables. " B = {B1...BN - 1} -> Set
of operators. " Can be used for an unbounded s
ize set. Relies " on lexicographic ordering of
the set. <a href="http://help.sap.com/abapdocu/en/ABAPFORM.htm"><spa
n class="kw3">form</a> permute using iv_set <spa
n class="kw4">like lt_numbers 
changing
 ev_last type c. 
<a href="http://help.sap.com/abapdocu/en/ABAPDATA.htm">data</s
pan></a>: lv_len
type i<sp
an class="sy0">, 
lv_first type i<s
pan class="sy0">, 
lv_third type i, 
lv_count type i
, 
lv_temp
type
i, 
lv_temp_2 type
i, 
lv_second type i, 
lv_changed type</spa
n> c, 
lv_perm
type</sp
an> i. describe table iv
_set lines lv_len. lv_perm = lv_len - 1. lv_changed = ' '. " Loop backwards through the table, attempting to find elements
which " can be permuted. If we find one, bre
ak out of the table and set the " flag indic
ating a switch. <a href="http://help.sap.com/abapdocu/en/ABAPDO.htm
">do</a>. 
<a href="htt
p://help.sap.com/abapdocu/en/ABAPIF.htm">if</a> lv_perm
<= 0.</s
pan> 
<a href="http://help.sap.com/abapdocu/en/ABAPEXIT.htm">exit</a>. 
<a href="http://help.s
ap.com/abapdocu/en/ABAPENDIF.htm">endif</a>. 
" Read the elements. 
read table iv_set index lv_p
erm into lv_first. 
<a
href="http://help.sap.com/abapdocu/en/ABAPADD.htm">add<
/a> 1 to lv_perm. 
read table iv_set index lv_perm into lv_second
. 
<a href="http://help.sap.com/abapdocu/en/ABAPSUBTRACT.htm"><spa
n class="kw3">subtract</a> 1 f
rom lv_perm. 
<a href="http://help.sap.co
m/abapdocu/en/ABAPIF.htm">if</a> lv_first < lv_second. 
lv_changed = 'X'. 
<a href="http://help.sap.com/abapdocu/en/ABAPEXIT.htm">e
xit</a>. 
<a href="http://help.sap.com/ab
apdocu/en/ABAPENDIF.htm">endif</a>. 
<a href="http://help.sap.com/abapdocu/en/ABAPSUBTRACT.htm">subtract</a> 1 from

 lv_perm. <a href="http://help.sap.com/aba
pdocu/en/ABAPENDDO.htm">enddo</a>.</s
pan> " Last permutation. <a
href="http://help.sap.com/abapdocu/en/ABAPIF.htm">if</
a> lv_changed <> 'X'<spa
ev_last = 'X'. 
apdocu/en/ABAPEXIT.htm">exit</a>.</sp
an> <a href="http://help.sap.com/abapdocu/en/ABAPENDIF.htm">endif</a>. " Swap tail decresing to get a tail increasing. lv_count <sp
an class="sy1">= lv_perm + 1. <a href="http://help.sap.com/abapdocu/en/A
BAPDO.htm">do</a>. 
lv_
first = lv_len + lv_perm - lv_count + 1</s
pan>. 
<a href="http://help.sap.com/abapdocu/en/
ABAPIF.htm">if</a> lv_count >=</sp
an> lv_first. 
apdocu/en/ABAPEXIT.htm">exit</a>.</sp
an> 
<a href="http://help.sap.com/abapdocu/en/ABAPENDIF.htm">endif</a>. 
read table iv_set index lv_count into lv_temp. 
read table iv_set index lv_first into lv_temp_2. 
.sap.com/abapdocu/en/ABAPMODIFY.htm">modify</a> iv_set
index lv_count from lv_temp_2. 
<a href="http://help.sap.com/abapdocu/en/ABAPM
ODIFY.htm">modify</a> iv_set index</s
pan> lv_first from lv_temp. 
<a href="http://help.sap.com/abapdocu/en/ABAPADD.htm">ad
d</a> 1 to lv_count<spa
n class="sy0">. <a href="http://help.sap.com/abapdocu/en/ABAPENDDO.
htm">enddo</a>. lv_count = lv_len - 1. <a href="http://help.sap.com
/abapdocu/en/ABAPDO.htm">do</a>.</spa
n> 
<a href="http://help.sap.com/abapdocu/en/ABAPIF.htm">if</a> lv_count <= lv_perm. 
<a href="http://help.sap.com/abapdocu/en/ABAPEXIT.htm">exit</a>. 
<a href="http://h
elp.sap.com/abapdocu/en/ABAPENDIF.htm">endif</a>. 
read table iv_se
t index lv_count into lv_first
. 
read table iv_set <s
pan class="kw4">index lv_perm into lv_second<spa
read table iv_set index lv_len into lv_third. 
<a href="http://help.sap.com/abapdocu/en/ABAPIF.htm"><s
pan class="kw1">if</a> ( lv_first < lv_third ) an
d ( lv_first > l
v_second ). 
lv_l
en = lv_count. 
<a href
="http://help.sap.com/abapdocu/en/ABAPENDIF.htm">endif<
/a>. 
apdocu/en/ABAPSUBTRACT.htm">subtract</a> 1 from lv_count. <a href="http://help.sap.com/abapdocu/en/ABAPENDDO.htm">en

ddo</a>. read
table iv_set index lv_perm in
to lv_temp. read table iv_set index lv_len into
lv_temp_2. <a href="http://help.sap.com/abapdocu
/en/ABAPMODIFY.htm">modify</a> iv_set index lv_perm from lv_temp_2.
 <a href="http://help.sap.com/abapdocu/en/ABAPMODIFY.htm">modify</a> iv_set index lv_len from lv_temp. <a href="http://help
.sap.com/abapdocu/en/ABAPENDFORM.htm">endform</a>.</pre>
Sample Runs:

<pre style="height:30ex;overflow:scroll">
Evaluating 24 with the following input: 1 1 2 7
( 1 + 2 ) * ( 1 + 7 )
( 1 + 2 ) * ( 7 + 1 )
( 1 + 7 ) * ( 1 + 2 )
( 1 + 7 ) * ( 2 + 1 )
( 2 + 1 ) * ( 1 + 7 )
( 2 + 1 ) * ( 7 + 1 )
( 7 + 1 ) * ( 1 + 2 )
( 7 + 1 ) * ( 2 + 1 )
Evaluating 24
( ( 1 + 2 ) +
( 1 + ( 2 + 3
( ( 1 * 2 ) *
( 1 * 2 ) * (
( 1 * ( 2 * 3
1 * ( ( 2 * 3
1 * ( 2 * ( 3
( ( 1 * 2 ) *
( 1 * 2 ) * (
( 1 * ( 2 * 4
1 * ( ( 2 * 4
1 * ( 2 * ( 4
( ( 1 + 3 ) +
( 1 + ( 3 + 2
( 1 + 3 ) * (
( ( 1 * 3 ) *
( 1 * 3 ) * (
( 1 * ( 3 * 2
1 * ( ( 3 * 2
1 * ( 3 * ( 2
( 1 + 3 ) * (
( ( 1 * 3 ) *
( 1 * 3 ) * (
( 1 * ( 3 * 4
1 * ( ( 3 * 4
1 * ( 3 * ( 4
( ( 1 * 4 ) *
( 1 * 4 ) * (
( 1 * ( 4 * 2
1 * ( ( 4 * 2
1 * ( 4 * ( 2
( ( 1 * 4 ) *
( 1 * 4 ) * (
with the following input: 1

3 ) * 4
) ) * 4
3 ) * 4
3 * 4 )
) ) * 4
) * 4 )
* 4 ) )
4 ) * 3
4 * 3 )
) ) * 3
) * 3 )
* 3 ) )
2 ) * 4
) ) * 4
2 + 4 )
2 ) * 4
2 * 4 )
) ) * 4
) * 4 )
* 4 ) )
4 + 2 )
4 ) * 2
4 * 2 )
) ) * 2
) * 2 )
* 2 ) )
2 ) * 3
2 * 3 )
) ) * 3
) * 3 )
* 3 ) )
3 ) * 2
3 * 2 )
(
1
1
(
(
(
(
(
2
2
(
(
(
2
2
(
(
(
2
2
(
(
(
2
2
(
(
(
(
(
2
2
(
(
2
(
2
(
(
(
2
2
(
(
(
2
2
(
(
(
(
2
2
(
(
2
(
2
(
(
1
*
*
(
2
(
2
2
*
*
(
2
2
/
/
(
2
2
*
*
(
2
2
/
/
(
2
(
2
2
*
*
(
2
*
2
*
(
2
2
*
*
(
2
2
*
*
2
(
2
2
*
*
(
2
*
2
*
2
(
*
(
(
2
+
2
*
*
(
(
2
/
/
(
(
2
*
*
(
(
2
/
/
(
(
2
+
2
*
*
(
(
2
*
(
*
(
2
*
*
(
(
2
*
*
(
(
+
2
*
*
(
(
2
*
(
*
(
+
2
(
(
4
+
(
*
1
(
(
1
/
1
(
1
(
*
1
(
(
1
/
1
(
1
(
+
(
*
3
(
(
3
*
(
(
3
3
*
3
(
(
3
*
3
(
(
3
4
*
4
(
(
4
*
(
(
4
4
4
*
4
4
*
1
1
1
)
1
1
*
1
)
1
/
1
1
)
1
1
*
1
)
1
/
1
3
3
3
)
3
3
*
3
3
3
)
/
3
)
3
3
*
3
)
3
3
*
)
4
)
4
4
*
4
4
4
)
/
)
4
*
*
(
)
+
)
*
*
*
(
)
*
/
(
/
)
*
*
*
(
)
*
/
(
/
)
+
)
*
*
*
(
)
/
/
/
(
)
*
*
*
(
)
*
*
*
(
*
)
*
*
*
(
)
/
/
/
(
*
)
3
3
3
+
3
*
(
3
3
3
*
(
3
3
3
*
(
4
4
4
*
(
4
4
4
+
1
*
(
1
1
1
/
1
1
(
1
*
(
4
4
4
*
(
4
4
4
(
*
(
1
1
1
/
1
1
(
1
(
*
)
)
*
3
)
3
3
)
)
*
3
3
)
*
)
4
4
)
)
*
4
4
)
*
)
1
)
1
1
)
)
*
1
)
)
1
/
4
4
)
)
*
4
4
)
)
/
1
1
1
)
)
*
1
)
)
1
/
3
3
)
*
2
)
)
)
*
)
*
4
)
*
)
4
/
)
*
)
*
3
)
*
)
3
/
)
)
)
*
)
*
4
)
)
*
/
4
)
*
)
*
1
)
/
)
/
1
+
)
*
)
*
3
)
)
*
/
3
+
)
*
2
)
*
*
*
4
*
4
)
*
4
*
)
4
*
3
*
3
)
*
3
*
)
3
*
*
*
4
*
4
)
*
*
4
4
)
*
1
*
1
)
/
1
/
1
)
3
*
3
*
3
)
*
*
3
3
)
1
*
2
)
)
4
4
4
)
4
)
)
4
)
4
)
)
3
)
3
)
)
3
)
3
)
)
4
4
4
)
4
)
)
4
4
)
)
)
1
)
1
)
)
1
)
1
)
)
)
3
)
3
)
)
3
3
)
)
)
)
1
(
(
2
2
(
(
(
2
2
(
(
(
(
(
(
3
3
(
(
(
3
3
(
(
(
(
3
3
(
(
(
3
3
(
(
(
(
(
3
3
(
(
3
(
3
(
(
(
3
3
(
(
(
3
3
(
(
(
3
3
2
2
*
*
(
2
2
*
*
(
3
3
(
3
3
*
*
(
3
3
/
/
3
(
3
3
*
*
(
3
3
/
/
(
3
(
3
3
*
*
(
3
*
3
*
(
3
3
*
*
(
3
3
*
*
(
3
3
*
*
*
*
(
(
2
*
*
(
(
3
+
+
3
*
*
(
(
3
/
/
(
(
+
3
*
*
(
(
3
/
/
(
(
3
+
3
*
*
(
(
3
*
(
*
(
3
*
*
(
(
3
*
*
(
(
3
*
*
(
(
4
(
(
4
*
4
(
(
4
+
(
1
*
1
(
(
1
/
1
(
1
(
1
*
1
(
(
1
/
1
(
1
(
+
(
*
2
(
(
2
*
(
(
2
2
*
2
(
(
2
*
2
(
(
2
*
4
(
(
4
)
4
4
*
4
)
4
4
*
1
1
)
1
)
1
1
*
1
)
1
/
1
)
1
)
1
1
*
1
)
1
/
1
2
2
2
)
2
2
*
2
2
2
)
/
2
)
2
2
*
2
)
2
2
*
4
)
4
4
*
*
*
*
(
)
*
*
*
(
)
+
*
)
*
*
*
(
)
*
/
(
/
*
)
*
*
*
(
)
*
/
(
/
)
+
)
*
*
*
(
)
/
/
/
(
)
*
*
*
(
)
*
*
*
(
)
*
*
*
(
(
3
3
3
*
(
3
3
3
+
2
(
*
(
2
2
2
*
(
2
2
2
(
*
(
4
4
4
*
(
4
4
4
+
1
*
(
1
1
1
/
1
1
(
1
*
(
4
4
4
*
(
4
4
4
*
(
1
1
1
3
)
)
*
3
3
)
)
/
2
)
2
2
2
)
)
*
2
2
)
*
)
4
4
4
)
)
*
4
4
)
*
)
1
)
1
1
)
)
*
1
)
)
1
/
4
4
)
)
*
4
4
)
)
/
1
1
)
)
*
*
)
*
1
)
/
)
/
1
)
)
+
)
*
)
*
4
)
*
)
4
/
+
)
*
)
*
2
)
*
)
2
/
)
)
)
*
)
*
4
)
)
*
/
4
)
*
)
*
1
)
/
)
/
1
)
*
)
*
2
1
*
1
)
/
1
/
1
)
*
*
4
*
4
*
4
)
*
4
*
)
4
2
*
2
*
2
)
*
2
*
)
2
*
*
*
4
*
4
)
*
*
4
4
)
*
1
*
1
)
/
1
/
1
)
*
2
*
2
)
)
1
)
)
1
)
1
)
)
4
4
)
4
)
4
)
)
4
)
4
)
)
)
2
)
2
)
)
2
)
2
)
)
4
4
4
)
4
)
)
4
4
)
)
)
1
)
1
)
)
1
)
1
)
)
2
)
2
)
)
(
(
3
(
3
(
(
(
3
3
(
(
(
3
3
4
4
(
(
(
4
4
(
(
(
4
4
4
4
(
(
(
4
4
(
(
(
4
4
(
4
4
(
(
(
4
4
(
(
4
(
4
(
4
4
(
(
(
4
4
(
3
*
3
*
(
3
3
*
*
(
3
3
*
*
*
*
(
4
4
*
*
(
4
4
/
/
*
*
(
4
4
*
*
(
4
4
/
/
4
*
*
(
4
4
*
*
(
4
*
4
*
4
*
*
(
4
4
*
*
3
*
(
*
(
3
*
*
(
(
3
*
*
(
(
(
(
4
*
*
(
(
4
/
/
(
(
(
(
4
*
*
(
(
4
/
/
(
(
+
(
(
4
*
*
(
(
4
*
(
*
(
+
(
(
4
*
*
(
(
*
(
(
4
4
*
4
(
(
4
*
4
(
(
4
(
1
*
1
(
(
1
/
1
(
1
(
(
1
*
1
(
(
1
/
1
(
1
(
2
(
2
*
2
(
(
2
*
(
(
2
2
2
(
2
*
2
(
(
2
4
4
4
)
/
4
)
4
4
*
4
)
4
4
*
1
+
1
)
1
1
*
1
)
1
/
1
1
+
1
)
1
1
*
1
)
1
/
1
)
2
+
2
)
2
2
*
2
2
2
)
/
)
2
+
2
)
2
2
*
)
/
/
/
(
)
*
*
*
(
)
*
*
*
(
+
(
)
*
*
*
(
)
*
/
(
/
+
(
)
*
*
*
(
)
*
/
(
/
*
+
(
)
*
*
*
(
)
/
/
/
(
*
+
(
)
*
*
*
(
/
1
1
(
1
*
(
2
2
2
*
(
2
2
2
2
2
*
(
2
2
2
*
(
2
2
2
3
3
*
(
3
3
3
*
(
3
3
3
(
1
1
*
(
1
1
1
/
1
1
(
1
(
3
3
*
(
3
3
3
1
)
)
1
/
2
2
)
)
*
2
2
)
)
/
)
+
2
2
)
)
*
2
2
)
*
)
)
+
3
3
)
)
*
3
3
)
*
)
1
)
+
1
1
)
)
*
1
)
)
1
/
3
)
+
3
3
)
)
*
)
)
*
/
2
)
*
)
*
1
)
/
)
/
1
+
3
)
*
)
*
3
)
*
)
3
/
+
2
)
*
)
*
2
)
*
)
2
/
+
+
3
)
*
)
*
3
)
)
*
/
3
+
+
1
)
*
)
*
1
*
*
2
2
)
*
1
*
1
)
/
1
/
1
)
3
)
*
3
*
3
)
*
3
*
)
3
2
)
*
2
*
2
)
*
2
*
)
2
3
3
)
*
3
*
3
)
*
*
3
3
)
1
1
)
*
1
*
1
)
2
2
)
)
)
1
)
1
)
)
1
)
1
)
)
)
)
3
)
3
)
)
3
)
3
)
)
)
)
2
)
2
)
)
2
)
2
)
)
)
)
)
3
)
3
)
)
3
3
)
)
)
)
)
)
1
)
1
)
)
(
(
(
4
4
4
4
(
(
(
4
4
(
(
4
(
4
4
4
(
(
(
4
4
(
(
(
4
4
(
4
4
*
*
*
*
(
4
4
*
*
(
4
*
4
*
*
*
(
4
4
*
*
(
4
4
*
*
4
*
*
(
(
(
(
4
*
*
(
(
4
*
(
*
(
(
(
4
*
*
(
(
4
*
*
(
(
*
2
(
(
2
(
3
*
3
(
(
3
*
(
(
3
3
(
3
*
3
(
(
3
*
3
(
(
3
2
)
2
2
*
3
+
3
)
3
3
*
3
3
3
)
/
3
+
3
)
3
3
*
3
)
3
3
*
)
*
*
*
(
+
(
)
*
*
*
(
)
/
/
/
(
+
(
)
*
*
*
(
)
*
*
*
(
*
(
3
3
3
1
1
*
(
1
1
1
/
1
1
(
1
2
2
*
(
2
2
2
*
(
2
2
2
Evaluating 24
5 * ( 6 - ( 8
( 5 + 7 ) * (
( ( 5 + 7 ) ( 5 + ( 7 - 8
( ( 5 - 8 ) +
( 5 - ( 8 - 7
6 * ( ( 5 + 7
6 * ( 5 + ( 7
6 * ( ( 5 - 8
6 * ( 5 - ( 8
6 * ( ( 7 + 5
6 * ( 7 + ( 5
( 6 / ( 7 - 5
6 / ( ( 7 - 5
6 * ( ( 7 - 8
6 * ( 7 - ( 8
( 6 * 8 ) / (
6 * ( 8 / ( 7
( 6 - ( 8 / 7
( 7 + 5 ) * (
( ( 7 + 5 ) ( 7 + ( 5 - 8
( ( 7 - 8 ) +
( 7 - ( 8 - 5
( 8 - 6 ) * (
( 8 * 6 ) / (
8 * ( 6 / ( 7
( 8 - 6 ) * (
( 8 / ( 7 - 5
3
3
)
)
/
)
+
1
1
)
)
*
1
)
)
1
/
)
+
2
2
)
)
*
2
2
)
)
/
)
/
)
/
1
+
2
)
*
)
*
2
)
)
*
/
2
+
1
)
*
)
*
1
)
/
)
/
1
/
1
/
1
)
2
)
*
2
*
2
)
*
*
2
2
)
1
)
*
1
*
1
)
/
1
/
1
)
1
)
1
)
)
)
)
2
)
2
)
)
2
2
)
)
)
)
)
1
)
1
)
)
1
)
1
)
)
with the following input: 5 6 7 8

/ 7 ) )
8 - 6 )
8 ) * 6
) ) * 6
7 ) * 6
) ) * 6
) - 8 )
- 8 ) )
) + 7 )
- 7 ) )
) - 8 )
- 8 ) )
) ) * 8
) / 8 )
) + 5 )
- 5 ) )
7 - 5 )
- 5 ) )
) ) * 5
8 - 6 )
8 ) * 6
) ) * 6
5 ) * 6
) ) * 6
5 + 7 )
7 - 5 )
- 5 ) )
7 + 5 )
) ) * 6
8 / ( ( 7 - 5 ) / 6 )
</pre>
tion=edit&section=2" title="Edit section: Argile">edit</a>] <a href="/wiki/Category:Argile" title="Category:Arg
ile">Argile</a></h2>
<div class="examplemeta workswith">Works with: <a href="/wiki/Argile" tit
le="Argile" class="mw-redirect">Argile</a> version 1.0.0</div>
<pre class="text highlighted_source">die "Please give 4 digits as argument
1\n" if argc < 2 print a function that given four digits
argv[1] subject to the rules of \ the _24_ game, computes an expression to s
olve the game if possible. use std, array let digi
ts
be an array of 4 byte let operators be an array of 4 byte (: reord
ered arrays :) let (type of digits)
rdigits let (type of operato
rs) roperators .: a function that given four digits <text digi
ts> subject to the rules of the _24_ game, computes an expression to s
olve the game if possible.
:.
-> text if #digits != 4 {return "[error: need exactly 4 digit
s]"} operators[0] = '+' ; operators[1] = '-' operators[2]
= '*' ; operators[3] = '/' for each (val int d) from 0 to 3 
i
f (digits[d] < '1') || (digits[d] > '9') 
return "[error: no
n-digit character given]" 
(super digits)[d] = digits[d] let e
xpr = for each operand order stuff return "" if expr is nil 
expr .:for each operand order stuff:. -> text for each
(val int a) from 0 to 3 
for each (val int b) from 0 to 3 
next
if (b == a) 
for each (val int c) from 0 to 3 
next if (c =
= b) or (c == a) for each (val int d) from 0 to 3 
next if (d ==
c) or (d == b) or (d == a) rdigits[0] = digits[a] ; rdigits[1] = dig
its[b] 
rdigits[2] = digits[c] ; rdigits[3] = digits[d] 
let found = for each operator order stuff 
return found unless fo
und is nil nil .:for each operator order stuff:. -> text
 for each (val int i) from 0 to 3 
for each (val int j) from 0 to 3
 
for each (val int k) from 0 to 3 
roperators[0] = operator
s[i] 
roperators[1] = operators[j] 
roperators[2] = operator
s[k] 
let found = for each RPN pattern stuff 
return found if
found isn't nil nil our (raw array of text) RPN_patterns =
Cdata "xx.x.x." "xx.xx.." "xxx..x.&qu
ot; "xxx.x.." "xxxx..." our (raw array of te
xt) formats = Cdata "((%c%c%c)%c%c)%c%c" "(%c%c%c)%c(
%c%c%c)" "(%c%c(%c%c%c))%c%c" "%c%c((%c%c%c)%c%c
)" "%c%c(%c%c(%c%c%c))" our (raw array of array of 3 in
t) rrop = Cdata {0;1;2}; {0;2;1}; {1;0;2}; {2;0;1}; {2;1;0} .:for each RPN pattern stuff:. -> text let RPN_stack be an array of 4
real for each (val int rpn) from 0 to 4 
let (nat) sp=0, op=0, dg=0
. 
let text p 
for (p = RPN_patterns[rpn]) (*p != 0) (p++) 
if *p == 'x' 
if sp >= 4 {die "RPN stack overflow\n&q
uot;} 
if dg > 3 {die "RPN digits overflow\n"} 
RPN_stack[sp++] = (rdigits[dg++] - '0') as real 
if *p == '.' 
if sp < 2 {die "RPN stack underflow\n"} 
if op > 2 {di
e "RPN operators overflow\n"} 
sp -= 2 
let x = RPN_stac
k[sp] 
let y = RPN_stack[sp + 1] switch roperators[op++] 
case '+' {x += y} 
case '-' {x -= y} 
case '*' {x *=
y} 
case '/' {x /= y} 
default {die "RPN operat
or unknown\n"} 
RPN_stack[sp++] = x 
if RPN_stack[0] == 2
4.0 
our array of 12 byte buffer (: 4 paren + 3 ops + 4 digits + null&#
160;:) 
snprintf (buffer as text) (size of buffer) (formats[rpn])
\ 
(rdigits[0]) (roperators[(rrop[rpn][0])]) (rdigits[1])
\ 
(roperators[(rrop[rpn][1])]) (rdigits[2])
\ 
(roperators[(rrop[rpn][2])]) (rdigits[3]); 
return buffer as text nil</pre>
Examples:

<pre>$ arc 24_game_solve.arg -o 24_game_solve.c
$ gcc -Wall 24_game_solve.c -o 24_game_solve
$ ./24_game_solve 1234
((1+2)+3)*4
((5+7)-8)*6
(1+2)*(1+7)</pre>
tion=edit&section=3" title="Edit section: AutoHotkey">edit</a>] <a href="/wiki/Category:AutoHotkey" title="
Category:AutoHotkey">AutoHotkey</a></h2>
<div class="examplemeta workswith">Works with: <a href="/wiki/AutoHotkey_
L" title="AutoHotkey L" class="mw-redirect">AutoHotkey_L</a></div>
Output is in RPN.

<pre class="ahk highlighted_source"><a href="http://www.autohotkey.com/docs/comm
ands/_NoEnv.htm">#NoEnv</a> <a href="http://www.aut
ohotkey.com/docs/commands/InputBox.htm">InputBox</a><sp
an class="sy0">, NNNN
; user input 4 digits NNNN := <a href="http://www.autohotkey.com/docs/c
ommands/RegExReplace.htm">RegExReplace</a>(NNNN, "(\d)(?=\
d)", "$1,"</spa
n>) ; separate with commas for th
e sort command <a href="http://www.autohotkey.com/docs/commands/Sort.
htm">sort</a> NNNN, d`, ; sort in ascending order for the permutati
ons to work <a href="http://www.autohotkey.com/docs/commands/StringRe
place.htm">StringReplace</a> NNNN,</s
pan> NNNN, `,, , All ; remove comma separators after sorting
 ops := "+-*/&quo
t; patterns := [
"x x.x.x." 
,"x x.x x.." 
,"x x x..x." 
,"x x x.x.." 
,"x x x x..."
] ; build brutefor
ce operator list ("+++, ++-, ++* ... ///") a := b := c := 0 While (++a<5){ <spa
n class="kw1">While (++</s
pan>b<5&#
41;{ While (++c<5)
{ l := <a href="http://www.autohotke
y.com/docs/Functions.htm#BuiltIn">SubStr</a>(ops, a, <sp
an class="nu0">1) .
<a href="http://www.autohotkey.com/docs/Functions.htm#BuiltIn">SubStr</a>(ops, b
, 1)</sp

an> . <a href="http://www.autohotkey.com/docs/Functions
.htm#BuiltIn">SubStr</a>(o
ps, c, 1</sp
an>) ; build br
uteforce template ("x x+x+x+, x x+x x++ ... x x x x///") 
For each, pattern in patterns { 
<a href="http://www.autohotkey.com/docs/commands/Loop.h
tm">Loop</a> 3 
<a
href="http://www.autohotkey.com/docs/commands/StringReplace.htm">StringReplace</a>, pattern
, pattern, ., % <a
href="http://www.autohotkey.com/docs/Functions.htm#BuiltIn">S
ubStr</a>(l, <a hre
f="http://www.autohotkey.com/docs/Variables.htm#A_Index">A_Ind
ex</a>, 1) 
pat .= pattern "`n" } }c := 0 }b := 0 } <a href="http://www.autohot
key.com/docs/commands/StringTrimRight.htm">StringTrimRight</sp
an></a>, pat, pat, 1 ; remove trailing new
line ; permutate input. As th
e lexicographic algorithm is used, each permutation generated is uniqueWhile NNNN { 
<a href="http://www.autohotkey.com/docs/commands/StringSplit.htm">StringSplit</a>, N,
NNNN 
; substitute numbers in for x's and evaluate 
<a href="http://www.autohotkey.com/docs/commands/Loop.htm">Loop</a> Parse, pat, `n 
{ 
eval <sp
an class="sy0">:= <a href="http://www.autohotkey.com/docs/Variables.htm#A
_LoopField">A_LoopField</a> ; current
line 
<a href="http://www.autohotkey.com/docs/commands
/Loop.htm">Loop</a> 4 
<a href="http://www.autohotkey.com/docs/commands/StringReplace.htm">StringReplace</a>, eval,
 eval, x, % N%A_Index% ; substitute number for "x&
quot; 
If <a href="http://www.
autohotkey.com/docs/Functions.htm#BuiltIn">Round</a><sp
an class="br0">(evalRPN(eval), 4) = 24 
final .= eval "`n" 
} 
NNNN <sp
an class="sy0">:= perm_next(NNNN) ; next lexicographic permutation of user's
digits } <a href="http://www.autoho
tkey.com/docs/commands/MsgBox.htm">MsgBox</a> % fi
nal ? <a href="http://www.autohotkey.com/docs/Variables.htm#Clipboard"><spa
n class="kw2">clipboard</a> := final : <spa
n class="st0">"No solution" ;
simple stack-based evaluation. Integers only. Whitespace is used to push a value
. evalRPN(s){ stack := [] 
<a href="http://
www.autohotkey.com/docs/commands/Loop.htm">Loop</a> Par
se, s 

If <a h
ref="http://www.autohotkey.com/docs/Variables.htm#A_LoopField">A_LoopField</a> is number 
t .= <a href="http://www.autohotkey.com/docs/Variables.htm#A_LoopField">A_LoopField</a> 
else 
If t 
stack.
Insert(t), t := <spa
n class="st0">"" 
If</sp
an> <a href="http://www.autohotkey.com/docs/Functions.htm#BuiltIn">InStr</a>("+-/*&
quot;, l := <a href="ht
tp://www.autohotkey.com/docs/Variables.htm#A_LoopField">A_Loop
Field</a>) 
{ 
a := stack.Remove(), b :=
stack.Remove() 
stack.Insert(
l = "+" ? b 
+ a 
:l = "-" ? b -
a 
:l = <s
pan class="st0">"*" ? b * a 
:l = "/" ? b <s
pan class="sy0">/ a 
:0
) 
} 
return stack.Remove<sp
an class="br0">() 
} perm_Next&#
40;str){ 
p := 0,</spa
n> sLen := <a href="http://www.autohotkey.com/docs/Func
tions.htm#BuiltIn">StrLen</a>(</s
pan>str) 
<a href="http://www.autohotkey.c
om/docs/commands/Loop.htm">Loop</a> % sLen 
If <a h
ref="http://www.autohotkey.com/docs/Variables.htm#A_Index">A_I
ndex</a>=1 
<a href="http://www.autohotkey.com/docs/commands/Continue.htm">continue</a> 
t := <a href="h
ttp://www.autohotkey.com/docs/Functions.htm#BuiltIn">SubStr</s
pan></a>(str, sLen+1-<a href="h
ttp://www.autohotkey.com/docs/Variables.htm#A_Index">A_Index</a>, 1
) 
n := <a href="http://ww
w.autohotkey.com/docs/Functions.htm#BuiltIn">SubStr</a>
(str, sLen+2-<a href="http://ww
w.autohotkey.com/docs/Variables.htm#A_Index">A_Index</a
>, 1)</s
pan> 
If (</spa
n> t < n ) 
p := sLen+1
-<a href="http://www.autohotkey.com/docs/Variables.htm#A_Index">A_Index</a>, pC :=</s

pan> <a href="http://www.autohotkey.com/docs/Functions.htm#BuiltIn">SubStr</a>(str,</spa
n> p, 1)
 
<a href="http://www.autohotkey.com/docs/commands
/Break.htm">break</a> 
} 
If !p 
return false 
<a href="http://www.autohotkey.com/docs/commands/Loop.htm">Loop</a> 
t := <a href="http://www.autohotkey.com/docs/Functions.
htm#BuiltIn">SubStr</a>(st
r, sLen+1</s
pan>-<a href="http://www.autohotkey.com/docs/Variables.
htm#A_Index">A_Index</a>, <spa
n class="nu0">1) 
If ( t ></spa
n> pC ) 
{
 
n := sLen+1-<a href="http://
www.autohotkey.com/docs/Variables.htm#A_Index">A_Index<
/a>, nC := <a href="http://www
.autohotkey.com/docs/Functions.htm#BuiltIn">SubStr</a>(str, n, 1) 
<a href="http://www.autohotkey.com/docs/commands/Break.htm">br
eak</a> 
} 
return <a href="http://
www.autohotkey.com/docs/Functions.htm#BuiltIn">SubStr</
a>(str, 
1, p-
1) . nC . Reverse(<a href="http://www.autohot
key.com/docs/Functions.htm#BuiltIn">SubStr</a>(str, p+<s
pan class="nu0">1, n-p-1) . pC . <a href="http://www.
autohotkey.com/docs/Functions.htm#BuiltIn">SubStr</a><s
pan class="br0">(str, n+1)&
#41; } Reverse(s){</spa
n> <a href="http://www.autohotkey.com/docs/commands/Loop.htm">Loop</a> Parse, s 
o := <a href="http://www.autohotkey.com/docs/Variables.htm#A_Lo
opField">A_LoopField</a> o 
return o }</pre>
<div>
<dl><dt>Output:</div>for 1127:
</dt></dl>
<pre>
1 2+1 7+*
1 2+7 1+*
1 7+1 2+*
1 7+2 1+*
2 1+1 7+*
2 1+7 1+*
7 1+1 2+*
7 1+2 1+*</pre>
And for 8338:


<pre>8 3 8 3/-/</pre>
tion=edit&section=4" title="Edit section: BBC BASIC">edit</a>] <a href="/wiki/Category:BBC_BASIC" title="Cat
egory:BBC BASIC">BBC BASIC</a></h2>
<pre class="text highlighted_source"> 
PROCsolve24("1234&quo
t;) 
PROCsolve24("6789") 
PROCsolve24("1127&quo
t;) 
PROCsolve24("5566") 
END 
D
EF PROCsolve24(s$) 
LOCAL F%, I%, J%, K%, L%, P%, T%, X$, o$(), p$(), t
$() 
DIM o$(4), p$(24,4), t$(11) 
o$() = "", "+
", "-", "*", "/" 
RESTORE 
FOR T% = 1 TO 11 
READ t$(T%) 
NEXT 
DATA "abc
defg", "(abc)defg", "ab(cde)fg", "abcd(efg)",
"(abc)d(efg)", "(abcde)fg" 
DATA "ab(cdefg)&q
uot;, "((abc)de)fg", "(ab(cde))fg", "ab((cde)fg)",
"ab(cd(efg))" 
FOR I% = 1 TO 4 
FOR J%
= 1 TO 4 
FOR K% = 1 TO 4 
FOR L% = 1 TO 4 
IF I%<>J% IF J%<>K% IF K%<>L% IF I%<>K% IF J%&
lt;>L% IF I%<>L% THEN 
P% += 1 
p
$(P%,1) = MID$(s$,I%,1) 
p$(P%,2) = MID$(s$,J%,1) 
p$(P%,3) = MID$(s$,K%,1) 
p$(P%,4) = MID$(s$,L%,1)
ENDIF 
NEXT 
NEXT 
NEXT 
NEXT 
FOR I% = 1 TO 4 
FOR J% = 1 TO 4 
FOR K% = 1 TO 4 
FOR T% = 1 TO 11 
FOR P% = 1 TO 24 
X$ = t$(T%) 
MID$(X$, I
NSTR(X$,"a"), 1) = p$(P%,1) 
MID$(X$, INSTR(X$,&quo
t;b"), 1) = o$(I%) 
MID$(X$, INSTR(X$,"c"), 1)
= p$(P%,2) 
MID$(X$, INSTR(X$,"d"), 1) = o$(J%) 
MID$(X$, INSTR(X$,"e"), 1) = p$(P%,3) 
MID$(X$, INSTR(X$,"f"), 1) = o$(K%) 
MID$(X$,
INSTR(X$,"g"), 1) = p$(P%,4) 
F% = TRUE : ON
ERROR LOCAL F% = FALSE 
IF F% IF EVAL(X$) = 24 THEN PRINT X$&
#160;: EXIT FOR I% 
RESTORE ERROR 
NEXT 
NEXT 
NEXT 
NEXT 
NEXT 
IF
I% > 4 PRINT "No solution found" 
ENDPROC </pre
>
<div>
<dl><dt>Output:</div>
</dt></dl>
<pre>
(1+2+3)*4
6*8/(9-7)
(1+2)*(1+7)
(5+5-6)*6
</pre>
tion=edit&section=5" title="Edit section: C">edit</a>] <a href="/wiki/Category:C" title="Category:C">C</a></h
2>
This is a solver that's generic enough to deal with more than 4 numbers,
goals other than 24, or different digit ranges.
It guarantees a solution if there is one.
Its output format is reasonably good looking, though not necessarily optimal.

<pre class="c highlighted_source">#include <stdio.h></sp
an> #include <stdlib.h> #include <time.h> #define n_cards
4 #define solve_goal 24 #define max_digit 9 typedef <s

pan class="kw4">struct { 
int num, denom; } frac_t, *</s
pan>frac; typedef enum { C_NUM = 0, C_ADD, C_SUB, C_MUL, C_DI
V } op_type; typedef struct expr_t *expr; typede
f struct expr_t { 
op_type op; 
expr left, right; 
i
nt value; } ex
pr_t; void show
_expr(expr e, op_type prec
, int is_right) { 
const char * op; 
switch(e->op) <sp
an class="br0">{ 
case C_NUM<spa
n class="sy0">:
<a href="http://www.opengroup.org/onlinepubs/00969539
9/functions/printf.html">printf</a>&#
40;"%d", e<sp
an class="sy0">->value)
; 
return; 
case C_ADD
:
op = " + "</sp
an>; break; 
case C_SUB:
op = " - "; break;
case C_MUL:
op
= " x "; break; 
case C_DIV:
op = " / "; break; 
} 
if <s
pan class="br0">((e-&g
t;op == prec &&
is_right) || e->op < prec) <a href="http://www.opengroup.org/onlinepubs/009695399/functions/printf.h
tml">printf</a>("(");</s
pan> 
show_expr(e->
left, e->op, 0); 
<a href="http://www.opengroup.org/onlinepubs/00
9695399/functions/printf.html">printf</a>("%s", op); 
show_ex
pr(e->right, e->op, 1); 
if ((e->op ==
prec && is_right)

|| e->op 
< prec) <a href="http://www.opengroup.org
/onlinepubs/009695399/functions/printf.html">printf</a>
(")"); }
 void eval_expr(expr e, frac f) { 
frac_t left,
right; 
if (e->op ==</s
pan> C_NUM) { 
f->num = e<spa
n class="sy0">->value; 
f->denom = 
1; 
return; 
} 
eval_expr(e->l
eft, &left); 
eval_expr
(e->right, &right); 
switch (e->op) { 
case C_ADD: 
f->num = left.num * right.
denom + left.denom * right.num->denom = left.denom 
* right.denom; 
return; 
case C_SUB: 
f->num = left.num * right.denom</sp
an> - left.denom * right.num; 
f->denom = l
eft.denom * right.denom; 
return; 
case</s
pan> C_MUL: 
f-&gt
;num = left.num * right.num;
 
f->denom =</s
pan> left.denom * right.denom; 
return; 
c
ase C_DIV: 
f->num = left.num * right.denom
; 
f->denom = left.denom * righ
t.num; 
<sp
an class="kw1">return; 
default: 
<a href="http:
//www.opengroup.org/onlinepubs/009695399/functions/fprintf.html">fprintf</a>(stderr,</sp
an> "Unknown op: %d\n"
, e->op); 
return; 
} } int solve
(expr ex_in[], int len) { 
<s
pan class="kw4">int i, j;</spa
n> 
expr_t node; 
expr ex[n_cards]; 
frac_t final; 
if (len 
== 1) { 
eval_expr(ex
_in[0&#9
3;, &final); 
if (final.num
== final.denom * solve_goal && final.denom) {
show_expr(ex_in[0]<sp
an class="sy0">, 0, <sp
an class="nu0">0); 
return 1<
}</s
pan> 
return 0</sp
an>; 
} &#
160; 
for (i <s
pan class="sy0">= 0; i
< len - 1
; i++
) { 
for (j = i + 1; j <sp
an class="sy0">< len; j++) 
ex[j - 1] = ex_in[</s
pan>j]; 
ex[i] = &node; 
for (j = i + 1<sp
an class="sy0">; j < len; j++) { 
node.left
= ex_in[i]; 
node.right = ex_in[j]; 
for (node.<spa
n class="me1">op = C_ADD;</spa
n> node.op <= C_DIV; node.op++<s
pan class="br0">) 
if (solve(ex
, len - 1</s
pan>)) 
return 1

; 
node.<s
pan class="me1">left = ex_in&#
91;j]; 
node.right = e
x_in[i]; 
node.op = C_SUB; 
if (solve(ex, len - 1))
return 1;</s
pan> 
node.op = C_DIV; 
if (solve(ex, len - 1)) return 1; 
ex[j] = ex_in[</sp
an>j]; 
ex[i] = ex_in[i]; 
} 
return 0; } int solve24<spa
n class="br0">(int n[]) { 
int i; 
expr_t ex[n_cards]; 
expr e[n_cards];
 
for (i = 0; i <spa
n class="sy0">< n_cards; i+
+) { 
e[i] = ex + i;
ex[i]</spa
n>.op = C_NUM; 
ex[i].left = ex[i].right = 0; 
ex[i&#9
3;.value = n[i]; 
return</s
pan> solve(e, n_cards); }
 int main() { 
int i, j, n[] = { 3<sp
an class="nu0">8, 8<spa
n class="sy0">, 9 }; 
<a href="http://www.opengroup.org/online
pubs/009695399/functions/srand.html">srand</a>(<a href="http://www.opengroup.org/onlinepubs/009695399/func
tions/time.html">time</a>(
0)); 
for</s
pan> (j = 0; j < 10; j++) { 
for (i = 0; i < n_cards; i++) { 
n[i] = 1 + (double) <a h
ref="http://www.opengroup.org/onlinepubs/009695399/functions/rand.html">rand</a>() * max_digit / RAND_MAX<s
pan class="sy0">; 
<a href="http://www.opengro
up.org/onlinepubs/009695399/functions/printf.html">printf</spa
n></a>(" %d", n[i&#
93;); 
<a href="http://www.o
pengroup.org/onlinepubs/009695399/functions/printf.html">print
f</a>(": "</spa
n>); 
<
a href="http://www.opengroup.org/onlinepubs/009695399/functions/printf.html"><sp
an class="kw3">printf</a>(solve24(n) ? <s
pan class="st0">"\n" : "No solution\n"); 
} 
return
0; &#12
5;</pre>
<div>
</dt></dl>
<pre> 1 8 2 1: 1 x 8 x (2 + 1)
6 8 2 8: 6 + 8 + 2 + 8
4 2 8 1: (4 - 2 + 1) x 8
3 1 9 9: (9 - 1) / (3 / 9)
5 7 5 1: No solution
5 8 4 1: (5 + 1) x (8 - 4)
8 3 4 9: 8 + 3 + 4 + 9
3 7 4 4: ((3 + 7) - 4) x 4
5 6 4 1: 4 / (1 - 5 / 6)
5 5 9 8: 5 x 5 - 9 + 8</pre>
For the heck of it, using seven numbers ranging from 0 to 99, trying to calcu
late 1:

<pre> 54 64 44 67 60 54 97: (54 + 64 + 44) / 54 + 60 / (67 - 97)
83 3 52 50 14 48 55: 55 - (((83 + 3 + 52) - 50 + 14) - 48)
70 14 26 6 4 50 19: ((70 + 14 + 26) / 4 - 19) x 6 - 50
75 29 61 95 1 6 73: 6 / (73 - ((75 + 29 + 61) - 95)) - 1
99 65 59 54 29 3 21: 3 - (99 + 65 + 54) / (59 + 29 + 21)
88 57 18 72 60 70 22: (72 - 70) x (60 + 22) - (88 + 57 + 18)
73 18 76 44 32 3 49: 32 / (49 - (44 + 3)) - ((73 + 18) - 76)
36 53 68 12 82 30 8: ((36 + 53 + 68) - 82) / 30 - 12 / 8

83 35 81 82 99 40 36: ((83 + 35) x 81 - 82 x 99) / 40 / 36
29 43 57 18 1 74 89: (1 + 74) / (((29 + 43) - 57) / 18) - 89</pre>
tion=edit&section=6" title="Edit section: C++">edit</a>] <a href="/wiki/Category:C%2B%2B" title="Category:C++"
>C++</a></h2>
<div class="examplemeta workswith">Works with: <a href="/wiki/C%2B%2B11"
title="C++11" class="mw-redirect">C++11</a></div>
<div class="examplemeta workswith">Works with: <a href="/wiki/GCC" title=
"GCC" class="mw-redirect">GCC</a> version 4.8</div>
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 thes
e parameters, with the belief they are complete.

<pre class="cpp highlighted_source"> #include <io
stream> #include <ratio> #include <array> #include <alg
orithm> #include <random> &#160
; typedef short int Digit; // Typedef
for the digits data type. constexpr Digit nDigits{4}
;
// Amount of digits that are t
aken into the game. constexpr Digit maximumDigit&#1
23;9}; // Maximum digit that may be taken into the game
. constexpr short int</spa
n> gameGoal{24};
// Desired r
esult. typedef std::array<Digit, nD
igits> digitSet; // Typedef for the set of digits in the game. digitSet d; void printTrivialO
peration(std::string operation) &#
123; // Prints a commutative operation taking all the d
igits. 
bool printOperation(false)<s
pan class="sy4">; for&#
40;const Digit& num
ber : d) { 
if&#4
0;printOperation) 
std::cout &l
t;< operation; 
else 
printOperation = true; 
std::cout << number; 
br/>
std::cout << std::endl; } void printOperation(std<spa
n class="sy4">::string prefix, std::string operation1, std::
string operation2, std::string operation3, std::string suffix = &
quot;") {

 std::cout << prefix << d[0] << operation1 << d[1] <s
pan class="sy1"><< operation2 << d<s
pan class="br0">[2]</s
pan> << operation3 <<</sp
an> d[3&
#93; << suffix << std::endl; } int main() <s
pan class="br0">{ 
std::mt19937_64 randomGenerator; 
std::uniform_int_distribution<Digit> digitDistro{1, maximumDigit}; // Let us set
up a number of trials: 
for(int trial{</sp
an>10};
 trial; --trial) { 
for(Digit& digit : d) =
digitDistro(randomGenerator)
; 
std::cout << digit <spa
n class="sy1"><< " "; 
std::cout &l
t;< std::endl::sort(d.begin(), d.end()); 
// We start with the most trivial, commutative operations: 
if(std::
accumulate(d.cbegin(), d.cend(), 0) <sp
an class="sy1">== gameGoal) 
printTrivialOperation(" + &q
uot;); 
if(std::
accumulate(d.cbegin(), d.cend(), 1, std::<s
pan class="me2">multiplies<Digit>{}<s
pan class="br0">) == gameGoal) 
printTrivialOperation&
#40;" * ")// Now let's s
tart working on every permutation of the digits. 

do { 
// Operations with 2 symbols + and one symbol -: 
if(d&#91
;0] + d[1] + d[<s
pan class="nu0">2] - d[3&#9
3; == gameGoal) pri
ntOperation("",
" + ", " + "</spa
n>, " - "); // If gameGoal is ever changed to a small
er value, consider adding more operations in this category. 
// Operations with 2 symbols + and one symbol *: 
2">* d[1] + d[<s
pan class="nu0">2] + d[3&#9
3; == gameGoal) pri
" * ", " + "</spa
n>, " + ")if(d[0</spa
n>] * &#
40;d[1] + d[<spa
n class="nu0">2])</spa
n> + d[3
] == gameGoal) printOperation("", " * ( ", " + ", " ) + "<spa
n class="br0">); 
2">* (d[1] + d<s
pan> + d[3]) == gameGoal) printOperation("", &q
uot; * ( ", " + ", " + ", " )"// Operations with one symbol + and 2 symbols *: 
if((
d[0] * d[1] * d<s
pan>) + d[3] ("( ", 
" * ", " * ", " ) + ");</s
pan> 
0;d[0] * d[1] * (d[2] + d[3]) == gameGoal&#41
; printOperation("( &
quot;, " * ", "
* ( ", " + ", 
" )"); 
if((d[
0] * d[1]) + (d[2&#93
; * d[3]) == gameGoal) printOperation("( ", " * ", " ) + ( ", " * ", " )"); 
// Operations with one symbol - and 2 symbols *: 
if((
d[0] * d[1] * d<s
pan>) - d, " * ", " ) - ");</s
pan> 
class="nu0">1] * (d[2] - d[3]) == gameGoal&#41
; printOperation("( &
quot;, " * ", "
* ( ", " - ", 
" )"); 
>(d[
0] * d[1]) - (3]) == gameGoal) printOperation("( ", " * ", " ) - ( &quotquot;, <s
pan class="st0">" * ", " )"); 
// Operations with one symbol +, one symbol *, and one symbol
-: 
class="nu0">1] + d
[2] - d[3] == gameGoal<s
pan class="br0">) printOperation("", " * ", " + ", " - "<spa
n class="br0">); 
2">* (d[1] + d<s
pan>) - d("", &q
uot; * ( ", " + ", " ) - ");</s
pan> 
r0">] * (d[1] - d[2]) + d[3] == gameGoal&#41
; printOperation("&qu
ot;, " * ( ", "
- ", " ) + "&#
41;; 
if(d[0] * <spa
n class="br0">(d[1</sp
an>] + d
[2] - d[3]) == gameGoal) printOperation("", " * ( ", " + ", " - &qu
ot;, " )")if</sp
an>(d[0] * d[1] <spa
n class="sy2">- (d[</s
pan>2] +
 d[3]) == gameGo
al) printOperation(<sp
an class="st0">"", " * ", <s
pan class="st0">" - ( ", " + "</spa

n>, " )")// Operations
with one symbol *, one symbol /, one symbol +: 
="br0">] == (ga
meGoal - d[3]) * d[2<spa
n class="br0">]) printOperation, " / ", " ) + ");</s
pan> 
0;((d[0] <sp
an class="sy2">* d[1]) 
+ d[2]) == gameG
oal * d[
3]) printOperat
ion("(( ", " * ", " ) + ",
" ) / ")((d[0] + d[1]) * d<spa
n class="br0">[2]</spa
n> == gameGoal * d[3]) printOperation("(( ", " + ", " ) * ", " ) / "<
="br0">] == gameGoal *</sp
an> (d[2] + d[3]<spa
n class="br0">)) printOperation, " ) / ( ", " + ", " )"); 
// Operations with one symbol *, one symbol /, one symbol -: 
nu0">1] == (gameGoal + d&#9
1;3]) * d[2])
printOperation("( "</s

pan>, " * ", " / &quot
;, " ) - ")</spa
n>; 
an>(((d[0] * d[1]) - d[2]) == gameGoal * d[3]
) printOperation(&quot
;(( ", " * ", &
quot; ) - ", " ) / "if((d
[0] - d[1]) * d[2<spa
n class="br0">] == gameGoal * d[3]) printOperation("(( ", "
- ", " ) * ", &
quot; ) / "); 
nu0">1] == gameGoal
* (d&#9
1;2] - d[3]))
printOperation("( "</s
pan>, " * ", " ) / ( &
quot;, " - ", "
)"); 
// Operations with 2 symbols *, one symbol /: 
="br0">] * d[<s
pan class="nu0">2] ==</spa
n> gameGoal * d[3]) pri
" * ", " * "</spa
n>, " / ")(d[0</spa
n>] * d&
#91;1] == gameGoal * d[</sp
an>2] * d[3]) printOperation&#4
0;"", " * &quot
;, " / ( ", " *
", " )"); 
// Ope
rations with 2 symbols /, one symbol -: 
if(d[
0] *</sp
#93; == gameGoal * <spa
n class="br0">(d[1</sp
an>] * d
[3] - d[2]))</sp
an> printOperation("", " / ( ", " - &q
uot;, " / ", "
)"); 
// Operations with 2 symbols /, one symbol *: 
="br0">] == gameGoal *</sp
#93; * d[3]) pri
ntOperation("( "
, " * ", " / "</s
pan>, " ) / ", ""
); 
} while
(std::next_permutation</sp
an>(d.begin(), d.end<sp
an class="br0">())
); // All operations are repeated for all possible permutations of the numbers. 
return
 0; } </pre>
<div>
</dt></dl>
<pre>
8 3 7 9
3 * ( 7 + 9 - 8 )
3 * ( 9 + 7 - 8 )
1 4 3 1
( 3 * 4 * ( 1 + 1 )
( 4 * 3 * ( 1 + 1 )
5 4 3 6
6 * ( 3 + 5 - 4 )
6 * ( 5 + 3 - 4 )
2 5 5 8
5 4 7 3
3 * 4 + 5 + 7
3 * 4 + 7 + 5
( 3 * 4 * ( 7 - 5 )
3 * ( 5 + 7 - 4 )
3 * ( 7 + 5 - 4 )
4 * 3 + 5 + 7
4 * 3 + 7 + 5
( 4 * 3 * ( 7 - 5 )
4 * 5 + 7 - 3
5 * 4 + 7 - 3
5 * ( 7 - 3 ) + 4
3 3 9 2
2 * 9 + 3 + 3
3 * ( 2 + 3 ) + 9
3 * ( 2 + 9 - 3 )
3 * ( 3 + 2 ) + 9
3 * ( 9 - 2 ) + 3
3 * ( 9 + 2 - 3 )
9 * 2 + 3 + 3
3 2 7 9
3 * ( 7 - 2 ) + 9
(( 7 + 9 ) * 3 ) / 2
(( 9 + 7 ) * 3 ) / 2
7 1 5 3
7 6 9 4
(( 7 + 9 ) * 6 ) / 4
(( 9 + 7 ) * 6 ) / 4
3 5 3 1
( 1 * 3 * ( 3 + 5 )
( 1 * 3 * ( 5 + 3 )
( 3 * 1 * ( 3 + 5 )
( 3 * 1 * ( 5 + 3 )
(( 3 + 5 ) * 3 ) / 1
(( 5 + 3 ) * 3 ) / 1
</pre>
tion=edit&section=7" title="Edit section: Clojure">edit</a>] <a href="/wiki/Category:Clojure" title="Category:
Clojure">Clojure</a></h2>
<pre class="clojure highlighted_source">(ns rosettacode.24game.
solve (:require</spa
n> [clojure.math.combinatorics :as c] 
[clojure.walk :as w])) (def ^:private op-maps (map #&#4
0;zipmap [:o1 :o2 :o3
] %) (c/selectio
ns '(* +
 - /&
#41; 3))) (def ^:private patterns '( (:o1 (:
o2 :n1 :n2) (:<sp
an class="me1">o3 :n3 :n4)) (:o1 :n1 (:o2 :<sp
an class="me1">n2 (:o3</sp

an> :n3 :n4))) (:o1 (:o2 (:<sp
an class="me1">o3 :n1 :n2) :n3<spa
n class="br0">) :n4&#
41;)) &#160
; (defn play24 [& digits&#
93; {:pre <s
pan class="br0">(and (
every? #(not= 0 %) digits) 
(=
(count digits) 4))} 
(->> (<sp
an class="kw1">for [:let [digit-maps 
(->> digits sort c/permutations
(map
 #(zipmap [:n1 :n2</sp
an> :n3 :n4] %)<s
pan class="br0">))&#93
; 
om op-maps, dm digit-maps] 
(w/prewalk-repla
ce dm 
(w/p
rewalk-replace om patterns))) 
(filter #(= (eval %) 24)) 
(map println)
 
doall 
count</s
pan>))</pre>
The function <code>play24</code> works by substituting the given digits and t
he 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 (t
he function) are used to substitute in operations and digits, which are replaced
into the tree patterns.

tion=edit&section=8" title="Edit section: CoffeeScript">edit</a>] <sp
an class="mw-headline" id="CoffeeScript"><a href="/wiki/Category:CoffeeScript" t
itle="Category:CoffeeScript">CoffeeScript</a></h2>
<pre class="coffeescript highlighted_source"> # This
program tries to find some way to turn four digits into an arithmetic # expression that adds up to 24. # # Example solution for 5, 7, 8, 8: #
(((8 + 7) * 8) / 5) so
lve_24_game = (digits...)</sp

an> -> # Create an array of
objects for our helper functions arr = for
digit in digits 
{ 
val: digit 
expr
: digit 
} combo4 arr... &
#160; combo4 = (a, b, c, d) -> arr = [a, b, c
, d] # Reduce this to a three-node problem by combining two # nodes from the array. permutations = &
#91; 
[0<spa
n class="sy0">, 1, <spa
n class="nu0">2, 3] 
[0, 2, 1, 3] 
[<s
pan class="nu0">0, 3<sp
an class="nu0">2] 

[1, 2, 0, 3] 
<spa
n class="br0">[1, 3, 0<s
pan class="sy0">, 2] 
[2, 3, 0, 1] ] for
 permutation in permutations 
[i, j, k<spa
n class="sy0">, m] = permutation 
<sp
an class="kw1">for combo in combos arr[i], ar
r[j] 
answer
= combo3 combo, arr[k], arr[m] 
answer if answer null combo3 = (a,
b, c) > arr = [a, b, c] permutations
= [ 
[0, 1, 2] 
[0, 2, 1] 
[1, 2, 0] ] for permutation
in permutations 
[
i, j, k]
 = permutation 
for combo in combos arr[i]</s
pan>, arr[j] 
answer = combo2 combo, arr<sp
an class="br0">[k] 
return answer if answer null combo2 = (a, b) -></sp
an> for combo in combos
a, b 
return combo.<spa
n class="me1">expr if combo.va
l == 24 null 
 combos = (a, b) -> [ 
val: a.val + b.val 
expr<sp
an class="sy0">: "(#{a.expr} + #{b.expr})"</s
pan> , 
val: a.<s
pan class="me1">val * b.val</s
pan> 
expr: "(#{a.expr} *
#{b.expr})" , 
val: a.val - b.<spa
n class="me1">val 
expr: "(#{a.expr} - #{b.expr})" , 
val: b.val - a.val 
expr:</sp
an> "(#{b.expr} - #{a.expr})" , 
val: a.val / b.val 
expr<sp
an class="sy0">: "(#{a.expr} / #{b.expr})"</s
pan> , 
val: b.<s
pan class="me1">val / a.val</s
pan> 
expr: "(#{b.expr} /
#{a.expr})" , ] # test do -> rand_digit = -> 1 + Math.floor
(9 *</sp
an> Math.random()) for i in [<sp
an class="nu0">1..15]</spa
n> 
a = rand_digit() 
b = rand_digit(&#41
; 
c = rand_digit(&
#41; 
d = rand_digit() 
solution = solve_24_game a, b<sp
an class="sy0">, c, d 
console.log "Solution for #{[a,b,c,d]}: #{solution
? 'no solution'}" </pre>
<div>
</dt></dl>
<pre>
> coffee 24_game.coffee
Solution for 8,3,1,8: ((1 + 8) * (8 / 3))
Solution for 6,9,5,7: (6 - ((5 - 7) * 9))
Solution for 4,2,1,1: no solution
Solution for 3,5,1,3: (((3 + 5) * 1) * 3)
Solution for 6,4,1,7: ((7 - (4 - 1)) * 6)
Solution for 8,1,3,1: (((8 + 1) - 1) * 3)
Solution for 6,1,3,3: (((6 + 1) * 3) + 3)
Solution for 7,1,5,6: (((7 - 1) * 5) - 6)

Solution for 4,2,3,1: ((3 + 1) * (4 + 2))
Solution for 8,8,5,8: ((5 * 8) - (8 + 8))
Solution for 3,8,4,1: ((1 - (3 - 8)) * 4)
Solution for 6,4,3,8: ((8 - (6 / 3)) * 4)
Solution for 2,1,8,7: (((2 * 8) + 1) + 7)
Solution for 5,2,7,5: ((2 * 7) + (5 + 5))
Solution for 2,4,8,9: ((9 - (2 + 4)) * 8)
</pre>
tion=edit&section=9" title="Edit section: Common Lisp">edit</a>] <spa
n class="mw-headline" id="Common_Lisp"><a href="/wiki/Category:Common_Lisp" titl
e="Category:Common Lisp">Common Lisp</a></h2>
<pre class="lisp highlighted_source">(defconstant +
ops+ '(* / + -)) (defun digits (</spa
n>) (sort (loop repeat 4 collect (1+ (random 9)
)) #'<)) (defun expr
-value (expr) (eval</spa
n> expr)) (defun divides-by-zerop (expr) (when (</sp
an>consp expr) 
<sp
an class="br0">(destructuring-bind (op &rest args) expr 
(or 
(divides-by-zero-p (ca
r args)) 
(and (eq op '/)
 
(or <s
pan class="br0">(and (
= 1 &
#40;length args)<sp
an class="br0">) 
(zerop (expr-value (car args)))) 
(some (lambda (arg) 
(or
(divides-by-zero-p arg) 
(zerop (expr-value</sp
an> arg)))) 
<sp
an class="br0">(cdr args&#
41;)))))
)) <spa
n class="br0">(defun solvable-p (digits &optional expr) (unless 
(divides-by-zero-p expr) 
(if digits 
(destructuring-bind (next &rest rest) digits 
(if expr 
(some (lambda (op) 
(solvable-p rest <s
pan class="br0">(cons op &
#40;list next expr)
))&#
41; 
+ops+) 
(solvable-p rest (</sp
an>list (car +ops+) next)</spa
n>))
) 
(when</spa
n> (and expr 
(eql 24 (expr-value
expr))) 
(merge-exprs expr)))</s
pan>)) 
(defun merge-exprs (expr) (if (atom expr) 
expr 
(destructuring-bind (o
p &rest args) expr 
(if (and (member op '(* +)) 
(= 1 (length args)</sp
an>)) 
<s
pan class="br0">(car args&
#41; 
(cons</sp
an> op 
(case</s
pan> op 
(&#40
;* +) 
(loop for arg in args 
for merged = (merge-exprs arg) 
when (and (consp merged) 
(eq</sp
an> op (car merged)))</spa
n> 
append 
(cdr merged) 
else collect merged)) 
(t <sp
an class="br0">(mapcar #'merge-exprs args<sp
an class="br0">)))
))))) (defun solve24-game (digits) "Generate a lisp form using the
operators in +ops+ and the given digits which evaluates to 24. The first f
orm found is returned, or NIL if there is no solution." <s
pan class="br0">(solvable-p digits))</pre>
<div>
</dt></dl>
<pre>
CL-USER 138 > (loop repeat 24 for soln = (solve-24-game (digits)) when soln d
o (pprint soln))
(+ 7 5 (* 4 3))
(* 6 4 (- 3 2))
(+ 9 8 4 3)
(* 8 (- 6 (* 3 1)))
(* 6 4 (/ 2 2))
(* 9 (/ 8 (- 8 5)))
NIL
</pre>
tion=edit&section=10" title="Edit section: D">edit</a>] <a href="/wiki/Category:D" title="Category:D">D</a></
h2>
This uses the Rational struct and permutations functions of two other Rosetta
Code Tasks.

<div class="examplemeta translation">Translation of: <a href="/wiki/24_ga
me/Solve#Scala" title="24 game/Solve">Scala</a></div>
<pre class="d highlighted_source">import std.stdio, std.algorithm, std.range, std.conv, std.<sp
an class="kw4">string, 
std.concurrency, permutations2, arithmetic_rational; string solve(i
n int target, in int[<sp
an class="br0">] problem) { 
static stru
ct T { Rational r;
string e; &
#125; 
Generator!T computeAllO
perations(in Rational[] L)
 { 
return</sp
an> new typeof(return)({ 
if (!L.empty) &#
123; 
immutable x = L[0]; 
if (L.length == 1) { 
yield(T(x, x.text)&#41
;; 
} else { 
foreach (<spa
n class="kw4">const o; computeAllOperations(L.dropOne&#4
1;) { 
immutable y =</sp
an> o.r; 
auto sub = [T(x * y, "*"), T(x + y, "+"
), T(x - y, "-")&#
if (y) sub ~= [T&#40
;x / y, "/")]</sp
fore
ach (const e; sub) 
yield(T(e.r, format(</sp
an>"(%s%s%s)", x<spa
n class="sy0">, e.e, o.
e))); 
&#1
25; 
});
fore
ach (const p; problem.map!</spa
n>Rational.array.permutations!false) 
foreach (const sol; computeAllOperatio
ns(p)) 
if &#40
;sol.r == target) 
return sol.
e; 
r
eturn "No solution";
 } voi
d main() { 
foreach (const prob; [[6, 7,</s
pan> 9, 5</s
pan>], &
#91;3, 3, 8, 8], [1, 1, 1, 1]])
writeln(prob, ": ", solve(24, prob<s
pan class="br0">));</s
pan> }</pre>
<div>
</dt></dl>
<pre>[6, 7, 9, 5]: (6+(9*(7-5)))
[3, 3, 8, 8]: (8/(3-(8/3)))
[1, 1, 1, 1]: No solution</pre>
tion=edit&section=11" title="Edit section: ERRE">edit</a>] <a href="/wiki/Category:ERRE" title="Category:ERRE">ER
RE</a></h2>
ERRE hasn't an "EVAL" function so we must write an evaluation routine; this t
ask is solved via "brute-force".

<pre class="text highlighted_source"> PROGRAM 24SOLVE L
ABEL 98,99,2540,2550,2560 ! possible brackets CONST NBRACKETS
=11,ST_CONST$="+-*/^(" DIM D[4],PERM[24,4] DIM BRAK
ETS$[NBRACKETS] DIM OP$[3] DIM STACK$[50] PROCEDURE COMPA
TTA_STACK IF NS>1 THEN 
R=1 
WHILE R<NS DO 
IF INSTR(ST_CONST$,STACK$[R])=0 AND INSTR(ST_CONST$,STACK$[R+1])=0 THEN
FOR R1=R TO NS-1 DO 
STACK$[R1]=STACK$[R1+1] 
END FOR 
NS=NS-1 
END IF 
R=
R+1 
END WHILE END IF END PROCEDURE PROCEDURE
CALC_ARITM 
L=NS1 
WHILE L<=NS2 DO 
IF STACK$[L]=
"^" THEN 
IF L>=NS2 THEN GOTO 99 END IF 
N1#=VAL(STACK$[L-1]) N2#=VAL(STACK$[L+1]) NOP=NOP-1 
IF STACK
$[L]="^" THEN 
RI#=N1#^N2# 
END IF
STACK$[L-1]=STR$(RI#) 
N=L 
WHILE N
<=NS2-2 DO 
STACK$[N]=STACK$[N+2] 
N=N+1 
END WHILE 
NS2=NS2-2 
L=NS1-1 
END IF 
L=L+1 
END WHILE 
L=NS1 
IF STACK$[L]="*" OR STACK$[L]=&q
uot;/" THEN 
IF L>=NS2 THEN GOTO 99 END IF 
IF STACK$[
L]="*" THEN 
RI#=N1#*N2# 
ELSE 
IF N2#<>0 THEN RI#=N1#/N2# ELSE NERR=6 RI#=0 END IF 
END IF 
N=L 
WHILE N<=NS2-2 DO 
N=N+1 
END WHILE 
NS2=NS2-2 
L=NS1-1 
END IF 
L=L+1 
END WHILE &#1
60; 
L=NS1 
IF STACK$[L]="+&
quot; OR STACK$[L]="-" THEN 
EXIT IF L>=NS2 
IF
STACK$[L]="+" THEN RI#=N1#+N2# ELSE RI#=N1#-N2# END IF 
N=L 
WHILE N<=NS2-2 DO 
N=N+1 
END WHILE 
NS2=NS2-2 
L=NS1-1 
END IF
 
L=L+1 
END WHILE 99: 
IF NOP<2 THEN !
precedenza tra gli operatori 
DB#=VAL(STACK$[NS1]) 
ELSE
 
IF NOP<3 THEN 
DB#=VAL(STACK$[NS1+2]) 
ELSE 
DB#=VAL(STACK$[NS1+4]) 
END IF
END IF END PROCEDURE PROCEDURE SVOLGI_PAR NPA=
NPA-1 FOR J=NS TO 1 STEP -1 DO 
EXIT IF STACK$[J]="(" END FOR IF J=0 THEN 

NS1=1 NS2=NS CALC_ARITM NERR=7 
ELSE 
FOR R=J TO NS-1 DO 
STACK$[R]=STACK$[R+1] 
END FOR 
NS1=J NS2=NS-1 CALC_ARITM 
IF NS1=2 THEN 
NS1=1 STACK$[1]=STACK$[2] 
END IF 
NS=NS1 
COMPATTA_STACK END IF END PROCEDURE PROCEDURE
MYEVAL(EXPRESSION$,DB#,NERR->DB#,NERR) 
NOP=0 NPA=0 NS=1 K
$="" NERR=0 
STACK$[1]="@"
! init stac
k 
FOR W=1 TO LEN(EXPRESSION$) DO 
LOOP 
CODE=ASC(MID$(EXPRESSION$,W,1)) 
IF (CODE>=48 AND CODE<
=57) OR CODE=46 THEN 
K$=K$+CHR$(CODE) 
W=
W+1 IF W>LEN(EXPRESSION$) THEN GOTO 98 END IF 
ELSE 
EXIT IF K$="" 
IF NS>1 OR (NS=1 AND
STACK$[1]<>"@") THEN NS=NS+1 END IF 
IF FLAG=
0 THEN 
STACK$[NS]=K$ 
ELSE 
STACK$[NS]=STR$(VAL(K$)*FLAG) 
END IF 
K$="" FLAG=0 
EXIT 
END IF 
END LOOP 
IF CODE=43 THEN K$="+" END I
F 
IF CODE=45 THEN K$="-" END IF 
IF CODE=42 THE
N K$="*" END IF 
IF CODE=47 THEN K$="/" END IF 
IF CODE=94 THEN K$="^" END IF 
CASE CO
DE OF 
43,45,42,47,94-> ! +-*/^ 
IF MID$(E
XPRESSION$,W+1,1)="-" THEN FLAG=-1 W=W+1 END IF 
IF I
NSTR(ST_CONST$,STACK$[NS])<>0 THEN 
NERR=5 
ELSE 
NS=NS+1 STACK$[NS]=K$ NOP=NOP+1 
IF NOP>=2 THEN 
FOR J=NS TO 1 STEP -1 DO 
IF STACK$[J]<>"(" THEN GOTO 2540 END IF 
IF J<NS-2 THEN GOTO 2550 ELSE GOTO 2560 END IF 25
40:
END FOR 2550:
NS1=J+1 NS2=NS CALC_ARITM 
NS=NS2 STACK$[NS]=K$ 
REGISTRO_X#=VA
L(STACK$[NS-1]) 
END IF 
END IF 2560:
END -> 
40-> ! ( 
IF NS&gt
;1 OR (NS=1 AND STACK$[1]<>"@") THEN NS=NS+1 END IF 
STACK$[NS]="(" NPA=NPA+1 
IF MID$(EXPRESSION$,W+1
,1)="-" THEN FLAG=-1 W=W+1 END IF 
END -> 
41-> ! ) 
SVOLGI_PAR 
IF NE
RR=7 THEN 
NERR=0 NOP=0 NPA=0 NS=1 
ELSE 
IF NERR=0 OR NERR=1 THEN 
DB#=VAL
(STACK$[NS]) 
REGISTRO_X#=DB# 
E
LSE 
NOP=0 NPA=0 NS=1 
END IF 
END IF 
END -> 
OTHERWISE
NERR=8 
END CASE 
K$="" E
ND FOR 98: IF K$<>"" THEN 
IF NS>1 OR (
NS=1 AND STACK$[1]<>"@") THEN NS=NS+1 END IF 
IF FLAG
=0 THEN STACK$[NS]=K$ ELSE STACK$[NS]=STR$(VAL(K$)*FLAG) END IF END IF IF INSTR(ST_CONST$,STACK$[NS])<>0 THEN 
NERR=6
 
ELSE 
WHILE NPA<>0 DO 
SVOLGI_PAR 
END WHILE 
IF NERR<>7 THEN NS1=1 NS2=NS CALCARIT
M END IF 
END IF 
NS=1 NOP=0 NPA=0 END
PROCEDURE BEGIN PRINT(CHR$(12);) ! CLS ! possible brackets DATA("4#4#4#4") DATA(&quot
;(4#4)#4#4") DATA("4#(4#4)#4") DATA("4#4#(4#4)
") DATA("(4#4)#(4#4)") DATA("(4#4#4)#4") DATA("4#(4#4#4)") DATA("((4#4)#4)#4") D
ATA("(4#(4#4))#4") DATA("4#((4#4)#4)") DATA(&q
uot;4#(4#(4#4))") FOR I=1 TO NBRACKETS DO 
READ(BRAKETS$[I])
 END FOR INPUT("ENTER 4 DIGITS: ",A$) 
ND=0 FOR I=1 TO LEN(A$) DO 
C$=MID$(A$,I,1) 
IF INSTR(&
quot;123456789",C$)>0 THEN 
ND=ND+1 
D[ND]=VAL(C$)
 
END IF END FOR ! precompute permutations. dumb way
. NPERM=1*2*3*4 N=0 FOR I=1 TO 4 DO 
FOR J=1 TO 4
DO 
FOR K=1 TO 4 DO 
FOR L=1 TO 4 DO 
&#
160;! valid permutation (no dupes) 
IF I<>J AND I<&g
t;K AND I<>L AND J<>K AND J<>L AND K<>L THEN 
N=N+1 ! actually,we can as well permute given digits 
PERM[N,1]=D[I] 
PERM[N,2]=D[J] 
PERM[N,3]=D[K] 
PERM[N,4]=D[L] 
END IF 
END FOR 
END FOR 
END FOR 
END FOR ! operations: full search COUNT=0 
OPS$="+-*/" FOR OP1=1 TO 4 DO 
OP$[1]=MID$(OPS$,OP1,
1) 
FOR OP2=1 TO 4 DO 
OP$[2]=MID$(OPS$,OP2,1) 
F
OR OP3=1 TO 4 DO 
OP$[3]=MID$(OPS$,OP3,1) 
!
substitute all brackets 
FOR T=1 TO NBRACKETS DO 
TMPL$=BRAKETS$[T] 
! now,substitute all digits: perm
utations. 
FOR P=1 TO NPERM DO 
RES$=&
quot;" 
NOP=0 
ND=0 
FOR I=1 TO LEN(TMPL$) DO 
C$=MID$(TMPL
$,I,1) 
CASE C$ OF 
"
#"->
! operations 
NO
P=NOP+1 
RES$=RES$+OP$[NOP] 
END -> 
"4"->
&#
160;! digits 
ND=NOP+1 
RES$=RES$+MID$(STR$(PERM[P,ND]),2) 
END ->
OTHERWISE
! brackets goes here 
RES$=RES$+C$ 
END CASE 
END FOR 
! eval here 
MY_EVAL(RES$,DB#,NERR->DB#,NERR) 
IF DB#=
24 AND NERR=0 THEN 
PRINT("24=";RES$) 
COUNT=COUNT+1 
END IF 
END FOR 
END FOR 
END FOR 
END FOR 
END FOR 
IF COUNT=0 THEN 
PRINT("If you s
ee this, probably task cannot be solved with these digits") 
ELSE
PRINT("Total=";COUNT) 
END IF END PROG
RAM </pre>
<div>
</dt></dl>
<pre>
ENTER 4 DIGITS: ? 6759
24=6+(7-5)*9
24=6+((7-5)*9)
24=6+9*(7-5)
24=6+(9*(7-5))
24=6-(5-7)*9
24=6-((5-7)*9)
24=(7-5)*9+6
24=((7-5)*9)+6
24=6-9*(5-7)
24=6-(9*(5-7))
24=9*(7-5)+6
24=(9*(7-5))+6
Total= 12
</pre>
tion=edit&section=12" title="Edit section: Euler Math Toolbox">edit</a>]</sp
an> <a href="/wiki/Category:Eu
ler_Math_Toolbox" title="Category:Euler Math Toolbox">Euler Math Toolbox</a></sp
an></h2>
Via brute force.

<pre class="text highlighted_source"> >function try24 (v) ... $
n=cols(v); $if n==1 and v[1]~=24 then $ "Solved the problem",

 $ return 1; $endif $loop 1 to n $ w=tail(v,2); $ loop 1
to n-1 $
h=w; a=v[1]; b=w[1]; $
w[1]=a+b; if try24(w); "&quot
;+a+"+"+b+"="+(a+b), return 1; endif; $
w[1]=a-b; if
try24(w); ""+a+"-"+b+"="+(a-b), return 1; endif;$
w[1]=a*b; if try24(w); ""+a+"*"+b+"="+(a*b
), return 1; endif; $
if not b~=0 then $
w[1]=a/b; if try24(w)
; ""+a+"/"+b+"="+(a/b), return 1; endif; $
endif; $
w=rotright(w); $ end; $ v=rotright(v); $end; $
return 0; $endfunction </pre>
<pre class="text highlighted_source"> >try24([1,2,3,4]); Solve
d the problem 6*4=24 3+3=6 1+2=3 >try24([8,7,7,1]); S
olved the problem 22+2=24 14+8=22 7+7=14 >try24([8,4,7,1])
; Solved the problem 6*4=24 7-1=6 8-4=4 >try24([3,4,5
,6]); Solved the problem 4*6=24 -1+5=4 3-4=-1 </pr
e>
 

tion=edit&section=13" title="Edit section: F#">edit</a>] <a href="/wiki/Category:F_Sharp" titl
e="Category:F Sharp">F#</a></h2>
The program wants to give all solutions for a given set of 4 digits.
It eliminates all duplicate solutions which result from transposing equal digits
.
The basic solution is an adaption of the OCaml program.

<pre class="fsharp highlighted_source">open System 
 let rec gcd x y <sp
an class="sy0">= if x =
y || x = 0 
then y else if x < y then gcd y x else gcd y (x-y<s
pan class="br0">) let 
abs (x : int<s
pan class="br0">) = Math.A
bs x let sign (x: int) = Math.Sign x let cint s = Int32.Parse(s) 
 type Rat(x&#160
;: int, y : int) = 
let</s
pan> g = if y = 0 then 0 else gcd (abs x) &#
40;abs y) 
member this.n = if g = 0 then sign y <spa
n class="sy0">* sign x else</s
pan> sign y * x / g // store a minus sign in the numerator
 
member this.d = 
if y 
= 0 then 0 else sign y * y / g 

s
tatic member (~-) (</sp
an>x : Rat) = Rat<spa
n class="br0">(-x.n
, x.d) 
static member (</sp
an>+) &#
40;x : Rat, y : Rat) = Rat(x.n <spa
n class="sy0">* y.d + y
.n * x.d</sp
an>, x.d * y.d) 
static
member (
-) (x : Ra
t, y : Rat) = x + Rat(-y.n, y.d&#4
1; 
static member (*&#41
; (x : Rat, y : Rat) = Rat(x.<s
pan class="me1">n * y.n
, x.d * y.d) 
static <sp
an class="kw1">member (/) (x : Rat,
y : Rat) = x * Rat(y.d
, y.n) 
interface System.IComparable with 
member this.CompareTo o = 

match o with 
| :? Rat as that -> compare (this.n * that.<sp
an class="me1">d) (</s
pan>that.n * this.d) 
| _ > invalidArg "o" "cannot compare values of differnet types." 
override this.Equals</s
pan>(o) = 
match o with
 
| :? Rat as that -> this.n = tha
t.n && this.d = that.d 
| _ -> false 
overr
ide this.ToString() = 
if this.d = <spa
n class="nu0">1 then this.n</s
pan>.ToString() 
else sprintf @"<%d,%d>" this.n this.d 
new
(x : string, y : string) = if y = "" then Rat(cint x, <s
pan class="nu0">1) else</s
pan> Rat(cint x, cint y)</spa
n> type expression = 
| Const of Rat 
| Sum of expression * expression 
| Diff
of expression * expression 
| Prod of expression * e
xpression 
| Quot of expression * expression let rec eval = function
 
| Const c -> c 
| Sum (f, g) -> eval f + eval g 
| Diff(
f, g) -> eval f
- eval g 
| Prod(f,
g) -> eval f * eval g 
| Quot(f, g) -> eval f 
/ eval g let print_expr expr <spa
n class="sy0">= 
let concat (s : seq<</sp
an>string>) = System.<a href="http://research.microso
ft.com/en-us/um/cambridge/projects/fsharp/manual/namespaces.html">String</a>.Concat s 
let paren p prec op_prec = i
f prec > op_prec then p else "" 
let rec print prec = function 
| Const c -> c.ToString(</s
pan>) 
| Sum(f,
g) -> 
conc
at [ (paren "(" prec 0&#
41;; (print 0 f); <s
pan class="st0">" + "; (print 0 g); (paren 
")" prec 0)</spa
n> ] 
| Diff(f,
conc
pan class="st0">" - "; (f,
conc
pan class="st0">" * "; (f,
conc
pan class="st0">" / "; 0 expr let rec normal
expr = 
let norm epxr = 
match expr with 
| Sum(x, y) -> if</s
pan> eval x <= eval y then
expr else Sum(normal y, no
rmal x) 
| Prod(x, y) -> if eval x <= eval y then expr else Prod(</sp
an>normal y, normal x) 
| _ -> expr 
match expr with 
| Const c -> expr 
| Sum(x, y) -> norm (Sum&#4
0;normal x, normal y))
 
| Prod(x, y) -> norm (Prod<sp
an class="br0">(normal x, normal y)(x, y) -> Diff&#
40;normal x, normal y) 
| Quot(x, y) -&gt
; Quot(normal x, normal y&
#41; let rec</s
pan> insert v = function 
| [] -> [[v<s
pan class="br0">]] 
| x::xs as li -> (
v::li) :: (<a href="http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manua
l/namespaces.html">List</a>.map (fun y -> x::y) (i
nsert v xs)) &#160
; let permutations li = 
<a href="http://research.microsoft.com/en-us/um/cambridge/projects/fsharp
/manual/namespaces.html">List</a>.fol
dBack (fun x z <spa
n class="sy0">-> <a href="http://research.microsoft.com/en-us/um/cambr
idge/projects/fsharp/manual/namespaces.html">List</a>.concat (<a href="http://res
earch.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/namespaces.html">List</a>.map 
(insert x) z)</spa

n>) li [[]] let rec comp expr
rest = seq &
#123; 
match rest with 
| x::xs -> 
yield! comp (Sum (
expr, x)) xs<sp
an class="sy0">; 
yield! comp (Diff(x, expr)) xs; 
yield! comp (Diff<sp
an class="br0">(expr, x)) xs; 
yield!
 comp (Prod(exp
r, x)) xs; 
yield! comp (Quot(x, expr)</s
pan>) xs; 
<spa
n class="kw1">yield! comp (Quot(expr, x))</s
pan> xs; 
| [] -> if</sp
an> eval expr = Rat(24,1) then yield print_expr (normal expr) } [<EntryPoint>]</spa
n> let main argv = 
let digits = <a href="http://
research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/namespaces.html
">List</a>.init 4 (fun i -> Const (Rat(argv.[i]
,""))) 
let solutions = 
permutations digits 
|> <a href="http://research.microsoft.com/enus/um/cambridge/projects/fsharp/manual/namespaces.html">Seq</s
pan></a>.groupBy (sprintf
"%A") 
|> <a href="http://research.microsoft.com/en-us/um
/cambridge/projects/fsharp/manual/namespaces.html">Seq<
/a>.map snd 
|> <a href="http://research.microsoft.com/en-us/um/cambridge/projects/
fsharp/manual/namespaces.html">Seq</a>.map <a href="http://research.microsoft.com/en-us/um/cambridge/projects/
fsharp/manual/namespaces.html">Seq</a>.head 
|> <a href="http://researc
h.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/namespaces.html">Seq</a>.map (
fun x -> comp (<a href="http://research.microsoft.com/en-us/um/cambridg
e/projects/fsharp/manual/namespaces.html">List</a>.<spa
n class="me1">head x) &#40
;<a href="http://research.microsoft.com/en-us/um/cambridge/projects/fshar
p/manual/namespaces.html">List</a>.ta
il x)) 

|> <a href="http://research.microsoft.com/en-us/
um/cambridge/projects/fsharp/manual/namespaces.html">Seq</a>.choose (fun x -> if <a
href="http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/n
amespaces.html">Seq</a>.isEmpty x then None else Some x|> <a href="ht
tp://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/namespaces
.html">Seq</a>.concat 
if <a href="http://research.microsoft.com/en-us/um/camb
ridge/projects/fsharp/manual/namespaces.html">Seq</a>.isEmpty solutions then 
printfn "No solutions." 
else 
solutions 
|> <a href="http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/
manual/namespaces.html">Seq</a>.group
By id 
|> <a href="http://research
.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/namespaces.html">Seq</a>.iter (
fun x -> printfn <sp
an class="st0">"%s" (fst x)) 
0</pre>
<div>
</dt></dl>
<pre>>solve24 3 3 3 4
4 * (3 * 3 - 3)
3 + 3 * (3 + 4)
>solve24 3 3 3 5
No solutions.
solve24 3 3 3 6
6 + 3 * (3 + 3)
(3 / 3 + 3) * 6
3 * (3 + 6) - 3
3 + 3 + 3 * 6
>solve24 3 3 8 8
8 / (3 - 8 / 3)
>solve24 3 8 8 9
3 * (9 - 8 / 8)
(9 - 8) * 3 * 8
3 / (9 - 8) * 8
8 / ((9 - 8) / 3)
3 * (9 - 8) * 8
3 * 8 / (9 - 8)
3 / ((9 - 8) / 8)</pre>
tion=edit&section=14" title="Edit section: Fortran">edit</a>] <a href="/wiki/Category:Fortran" title="Category
:Fortran">Fortran</a></h2>
<pre class="fortran highlighted_source">program solve_2
4 use helpers implicit</s
pan> none real
:: vector(4), reals(4), p, q, r, s integer
:: numbers(
4), n, i, j, k, a, b, c, d
 character, parameter <s
pan class="sy0">:: ops(</s
pan>4) =
 (/ '+', '-', '*', '/' /)
 logical
::
last real,parameter
:: eps</s
pan> = epsilon(1.0) &#1
60; do n=1,12 
call <s
pan class="kw4">random_number(vector) 
reals = 9 * vector + 1 
numbers = int(reals) 
call Insertion_Sort(
numbers) 
permutations: do 
a =</spa
n> numbers(1); b = numbers(</s
pan>2); c = numbers(3); d = numbers
(4) 
r
eals = real&
#40;numbers) 
p =
 reals(1); q = reals(
2); r = reals(3<sp
an class="br0">); s = reals(4) 
! combinations of operators: 
do i=1,4 
do j=</spa
n>1,4 
do k=1,4 
if
( abs(op(op(op(p,i,q),j,r)</spa
n>,k,s)-
24.0) < eps ) then 
write (*,*&#4
1; numbers, ' : ', '((',a,ops(i),b,')',ops(j&#41
;,c,')',ops(k),d 
exit permu
tations 
else if ( abs&
#40;op(op(p,i,o

p(q,j,r)),k,s)-<spa
n class="nu0">24.0) < eps ) then 
write (*,*) numbers, ' : ', '(',a,ops(i),'(',b,ops(j),c,'))',ops(
k),d 
exi
t permutations 
else if ( abs(op(p,i,op(op(q,j,r)
,k,s))-24.0) < eps ) then 
wr
ite (*,*
) numbers, ' : '</spa
n>, a,ops(i),'((',b,ops(j)
,c,')',ops(k),d,')' 
exit permutations 
else if ( a
bs(op(p,i,op<sp
an class="br0">(q,j,op(r,k,s)))<s
pan class="sy0">-24.0)</sp
an> < eps ) then 
write (*,*) numbers, '
: ', a,ops(i)</s
pan>,'(',b,ops(j),'(',c,ops(k),d,'))' 
exit permutations 
else if ( abs(op(op(p,i,q),j,op<sp
an class="br0">(r,k,s)
)-24.0) < eps ) then
 
write (
*,*) numbers, ' : ', '(',a,ops(i),b,')',o
ps(j),'(',c,ops(k),
d,')' 
exit p
ermutations 
end if</s
pan> 
end do 
end do 
end do 

call nextpermutation(numbers,last) 
if &#
40; last ) then 
write (*,*) numbers, '&#1
60;: no solution.' 
exit permutations
 
end if 
<spa
n class="kw1">end do permutations end do contains pure real
function op(x,c,yinteger, intent(in) :: c
real, intent(in)
:: x,y 
select case ( op
s(c) ) 
case (</s
pan>'+') 
op <s
pan class="sy0">= x+y 
case ('-'= x-y 
case (</s
pan>'*') 
op <s
pan class="sy0">= x*y 
case ('/'= x/y 
end select</spa
n> end function op &
#160; end program solve_24
</pre>
<pre class="fortran highlighted_source">module helpers contains pure subroutine Insertion_Sort(ainteger, intent(inout<spa
n class="br0">) :: a(:)
 
integer
:: temp, i, j 
do</sp
an> i=2,size
(a) 
j
= i-1 
temp = a(i<spa
n class="br0">) 
do while ( j>=<s
pan class="nu0">1 .and.
a(j)>temp (j+1) = a(j) 
j = j - 1 
end do</sp
an> 
a(j+1) = temp
 
end do end subroutine Insertion_Sort &#16
0; subroutine nextpermutation&#
40;perm,last) 
inte
ger, intent(inout) :: perm(:
) 
logical,
intent(o

ut) :: last 
integer :
: k,l 
k = large
st1() 
last <sp
an class="sy0">= k == 0
 
if ( .not. last )
then
 
l = largest
2(k) 
call swap(l,k&#
41; 
call reverse&#40
;k) 
end <sp
an class="kw1">if contains 
pure <s
pan class="kw3">integer function largest1() 
integer :: k, max 
max =
 0 
do k=1,size<spa
n class="br0">(perm)-1 
lass="br0">( perm(k&#4
1; < perm(k+<spa
n class="nu0">1) )</sp
an> then 
max <sp
an class="sy0">= k 
end if 
end do 
largest1 = max 
end function largest1 
pure integer function
 largest2(k) 
integer, intent(in)
:: k 
integer
:: l, max 
max = k+1 
do l=k
+2,size(perm) 
i
f ( perm(k) < perm(l) ) then 
max = l 
end if 
end do 
largest2 = max 
end <s
pan class="kw1">function largest2 
su
broutine swap(l,k)</sp
an> 
integer, intent(in) :: k,l 
integer
:: temp 
temp
= perm(k) 
perm
(k) = perm(l) 
perm(l) =
temp 
end subroutine sw
ap 
subroutine reverse(k) 
integ
er, intent(in) :: <s
pan class="me2">k 
integer
:: i 
do i=1,(size(perm
)-k)
/2 
call swap(k+</sp
an>i,size(perm)+1-i) 
end do 
end subroutine reverse end subroutine nextpermutation end module helpers</pre>
<div>
<dl><dt>Output:</div> (using g95):
</dt></dl>
<pre> 3 6 7 9 : 3 *(( 6 - 7 )+ 9 )
3 9 5 8 : (( 3 * 9 )+ 5 )- 8
4 5 6 9 : (( 4 + 5 )+ 6 )+ 9
2 9 9 8 : ( 2 +( 9 / 9 ))* 8
1 4 7 5 : ( 1 +( 4 * 7 ))- 5
8 7 7 6 : no solution.
3 3 8 9 : ( 3 *( 3 + 8 ))- 9
1 5 6 7 : ( 1 +( 5 * 6 ))- 7
2 3 5 3 : 2 *(( 3 * 5 )- 3 )
4 5 6 9 : (( 4 + 5 )+ 6 )+ 9
1 1 3 6 : ( 1 +( 1 * 3 ))* 6
2 4 6 8 : (( 2 / 4 )* 6 )* 8
</pre>
tion=edit&section=15" title="Edit section: GAP">edit</a>] <a href="/wiki/Category:GAP" title="Category:GAP">GAP</a
></h2>
<pre class="text highlighted_source"># Solution in '''RPN''' check := f
unction(x, y, z) local r, c, s, i, j, k, a, b, p; i := 0; 
j := 0; 
k := 0; 
s := [ ]; 
r := ""; 
for c in z do 
if c = 'x' then 
i := i + 1; 
k := k + 1;
 
s[k] := x[i]; 
Append(r, String
(x[i])); 
else 
j := j + 1; 
b := s[k]; 
k := k - 1; 
a := s[k]; 
p := y[j]; 
r[Size(r) + 1] := p; 
if p = '+' then 
a := a + b; 
elif p = '-' then 
a := a - b; 
elif p = '*' then 
a := a * b; 
elif p = '/' then 
if b = 0 then 
continue; 
else 
a := a / b; 
fi; 
else 
return f
ail; 
fi; 
s[k] := a; 
fi; 
od; 
if s[1] = 24 then 
return r; else 
return fail; 
fi; end; Player24 := function(digits) 
local u, v, w, x, y, z,
r; u := PermutationsList(digits); 
v := Tuples("+
-*/", 3); 
w := ["xx*x*x*", "xx*xx**", &qu
ot;xxx**x*", "xxx*x**", "xxxx***"]; 

for x in
u do 
for y in v do 
for z in w do 
r := check(x, y, z); 
if r <> fail then 
return r; 
fi; 
od; 
od; 
od; 
return fail; end; Player24([1,2,7,7]); # "77*1-2/&qu
ot; Player24([9,8,7,6]); # "68*97-/" Player24([1,1,7,7]); # fail # Solutions with only one distinct digit are found onl
y for 3, 4, 5, 6: Player24([3,3,3,3]); # "33*3*3-" Player2
4([4,4,4,4]); # "44*4+4+" Player24([5,5,5,5]); # "55*
55/-" Player24([6,6,6,6]); # "66*66+-" # A
tricky one: Player24([3,3,8,8]); "8383/-/"</pre>
 

tion=edit&section=16" title="Edit section: Go">edit</a>] <a href="/wiki/Category:Go" title="Category:Go">Go</a></sp
an></h2>
<pre class="go highlighted_source">package main &#1
60; import ( "fmt" "math/rand" 
"time" 
) const ( op_num = iota 
op_add 
op_sub
op_mul 
op_div ) <sp
an class="kw1">type frac struct { num, denom int
 } // Expression:
can either be a single number, or a result of binary // operation from left and right node type
Expr struct { op
int left, right <sp
an class="sy3">*Expr 
value
frac }
 var n_cards = 4 var goal = 24 var
digit_range = 9 func (x *Expr) String() string { if</sp
an> x.op == op_num { 
return fmt.Sprintf("%d", x.value.num) 
} &
#160; 
var bl1, br1<s
pan class="sy1">, bl2, br2,</s
pan> opstr string switch
{ case x.left.op == op_num<spa
n class="sy1">: 
case x.left.op >= x.op: case x.left.op == op_add && x.op 
== op_sub: 
bl1, br1 = "", "" default: 
bl1, br1 = "(", ")" 

} 
if x.right.op == op_
num || x.op < x.right.op { 
bl2, br2 = &
quot;", ""</spa
n> } else { 
bl2, br2 = "(", <s
pan class="st0">")" 
#160; 
switch { 
case x.op ==
 op_add: 
opstr 
= " + " case x.op == op_sub: 
opstr = " - " case x.op == op_mul: 
opstr = " * " 
case x.op ==
 op_div: 
opstr 
= " / " }</spa
n> 
return bl1 + x.left.String() + br1 + opst
r + 
bl2 + x
.right.String() + br2 } &#1
60; func expr_eval(x *Expr) (f
frac) { if x.op == op_num <sp
an class="sy1">{ 
return x.value } 
l, r := expr_eval(x.left), expr_eva
l(x.right) switch x.</sp
an>op { case op_add<spa
n class="sy1">: 
f.num = l.num*r.denom + l.denom*r.num 
f.denom = l.
denom * r.denom 
return case op
_sub: 
f.num = l.num*</spa
n>r.denom - l.denom*r.num 
f.denom = l.
denom * r.denom 
return case op
_mul: 
f.num = l.num *</sp
an> r.num 
f.denom
= l.denom *
 r.denom 
 case op_div: 
f.num = l.num * r.
denom 
f.denom = l.denom * r.num 
return 
} return } func solve(ex_in []*Expr) bool { 
// only one expression left, meaning all numbers are a
rranged into 
// a binary tree, so evaluate
and see if we get 24 
if len(ex_in) == 1 { 
f := expr_eval(ex_in[0]) 
if f.denom !
= 0 && f.num <s
pan class="sy3">== f.denom*</s
pan>goal { 
fmt.Println(ex_in[<sp
an class="nu0">0].Strin
g()) 
 true 
}</spa
n> 
return false
} 
var</s
pan> node Expr 
ex := make</s
pan>([]*Expr
, len(ex_in)-1) 
// try to combine a pair of ex
pressions into one, thus reduce 
// the list le
ngth by 1, and recurse down for i := range ex <s
pan class="sy1">{ 
copy(ex[i:len(ex)], ex_in[i<sp
an class="sy3">+1:len(ex_in)])</spa
n> 
ex[i] = &node 
for j := i + 1; j < len(ex_in); j++ { 
node.left = ex_in[i] 
node.right = ex_in[j] 
// try all 4 operators 
for o := op_add;</sp
an> o <= op_div; o++ { 
node.op = o 
if solve(ex)
 { 
return true 
} 
#160; 
// also - and / are not commut
ative, so swap arguments 

node.left = ex_in[j] 
node.right <spa
n class="sy2">= ex_in[i
] 
node.op = op_sub 
if solve(ex)
{ 
 true 
} 
node.op
= op_div 
an> solve(ex) { 
return true 
#160; 
if j < len(ex) { 
ex[j<sp
an class="sy1">] = ex_in[</spa
n>j] 
}</spa
n> 
ex[</s
pan>i] =</sp
an> ex_in[i]
 
} return
false } <sp
an class="kw4">func main() { 
cards := make([]*Expr,</sp
an> n_cards) 
rand.Se
ed(time.Now(
).Unix()) 
for k := 0; k < 10; k++ { 
for i := 0; i < n_cards; i++ { 
cards[i]</sp
an> = &Expr{op_num, nil, nil, 
frac{rand.Intn(digit_range-1) + 1, 1}} 
fmt.Printf(&
quot; %d", cards[</s
pan>i].value
.num)
 
fmt.Print(": ") 
if !solve(car
ds) { 
fmt.Println(
"No solution") 
} } }</pre>
<div>
</dt></dl>
<pre> 8 6 7 6: No solution
7 2 6 6: (7 - 2) * 6 - 6
4 8 7 3: 4 * (7 - 3) + 8
3 8 8 7: 3 * 8 * (8 - 7)
5 7 3 7: No solution
5 7 8 3: 5 * 7 - 8 - 3
3 6 5 2: ((3 + 5) * 6) / 2
8 4 5 4: (8 - 4) * 5 + 4
2 2 8 8: (2 + 2) * 8 - 8
6 8 8 2: 6 + 8 + 8 + 2
</pre>
tion=edit&section=17" title="Edit section: Gosu">edit</a>] <a href="/wiki/Category:Gosu" title="Category:Gosu">Go
su</a></h2>
<pre class="text highlighted_source"> uses java.lang.Integer uses
java.lang.Double uses java.lang.System uses java.util.ArrayList uses
java.util.LinkedList uses java.util.List uses java.util.Scanner use
s java.util.Stack function permutations<T>( lst : List
<T> ) : List<List<T>> { 
if( lst.size() == 0 ) ret
urn {} 
if( lst.size() == 1 ) return { lst } 
var pivot
= lst.get(lst.size()-1) 
var sublist = new ArrayList<T>
( lst ) 
sublist.remove( sublist.size() - 1 ) 
var subP
erms = permutations( sublist ) 
var ret = new ArrayList<Lis
t<T>>() 
for( x in subPerms ) { 
for( e in x index i
) { 
var next = new LinkedList<T>( x ) 
next
.add( i, pivot ) 
ret.add( next ) 
} 
x.add
( pivot ) 
ret.add( x ) 
} 
return ret } 
 function readVals() : List<Integer> { 
var line = new jav
a.io.BufferedReader( new java.io.InputStreamReader( System.in ) ).readLine() 
var scan = new Scanner( line ) 
var ret = new ArrayList&l
t;Integer>() 
for( i in 0..3 ) { 
var next = scan.nextInt()
 
if( 0 >= next || next >= 10 ) { 
print( &quot
;Invalid entry: ${next}" ) 
return null 
} 
ret.add( next ) 
} 
return ret } function
getOp( i : int ) : char[] { 
var ret = new char[3] 
var
ops = { '+', '-', '*', '/' } 
ret[0] = ops[i / 16] 
ret[1] = ops[
(i / 4) % 4 ] 
ret[2] = ops[i % 4 ] 
return ret } function isSoln( nums : List<Integer>, ops : char[]
) : boolean { 
var stk = new Stack<Double>() 
for( n i
n nums ) { 
stk.push( n ) 
} 
for( c in ops
) { 
var r = stk.pop().doubleValue() 
var l = stk.pop().do
ubleValue() 
if( c == '+' ) { 
stk.push( l + r ) 
} else if( c == '-' ) { 
stk.push( l - r ) 
} e
lse if( c == '*' ) { 
stk.push( l * r ) 
} else if( c
== '/' ) { 
// Avoid division by 0 
if( r == 0.0 )
{ 
return false 
} 
stk.push(
l / r ) 
} 
} 
return java.lang.Math.abs( st
k.pop().doubleValue() - 24.0 ) < 0.001 } function printSol
n( nums : List<Integer>, ops : char[] ) { 
// RPN: a b c
d + - * 
// Infix (a * (b - (c + d))) 
print( "Found soln: ($
{nums.get(0)} ${ops[0]} (${nums.get(1)} ${ops[1]} (${nums.get(2)} ${ops[2]} ${nu
ms.get(3)})))" ) } System.out.print( "#> "
) var vals = readVals() var opPerms = 0..63 var solnFound
= false for( i in permutations( vals ) ) { 
for( j in opP
erms ) { 
var opList = getOp( j ) 
if( isSoln( i, opList )
) { 
printSoln( i, opList ) 
solnFound = true 
} 
} } if( ! solnFound ) { 
print
( "No solution!" ) } </pre>

tion=edit&section=18" title="Edit section: Haskell">edit</a>] <a href="/wiki/Category:Haskell" title="Category
:Haskell">Haskell</a></h2>
<pre class="haskell highlighted_source">import Data<spa
n class="sy0">.List import Data.Ratio import Control
.<a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.
html#t:Monad">Monad</a> import</s
pan> System.Environment (g
etArgs) data Expr = Constant <a href="http://haskell.org/ghc/docs/
latest/html/libraries/base/Prelude.html#t:Rational">Rational</a> | 
Expr :+</spa
n> Expr | Expr :- Expr <s
pan class="sy0">| 
Expr :* Expr <spa
n class="sy0">| Expr :/ Expr 
deriving (<a href="http://haskel
l.org/ghc/docs/latest/html/libraries/base/Prelude.html#t:Eq">E
q</a>) ops 
= &#9#91;(:+), (:-)</spa
n>, (:*), (:/)] instance <a href="h
ttp://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#t:Show">Show</a> Expr where 
<a href
="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:show"><s
pan class="kw3">show</a> (Constant x) = <a href="http://haskell.org/gh
c/docs/latest/html/libraries/base/Prelude.html#v:show">show</s
pan></a> $ numerator x 
-- I
n this program, we need only print integers. 
<a href="http://hask
ell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:show">show</a> (a :+</sp
an> b)
= strexp "+" a b 
<a href="http://haskell.org/ghc/doc
s/latest/html/libraries/base/Prelude.html#v:show">show<
/a> (a :- b)
= strexp &qu
ot;-" a b 
<a href="http://haskell.org/ghc/docs/latest/html/l
ibraries/base/Prelude.html#v:show">show</a> (a :* b)
= strexp "*"</spa
n> a b 
<a href="http://haskell.org/ghc/docs/latest/html/libraries/base/P
relude.html#v:show">show</a> (</s
pan>a :/ b)
= strexp "/" a b &#16
0; strexp :: <a href="http://haskell.org/ghc/docs/l
atest/html/libraries/base/Prelude.html#t:String">String
</a> -> Expr -> Expr <sp
an class="sy0">-> <a href="http://haskell.org/ghc/docs/latest/html/lib
raries/base/Prelude.html#t:String">String</a> strex
p op a b = "(" ++ <a href="http://haskell.org/ghc/docs/latest/html/librarie
s/base/Prelude.html#v:show">show</a> a ++ " " ++ o
p ++ " " ++ <a href="http://haskell.org/ghc/docs/latest/html/libraries/base

/Prelude.html#v:show">show</a> b ++ ")" templates :: [[Ex
pr] -> Expr] templates = do
 
op1 <- ops 
op2 <- ops 
op3 <- ops 
<sp
an class="br0">[\[a, b, c, d] -> op1 a $ op
2 b $ op3 c d, 
\[a, b,
c, d] > op1 (op2 a b)</sp
an> $ op3 c d, 
\, d] > op1 a $ op2 (o
p3 b c) d, 
\, d] > op1 (op2 a $ o
p3 b c) d, 
\, d] > op1 (op2 (
op3 a b) c) d] eval :: Expr -> <a href="http://haskell.org/ghc/docs/latest/html/libra
ries/base/Prelude.html#t:Maybe">Maybe</a> <a href="http
://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#t:Rational"><spa
n class="kw4">Rational</a> eval (Constan
t c) = Just c eval <sp
an class="br0">(a :+ b)
= liftM2 (</spa
n>+) &#4
0;eval a) (eval
b) eval (a :
- b)
= liftM2 (-) (eval a&#
41; (eval b) eval (a :* b)
= liftM2 
(*) (eval a) (eval b) eval (</spa
n>a :/ b)
= do 
denom 
<- eval b 
guard $ denom /= 0 
liftM (/ denom) $ eval a solve :: <a href=
"http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#t:Rational"
>Rational</a> -> [<a href="http://haskell.org/ghc/docs/latest/html/libraries/b
ase/Prelude.html#t:Rational">Rational</a>] -> [Ex
pr] solve target r4 =
<a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:f
ilter">filter</a> (<a href
="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:maybe">maybe</a> False (== target) . eval) $ 
liftM2 ($) templates $ 
nub $ permutations $ <a href="http://haskell.org/ghc/docs/l
atest/html/libraries/base/Prelude.html#v:map">map</a> C
onstant r4 main = getArgs >>= <a href="http://haskell.org/ghc/docs/latest/html/libraries
/base/Prelude.html#v:mapM_">mapM_</a> <a href="http://h
askell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:print">print</a> . solve 24</s
pan> . <a href="http://haskell.org/ghc/docs/latest/html
/libraries/base/Prelude.html#v:map">map</a> (<a href="http://haskell.org/ghc/docs/latest/html/libraries/ba
se/Prelude.html#v:toEnum">toEnum</a> 
. <a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude
.html#v:read">read</a>)
Example use:

<pre>$ runghc 24Player.hs 2 3 8 9
(8 * (9 - (3 * 2)))
(8 * (9 - (2 * 3)))
((9 - (2 * 3)) * 8)
((9 - (3 * 2)) * 8)
((9 - 3) * (8 / 2))
((8 / 2) * (9 - 3))
(8 * ((9 - 3) / 2))
(((9 - 3) / 2) * 8)
((9 - 3) / (2 / 8))
((8 * (9 - 3)) / 2)
(((9 - 3) * 8) / 2)
(8 / (2 / (9 - 3)))</pre>
tion=edit&section=19" title="Edit section: Alternative version">edit</a>]</s
pan> Alternative version</spa
n></h3>
<pre class="haskell highlighted_source">import Control.Applicative import Data<sp
an class="sy0">.List import Text.PrettyPrint data Expr = C <a href="http://haskell.org/ghc/docs/latest/
html/libraries/base/Prelude.html#t:Int">Int</a> | Op <a href="http://haskell.org/ghc/docs/latest/html/librarie
s/base/Prelude.html#t:String">String</a> Expr Expr 
 toDoc (C
x ) = int x toDoc (
Op op x y) = parens $ toDoc x <+> text op <+> toDoc y ops :: [(<a href="http://ha
skell.org/ghc/docs/latest/html/libraries/base/Prelude.html#t:String">String</a>, <a href="http://haskell.org/g
hc/docs/latest/html/libraries/base/Prelude.html#t:Int">Int</sp
an></a> -> <a href="http://haskell.org/ghc/docs/late
st/html/libraries/base/Prelude.html#t:Int">Int</a> <spa
n class="sy0">-> <a href="http://haskell.org/ghc/docs/latest/html/libr

aries/base/Prelude.html#t:Int">Int</a>)] ops = [(&qu
ot;+",(+)), ("
-",(-))<spa
n class="sy0">, ("*&q
uot;,(*)), ("/&quot
;,<a href="http://haskell.org/ghc/docs/latest/ht
ml/libraries/base/Prelude.html#v:div">div</a>)] sol
ve :: <a href="http://haskell.org/ghc/docs/latest/html/
libraries/base/Prelude.html#t:Int">Int</a> -> [<a href="http://haskell.org/ghc
/docs/latest/html/libraries/base/Prelude.html#t:Int">Int</a>] -> [Expr] solve res = <a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Pre
lude.html#v:filter">filter</a> ((Just res ==) . eval)</s
pan> . genAst where 
genAst [x] = [C x]</sp
an> 
genAst xs = do 
(ys,zs) <- split xs 
let f (Op op _</spa
n> _) = op `<a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelu
de.html#v:notElem">notElem</a>` [
"+","*"] ||
 ys <= zs 
<a href="http://haskell.o
rg/ghc/docs/latest/html/libraries/base/Prelude.html#v:filter">
filter</a> f $ Op <$></s
pan> <a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.htm
l#v:map">map</a> <a href="http://haskell.org/ghc/docs/l
atest/html/libraries/base/Prelude.html#v:fst">fst</a> o
ps <*> genAst ys <*></spa
n> genAst zs 
eval (C
x <sp
an class="br0">) = Just x 
eval (Op "/" _ y) | Just <s
pan class="nu0">0 <- eval y = Nothing 
eval (Op op x y) = <a href="http://haskell.org/ghc
/docs/latest/html/libraries/base/Prelude.html#v:lookup">lookup
</a> op ops <*> eval x &
lt;*> eval y select ::</sp
an> <a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html
#t:Int">Int</a> -> [<a href="http://haskell.org/ghc/docs/latest/html/libraries
/base/Prelude.html#t:Int">Int</a>&#93
; -> [[<a href="http://haskell.org/ghc/docs/latest/html/libraries/b
ase/Prelude.html#t:Int">Int</a>]] select 0 _ = [
[]&#
93; select n xs = [</s
pan>x:zs | k <- [0..<a href=
"http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:length">length</a> xs - n] 
, let (x:ys) = <a href="http://haskell.org/ghc/docs/latest/html/li
braries/base/Prelude.html#v:drop">drop</a> k xs 
, zs <- se
lect (n - 1) ys 
] split :: [<a href="http://haskell.org/ghc/docs/latest/html/libraries/bas
e/Prelude.html#t:Int">Int</a>]</s
pan> -> [([<a href="http://haskell.org/ghc/do
cs/latest/html/libraries/base/Prelude.html#t:Int">Int</
a>],&#91
;<a href="http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.
html#t:Int">Int</a>])] split xs = [(ys<sp
an class="sy0">, xs \\ ys) | n <- [1..<a href="http://haskell.org/ghc/do
cs/latest/html/libraries/base/Prelude.html#v:length">length</s
pan></a> xs - 1] 
, ys <sp
an class="sy0"><- nub . sort $ select n xs 
]</s
pan> main = <a href="http://h
askell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:mapM_">mapM_</a> (<a href="http://haskell.or
g/ghc/docs/latest/html/libraries/base/Prelude.html#v:putStrLn">putStrLn</a> . render . toDoc) $ solve 24 [2,3,8,9]</pre>
<div>
</dt></dl>
<pre>((8 / 2) * (9 - 3))
((2 / 9) + (3 * 8))
((3 * 8) - (2 / 9))
((8 - (2 / 9)) * 3)
(((2 / 9) + 8) * 3)
(((8 + 9) / 2) * 3)
((2 + (8 * 9)) / 3)
((3 - (2 / 9)) * 8)
((9 - (2 * 3)) * 8)
(((2 / 9) + 3) * 8)
(((2 + 9) / 3) * 8)
(((9 - 3) / 2) * 8)
(((9 - 3) * 8) / 2)</pre>
tion=edit&section=20" title="Edit section: Icon and Unicon">edit</a>]
 <a href="/wiki/Category:Icon" t
itle="Category:Icon">Icon</a> and <a href="/wiki/Category:Unicon" title="Categor
y:Unicon">Unicon</a> </h2>
This shares code with and solves the <a href="/wiki/24_game#Icon_and_Unicon"
title="24 game">24 game</a>. A series of pattern expressions are built up and th
en 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 occurre
nce of a solution.

<pre class="icon highlighted_source">invocable all link strings # for csort, deletec,
permutes procedure main() static
 eL initial { eoP := [] # set-up expression and operator permutat
ion patterns every &#40
; e := !["a@b#c$d", "a@(b#c)$d", "a@b#(c$d)", "a@(b#c$d)", "a@(b#(c$d))"] ) & 
&#
40; o := !(opers := "+-*/&
quot;) || !opers || !ope
rs ) do 
put( eoP,
map(e,"@#$",o) )
# ex
pr+oper perms eL := [] # all cas
es every ( e
:= !eoP &#4
1; & ( p := permutes(&q
uot;wxyz") )</spa
n> do 
put(eL, map<spa
n class="br0">(e,"abc
d",p)) } &#16
0; write("This will attempt to find solutions to 24 for sets of numbers by\n", 
"combining 4 single digits between 1 and 9 to make 24 using only
+ - * / and ( ).\n",</spa
n> 
"All operations have equal precedence and ar
e evaluated left to right.\n", 
"Enter 'use n1 n2 n3 n4' or just h
it enter (to use a random set),", 
"'first'/'all' shows the first or all solutions, 'quit'
to end.\n\n") repeat { e := t
rim(read())
| fail e ? case tab(find(" ")|0) of { 

"q"|"quit"
 : break 
<spa
n class="st0">"u"|&q
uot;use" : e := tab(0</sp
an>) 
"f"</spa
n>|"first": first := 1 <s
pan class="sy1">& next 
"a"|"all
" : first := <spa
n class="sy1">&null & next 
""</s
pan>
: e := " " ||(1+?8) || " " || (1+?8
) ||&quo
t; " || (1+?8) || " &q
uot; || (1+?8) 
writes(&
quot;Attempting to solve 24 for",e) e := deletec<sp
an class="br0">(e,' \t') #
no whitespace if e ?
 ( tab(many(<spa
n class="st0">'123456789')
), pos(5), pos(<s
pan class="nu0">0) ) then 
write<sp
an class="br0">(":") else write</sp
an>(" - invalid, only the di
gits '1..9' are allowed.") & next eS := set(<s
pan class="br0">) every ex := map(<spa
n class="sy1">!eL,"wxyz&q
uot;,e) do { 
if member(eS,ex) then next # skip duplicates of final expres
sion 
insert(</sp
an>eS,ex) 
if ex ? (</spa
n>ans := eval(E()), pos(</s
pan>0)&#
41; then # parse and evaluate 
if ans = 24 then &#123
; 
write("Success ",<spa
n class="kw4">image(ex&#41
;," evaluates to 24.&quot
;) 
if</spa
n> \first then break 
} } write("Quiting
.") end procedure eval(</spa
n>X)
#: return the evaluated A
ST if type(X) ==</sp
an> "list" then <spa
n class="br0">{ 
x := eval(get(
X)) 
while o := get</spa
n>(X) do 
if y :=</sp
an> get(X) then 
x 
:= o( real(x), (o ~== &q
uot;/" | fail, eval(y)
 )) 
else write
("Malformed expression.") & fail } return
\x | X e
nd procedure E&
#40;)
#: expression</sp
an> put(lex := [],T(</sp
an>)) while put(
lex,tab(
any('+-*/'))<spa
n class="br0">) do 
put(lex,T()<s
pan class="br0">) suspend if *lex = <spa
n class="nu0">1 then lex[1] else lex
# strip useless [] end procedure T()
#: Term susp
end 2(="(", E(), =")") | # parenthesize
d subexpression, or ... 
tab(any(<s
pan class="sy1">&digits&#4
1;)
# just a value end</pre>
 

<div class="examplemeta libheader">Library: <a href="/wiki/Category:Icon_
Programming_Library" title="Category:Icon Programming Library">Icon Programming
Library</a></div>
<a rel="nofollow" class="external text" href="http://www.cs.arizona.edu/icon/
library/src/procs/strings.icn">strings.icn provides deletec and permutes</a>

tion=edit&section=21" title="Edit section: J">edit</a>] <a href="/wiki/Category:J" title="Category:J">J</a></
h2>
<pre class="j highlighted_source">perm=: (A.&i.~&#1
60;!) 4 ops=: ' ',.'+-*%' {~ >,{i.each 4 4 4 cmask=:
1 + 0j1 * i.@{:@$@[ e. ] 
left=: [ #!.'('~"1 cmas
k right=: [ #!.')'~"1 cmask paren=: 2 :'[: left
&m right&n' parens=: ], 0 paren <spa
n class="nu0">3, 0 paren 5</sp
an>, 2 paren 5, [: 0 paren 7 (0 paren 3)
 all=: [: parens [:,/ ops ,@,."1/ perm { [:;&q
uot;:each answer=: ({.@#~ 24</spa
n> = ".)@all</pre>
This implementation tests all 7680 candidate sentences.
Example use:

<pre> answer 2 3 5 7
2+7+3*5
answer 8 4 7 1
8*7-4*1
answer 1 1 2 7
(1+2)*1+7
</pre>
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 equ
ivalent to the sentence <code>8*(7-(4*1))</code>. [Many infix languages use oper

ator 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.]

tion=edit&section=22" title="Edit section: Java">edit</a>] <a href="/wiki/Category:Java" title="Category:Java">Ja
va</a></h2>
<div class="examplemeta workswith">Works with: <a href="/wiki/Java" title
="Java" class="mw-redirect">Java</a> version 7</div>
Playable version, will print solution on request.

<pre class="java highlighted_source">import java.util.*; public class Game24Player { 
final <a href="http://www.google
.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%
20Lucky">String</a>[] patterns = &
#123;"nnonnoo", &quo
t;nnonono", "nnnoono", "nnnonoo", 
"nnnnooo&
quot;}; 
<s
pan class="kw1">final <a href="http://www.google.com/search?hl=en&q=a
llinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky">String</a> ops = "+-*/^
"; 
<a href="http://www.g
oogle.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Fee
ling%20Lucky">String</a> solution;</s
pan> 
List<Integer></spa
n> digits; 
public static void main(<a href="http://www.google.com/search?hl=en&q=allinur
l%3Astring+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Stri
ng</a>[] args<s
pan class="br0">) { 
new Game24Player().play( 
void play() { 
digits = getSolvableDigits&#
40;); 
Scanner in = new Sca
nner(<a href="http://www.google.com/search?hl=en&am
p;q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky">System</a>.in)</spa
while (true) { 
<a href="http://www.google.com
/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lu
cky">System</a>.out.print("Make 2
4 using these digits: "); 
<a href="http://www.google.com/search?hl=en&q=al
linurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky">System</a>.out.println
(digits); 
<a href="http://www.google.com/search?hl=en&q=a
llinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky">System</a>.out.println("(Enter 'q' to quit, 's' f
or a solution)");</sp
an> 
<a href="http://www.google.com/search?hl=en&q=allinurl%3
Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky">System</a>.out.print("> "
); 
<a href="http:
//www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27
m%20Feeling%20Lucky">String</a> line 
= in.nextLine(if (line.equalsIgnor
eCase("q"
)) &
#123; 
<a href="http://www.google.com/search?hl=en&amp
;q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky">System</a>.out.println("\nThanks for playing"); 
return; 
if (line.equalsIgnoreCase(&
quot;s"))
<a href="http://www.google.c
om/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20
Lucky">System</a>.out.println(solution
); 
digits = getSolvableDigits(&#
conti
nue; 
}</s
pan> 
char&
#91;] entry = line.
replaceAll("[^*+-/)(\\d]", &
quot;").toCharArray(); 
try { 
validate(en
try); 
if (evaluate<sp
an class="br0">(infixToPostfix(entry<spa
n class="br0">))) { 
<a href="http://w
ww.google.com/search?hl=en&q=allinurl%3Asystem+java.sun.com&btnI=I%27m%2
0Feeling%20Lucky">System</a>.out</spa
n>.println("\nCorrect! Want to try another? "<
digits = getSolvableDigits(); 
<s
pan class="br0">} else &#
123; 
<a href="http://www.google.com/search?hl=en&
amp;q=allinurl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky">System</a>.out.printl
n("
\nNot correct."); 
} catch (<a href="http://www.google.com/search?hl=en&q=allinur
l%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky">E
xception</a> e) {</sp
an> 
<a href="http://www.google.com/search?hl=en&q=allinu
rl%3Asystem+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Sys
tem</a>.out.printf("%n%s Try again.%n",
e.getMessage()); 
} 
void validate(char</sp
an>[] input) throws <a href="http://www.google.c
om/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling
%20Lucky">Exception</a> {
 
int total1 = <spa
n class="nu0">0, parens = 0</s
pan>, opsCount = 0; 
for (char c : inpu
t) { 
if (<a href="http://www.go
ogle.com/search?hl=en&q=allinurl%3Acharacter+java.sun.com&btnI=I%27m%20F
eeling%20Lucky">Character</a>.isDigit
(c)) 
total1 += 1 << (c - '0'
) * 4; 
else if (c == '(') 
parens++; 
else if (c == ')') 
parens
--; 
else if (ops.index
Of(c) != -1) 
opsCount++;
if (parens
< 0) 
throw new <a href="http://www.google.com/search?hl=en&q=allinurl%3Aexception+ja
va.sun.com&btnI=I%27m%20Feeling%20Lucky">Exception<
/a>("Parentheses mismatch.&q
uot;); 
if</spa
n> (parens != 0) 
t
hrow new <a href="http://www.google.com/search?h
l=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Exception</a>("Parentheses mismatch."); 
lass="br0">(opsCount != 3) 
throw</sp
an> new <a href="http://www.google.com/search?hl=en&amp

;q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Exception</a>(&qu
ot;Wrong number of operators."); 
int total2 <s
pan class="sy0">= 0; 
for (int d : digits)</sp
an> 
total2 += 1 << d * 4; 
i
f (total1 != total2
throw <s
pan class="kw1">new <a href="http://www.google.com/search?hl=en&q=all
inurl%3Aexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Exception</a>("Not
the same digits."); 
boolean evaluate(char[] line) throws <a href="http://www.google
.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Feeli
ng%20Lucky">Exception</a> {</spa
n> 
Stack<Float></sp
an> s = new Stack<>()
; 
try { 
for (char c : line<s
if ('0'
 <= c && c <= '9'&#41
; 
s.push((float) c - '0'</spa
n>); 
else 
s.push</s
pan>(applyOperator(s.pop()
, s.pop(), c))</spa
} 
} catch (<a href="http://www.google.com/search?hl=en&q=allinurl
%3Aemptystackexception+java.sun.com&btnI=I%27m%20Feeling%20Lucky">EmptyStackException</a> e) throw new <a href="http://www.google.com/search?hl=en&q=allinurl%3A
exception+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Excep
tion</a>("Invalid ent
ry."); 
(<a href="http://www.google.com/search?hl=en&q
=allinurl%3Amath+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Math</a>.abs(<spa
n class="nu0">24 - s.peek</spa
n>()
) < 0.001F); 
} 
float applyOperator(float a, float b, char c) {
 
switch (c<spa
n class="br0">) { 
case '+': 
return a +
b; 
case '-': 
return b - a;
case '*': 
return a * b; 
case '/': 
return b / a; 
default: 
return <a href="http:
//www.google.com/search?hl=en&q=allinurl%3Afloat+java.sun.com&btnI=I%27m
%20Feeling%20Lucky">Float</a>.NaN</sp
List<Integer> randomDigits() { 
<a href="http://www.google.com/search?hl=en&q=allinurl%3Arandom+java.sun.com
&btnI=I%27m%20Feeling%20Lucky">Random</a> r = new <a href="http://www.google.com/
search?hl=en&q=allinurl%3Arandom+java.sun.com&btnI=I%27m%20Feeling%20Luc
ky">Random</a>(); 
List
<Integer> result = new ArrayList<>(4)<
for (int i = 0; i <
4; i++) 
result.add</sp
an>(r.nextInt(9) + 1)<sp
return result<Integer> getSolvabl
eDigits() { 
List<Integer> result; 
do { 
result = randomDigits(&#4
}
while (!
isSolvable(result)</sp
an>); 
return result; 
} 
boolean isSolvable(List<Integer> digits) {
 
Set<List<Integer>> dPerms =
new HashSet<>(4 * 3 * 2); 
permute(digits, dPerms, 0&
#41;; 
i
nt total = 4 * 4 * 4; 
List&l
t;List<Integer>></spa
n> oPerms = new ArrayList<>(total); 
permuteOperators(oPerms, 4, total&#4
1;; 
StringBuilder sb <spa
n class="sy0">= new StringBuilder(4 + 3); &#16
0; 
for (<a hre
f="http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&b
tnI=I%27m%20Feeling%20Lucky">String</a> pattern : patterns) &#1
23; 
char[] patternChars = pat
tern.toCharArray(); 
for (List<
Integer> dig : dPerm
s) { 
for (List<Integer> opr :</sp
an> oPerms) { &#1
60; 
int i = 0, j = 0; 
fo
r (char c : patternChars) &
#123; 
if (c == 'n'<sp
an class="br0">) 
sb.append(dig.get<spa
n class="br0">(i++)</s
pan>); 
else 
sb.append(ops.cha
rAt(opr.get(j++)
)); 
<a href="http://www.google.com/search?hl=en&q=allinurl%3As
tring+java.sun.com&btnI=I%27m%20Feeling%20Lucky">String</s
pan></a> candidate = sb.toString</spa
n>()
; 
try 
{ 
if (evaluate(candidate.toCharArray()</s
pan>)) { 
solution =</s
pan> postfixToInfix(candidate&#41
;; 
return true; 
} catch 
(<a href="http://www.google.com/search?hl=en&q=allinurl%3Aexcepti
on+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Exception</s
pan></a> ignored) {
s
b.setLength(0); 
; 
return false; 
<a href="http://www.google.
com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=I%27m%20Feeling%2
0Lucky">String</a> postfixToInfix&#40
;<a href="http://www.google.com/search?hl=en&q=allinurl%3Astring+java
.sun.com&btnI=I%27m%20Feeling%20Lucky">String</a> p
ostfix) { 
class Expression { 
<a href="http://www.google.com/search?hl=en&q=allinurl%3Astring+j
ava.sun.com&btnI=I%27m%20Feeling%20Lucky">String</a
> op, ex; 
int
prec = 3;</s
pan> 
Expression(<a href=
"http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btn
I=I%27m%20Feeling%20Lucky">String</a> e) { 
ex = e; 
&
#125; 
Expression(
<a href="http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com
&btnI=I%27m%20Feeling%20Lucky">String</a> e1, <a hr
ef="http://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&
btnI=I%27m%20Feeling%20Lucky">String</a> e2, <a href="h
ttp://www.google.com/search?hl=en&q=allinurl%3Astring+java.sun.com&btnI=
I%27m%20Feeling%20Lucky">String</a> o
) { 
ex = <a href="http://www.google.com/search?hl=en&q=allinurl%3Astri
ng+java.sun.com&btnI=I%27m%20Feeling%20Lucky">String</a>.format("%s %s %s", e1, o, e2)</sp
op =
o; 
prec =
ops.indexOf(o) / 2; 
<s
pan class="br0">} 
Stack<
Expression> expr = new Stack<>(); &#1
60; 
for (char c : postfix.
toCharArray()<s
<sp
an class="kw4">int idx = ops.i
ndexOf(c)if (idx != -1) { 
Expression r = expr.<s
pan class="me1">pop()<
Expression l = expr.pop(<spa

n class="br0">); 
int opPrec = idx / 2; &#160
; 
if (
l.prec < opPrec) 
l.ex = '(' + l.<s
pan class="me1">ex + ')'; 
if (r.prec <= opPrec) 
r.ex = '(' + r.ex + ')'; 
expr.push(new Expression(l.ex, r.ex, "&quo
t; + c)); 
&
#125; else { 
expr.push(new Expression("" + c)</s
pan>); 
<sp
an class="br0">} 
return expr.peek().ex<
} 
char[] infixToPostfix(cha
r[] infix) throws <a href="http://www.goo
gle.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&btnI=I%27m%20Fe
eling%20Lucky">Exception</a> { 
StringBuilder sb = 
new StringBuilder()</s
pan>; 
Stack<Int
eger> s = new Stack<>(
); 
try { 
for (char c <sp
an class="sy0">: infix) &#
123; 
int idx = ops.indexOf(c<
<spa
n class="kw1">if (idx != -1&#41
; { 
if (s.isEmpty<sp
an class="br0">())
 
s.push(idx); 
else {</spa
n> 
while 
(!s.isEmpty())</spa
n> { 
int prec2 = s.peek
() /

 2; 
int prec1 = idx / 2;
if &#4
0;prec2 >= prec1) 
sb.append(ops.charAt(
s.pop()))<sp
else 
break}
s.push&#40
;idx); 
} else if (c == '('</spa
n>) { 
s.push(-2)} else if (c
== ')')
 { 
while (s.peek<spa
n class="br0">() !=</s
pan> -2)
 
sb.append(ops.charAt(s.pop()))pop<spa
n class="br0">();</spa
n> 
} else</s
pan> { 
sb.append(c)<spa
n class="sy0">; 
whi
le (!s.isEmpty()
sb.append(ops.charAt(s.pop(
))&#
41;; 
&#
125; catch (<a href
="http://www.google.com/search?hl=en&q=allinurl%3Aemptystackexception+java.s
un.com&btnI=I%27m%20Feeling%20Lucky">EmptyStackException</a> e) { 
throw new <a href="h
ttp://www.google.com/search?hl=en&q=allinurl%3Aexception+java.sun.com&bt
nI=I%27m%20Feeling%20Lucky">Exception</a>("Invalid entry."}
 
return sb.toStrin
g().toCharArray(); 
} &#16
0; 
void permute(Li
st<Integer> lst, Set<spa

n class="sy0"><List<Integer>> res, int k)</s
for <s
pan class="br0">(int i = k; i < lst.size(); i++)</s
<a href="http://www.google.
com/search?hl=en&q=allinurl%3Acollections+java.sun.com&btnI=I%27m%20Feel
ing%20Lucky">Collections</a>.swap</sp
an>(lst, i, k)(lst, res
, k + 1)
; 
<a href="http://www.google.com
/search?hl=en&q=allinurl%3Acollections+java.sun.com&btnI=I%27m%20Feeling
%20Lucky">Collections</a>.swap
(lst, k, i); 
if (k ==
lst.size()) 
res.add(new ArrayList
<>(lst)); 
void permuteOperators(List<List<Integer>> res,
int n, int total) { 
f
or (int i = 0, npow = n
* n; i < total; i++) 
res.add(<a href="http://www.google.com/search?hl=en&q=allinurl%3Aarr
ays+java.sun.com&btnI=I%27m%20Feeling%20Lucky">Arrays</spa
n></a>.asList((i / npow), (i % npow) / n, i % n<sp
an class="br0">));</sp
an> 
} }<
/pre>
<div>
</dt></dl>
<pre>Make 24 using these digits: [5, 7, 1, 8]
(Enter 'q' to quit, 's' for a solution)
> (8-5) * (7+1)
Correct! Want to try another?
Make 24 using these digits: [3, 9, 2, 9]
> (3*2) + 9 + 9
> s
4 * 5 - (4 - 8)
> 2+5+9+1
Not correct.
> 2 * 9 + 5 + 1
> s
(8 + 4) * (3 - 1)
> (9 +4) * 2 - 2
Not the same digits. Try again.
> q
Thanks for playing</pre>
tion=edit&section=23" title="Edit section: JavaScript">edit</a>] <spa
n class="mw-headline" id="JavaScript"><a href="/wiki/Category:JavaScript" title=
"Category:JavaScript">JavaScript</a></h2>
This is a translation of the C code.

<pre class="javascript highlighted_source">var ar=[]
,order=[
0,1,2]
,op=&
#91;],val=[]<spa
n class="sy0">; var NOVAL=
9999,oper="+-*/",o
ut; function rn
d(n)
{return Math.floor(Math</s
pan>.random()*n)} function say<sp
an class="br0">(s)&#12
3; try{docume
nt.write(s+" ")
} catch(e){WScript.Echo(s)} &#
125; function getvalue(x,dir){ var r=NOVAL; if<spa

n class="br0">(dir>0</s
pan>)++x
; while(1){ if(val[x]!=NOVAL){ r=val[x];</spa
n> val[x]=NOVAL; bre
ak; } 
x+=dir; } return r*1; }
 function calc&
#40;){ <s
pan class="kw1">var c=0
,l,r,
x; val=ar.join('/').split(</sp
an>'/');
 while(c<<s
pan class="nu0">3){ x=order[c]; l=getvalue(x,-1); 
r=getvalue(x,1); switch(</spa
n>op[x]){ case</sp
an> 0:val&#9
1;x]=l+r;break; case 1
:val[x&#
93;=l-r;break; case 2:val[x]=l*r;br
eak; case 3: if(!r||l%r)return 0; val<s
pan class="br0">[x]=l/r; } ++c; } return getvalu
e(-1</sp
an>,1); } function shuffle(s,n){</sp
an> var x=n,p=eval(s),r,t<s

pan class="sy0">; while(x--){ 
r=rnd(n
); t=p[x];
 p[x]=p[r]<sp
an class="sy0">; p[r
]=t; } } function parenth(n){ while&#40
;n>0)--n,out+='('; wh
ile(n<0)++n,out+=')'; } function getpriority(x){ for
(var z=3;z--;
)if(order[z]
==x)retu
rn 3-z; return 0; } function showsolution(){ var</spa
n> x=0,</spa
n>p=0,lp=0,v=0;
 while(x<4){ if(x<3){ lp=p;</spa
n> p=getpriority(x); v=p-lp; if(v>
0)parenth(v); <sp
an class="br0">} out+=ar[x]; 
if(x&lt
;3){ if(
v<0)parenth(v); out+=oper.charAt(op[x<sp
an class="br0">]);</sp
an> } ++x<spa
n class="sy0">; } parenth(-p); say(out); } function solve24(s){ var z=4<spa
n class="sy0">,r; while&#
40;z--)ar[z]=s.charCodeAt(z)-48; out=""; for(z=100000;z--;){ r=rnd(256); op[0]=r&3; op[1]
=(r>&
gt;2)&3; op<sp
an class="br0">[2]</sp
an>=(r&g
t;>4)&3; sh
uffle("ar",4)<spa
n class="sy0">; shuffle("order",3
); if(calc()!=24<s
pan class="br0">)continue;
 showsolution(); break; } &#125
; solve24(&
quot;1234");solve24("6789"); solve24("1127"&#
41;;</pre>
Examples:

<pre>(((3*1)*4)*2)
((6*8)/((9-7)))
(((1+7))*(2+1))</pre>
tion=edit&section=24" title="Edit section: jq">edit</a>] <a href="/wiki/Category:Jq" title="Category:Jq">jq</a></sp
an></h2>
<div class="examplemeta workswith">Works with: <a href="/wiki/Jq" title="
Jq" class="mw-redirect">jq</a> version 1.4</div>
The following solution is generic: the objective (e.g. 24) is specified as
the argument to solve/1, and the user may specify any number of numbers.
Infrastructure:

<pre class="text highlighted_source"># Generate a stream of the permutations of
the input array. def permutations: if length == 0 then [] else
. as $in | range(0;length) | . as $i 
| ($in|del(.[$i])|permutatio
ns) 
| [$in[$i]] + . end ; # Generate a stream
of arrays of length n, # with members drawn from the input array. def
take(n): length as $l | if n == 1 then range(0;$l) as $i | [ .[$i]
] else take(n-1) + take(1) end; # Emit an array with
elements that alternate between those in the input array and those in short, # starting with the former, and using nothing if "short" is too too s
hort. def intersperse(short): . as $in | reduce range(0;length) as
$i 
([]; . + [ $in[$i], (short[$i] // empty) ]); # Emit
a stream of all the nested triplet groupings of the input array elements, #
e.g. [1,2,3,4,5] => # [1,2,[3,4,5]] # [[1,2,3],4,5] # def tri
ples: . as $in | if length == 3 then . 
elif length == 1 th
en $in[0] 
elif length < 3 then empty 
else 
(range(0;
(length-1) / 2) * 2 + 1) as $i 
| ($in[0:$i] | triples) as $head 
| ($in[$i+1:] | triples) as $tail 
| [$head, $in[$i], $tail] 
end;</pre>
Evaluation and pretty-printing of allowed expressions

<pre class="text highlighted_source"># Evaluate the input, which must be a numbe
r or a triple: [x, op, y] def eval: if type == "array" then
 
.[1] as $op 
| if .[0] == null or .[2] == null then null 
else 
(.[0] | eval) as $left | (.[2] | eval) as $right 
|
if $left == null or $right == null then null 
elif $op == "+&q
uot; then $left + $right 
elif $op == "-" then $left - $ri
ght 
elif $op == "*" then $left * $right 
elif
$op == "/" then 
if $right == 0 then null 
else $left / $right 
end 
else "invalid arithmetic
operator: \($op)" | error 
end 
end else . end
; def pp: "\(.)" | explode | map([.] | implode |
if . == "," then " " elif . == "\"" then &quo
t;" else . end) | join("");</pre>
24 Game:

<pre class="text highlighted_source">def OPERATORS: ["+", "-&quot
;, "*", "/"]; # Input: an array of 4 digits# o: an array of 3 operators # Output: a stream def EXPRESSIONS(o): intersperse( o ) | triples; def solve(objective): len
gth as $length | [ (OPERATORS | take($length-1)) as $poperators 
|
permutations | EXPRESSIONS($poperators) 
| select( eval == objective) ] as $answers | if $answers|length > 3 then "That was too easy.
I found \($answers|length) answers, e.g. \($answers[0] | pp)" 
elif
$answers|length > 1 then $answers[] | pp 
else "You lose! There
are no solutions." 
end ; solve(24), "Please
try again."</pre>
<div>
</dt></dl>
<pre class="text highlighted_source">$ jq -r -f Solve.jq [1,2,3,4] That
was too easy. I found 242 answers, e.g. [4 * [1 + [2 + 3]]] Please try again
. [1,2,3,40,1] That was too easy. I found 636 answers, e.g. [[[1 / 2] *
40] + [3 + 1]] Please try again. [3,8,9] That was too easy. I found
8 answers, e.g. [[8 / 3] * 9] Please try again. [4,5,6] You lose! Th
ere are no solutions. Please try again. [1,2,3,4,5,6] That was too e
asy. I found 197926 answers, e.g. [[2 * [1 + 4]] + [3 + [5 + 6]]] Please try
again.</pre>
tion=edit&section=25" title="Edit section: Julia">edit</a>] <a href="/wiki/Category:Julia" title="Category:Julia
">Julia</a></h2>
<pre class="text highlighted_source">function solve24(nums) 

length(nums)
!= 4 && error("Input must be a 4-element Array") 
syms = [+,-,*,/] 
for x in syms, y in syms, z in syms 
for i
= 1:24 
a,b,c,d = nthperm(nums,i) 
if round(x(y(a,
b),z(c,d)),5) == 24 
return "($a$y$b)$x($c$z$d)" 
elseif round(x(a,y(b,z(c,d))),5) == 24 
return
"$a$x($b$y($c$z$d))" 
elseif round(x(y(z(c,d),b),a),5)
== 24 
return "(($c$z$d)$y$b)$x$a" 
elseif round(x(y(b,z(c,d)),a),5) == 24 
return "($b$y
($c$z$d))$x$a" 
end 
end 
end 
retu
rn "0" end</pre>
<div>
</dt></dl>
<pre>julia> for i in 1:10
nums = rand(1:9, 4)
println("solve24($nums) -> $(solve24(nums))")
end
solve24([9,4,4,5]) -> 0
solve24([1,7,2,7]) -> ((7*7)-1)/2
solve24([5,7,5,4]) -> 4*(7-(5/5))
solve24([1,4,6,6]) -> 6+(6*(4-1))
solve24([2,3,7,3]) -> ((2+7)*3)-3
solve24([8,7,9,7]) -> 0
solve24([1,6,2,6]) -> 6+(6*(1+2))
solve24([7,9,4,1]) -> (7-4)*(9-1)
solve24([6,4,2,2]) -> (2-2)+(6*4)
solve24([5,7,9,7]) -> (5+7)*(9-7)</pre>
tion=edit&section=26" title="Edit section: Liberty BASIC">edit</a>] <a href="/wiki/Category:Liberty_BASI
C" title="Category:Liberty BASIC">Liberty BASIC</a></h2>
<pre class="lb highlighted_source">dim d(4) <spa
n class="kw1">input "Enter 4 digits: "
; a$ nD=0 for i =1 to len(a$
c$=mid$(a$,i,1) 
if instr("123456789",c$) then 
nD=nD+1</sp
an> 
d(nD)=val(</sp
an>c$) 
end if next 'fo
r i = 1 to 4 '
print d(i); 'next 'precompute permutations.
Dumb way. nPerm = 1
*2*<s
pan class="nu0">3*4 dim perm(nPerm, 4) n = 0 for i = 1 
to 4 
for j <spa
n class="sy0">= 1 to <s
pan class="nu0">4 
for k = 1 to 4 
for l = 1 to 4 
'valid permutation (no dupes?)</s
pan> 
if i<>
j and i<>k and i<>l _ 
and j<>k and j<>l _ 
and k<>l then 
n=n+1 
' '
perm(n,1)=i '
perm(n,2)=j '
perm(n,3)=k '
perm(n,4)=l 
'actually, we
can as well permute given digits 
perm(n,1)=d(i) 
perm&#40
;n,2&
#41;=d(j(n,3)=d(k&#4
1; 
perm(n,4)=d(l) 
end if 
next 
next</s
pan> 
next next 'check if permutations look OK. They are 'for i =1 to n '
print i, <s
pan class="co1">'
for j =1 to 4: print perm(i,j);:next '
print 'next 'possible brackets NBrackets =
11 dim Brakets$(NBrackets) DATA "4#4#4#4" 
DATA "(4#4)#4#4" DATA "4#(4#4)#4" DATA "4#4#(4#4)" DATA "(4#4)#(4#4)" DATA "(4#4#4)#4" DATA "4#(4#4#4)" DATA "((4#4)#4)#4" DATA "(4#(4#4))#4" <spa
n class="kw1">DATA "4#((4#4)#4)" DATA "4#(4#(4#4))" for i = 1 to NBrackets 
read</spa
n> Tmpl$: Brakets$(i) = Tmpl$ 
next 'operations: full search count = 0 Ops$="+ - * /" dim Op$(3) For op1=1 to 4 
Op$(1)=word$
(Ops$,op1) 
For op2=
1 to 4 
Op$(2)=word$(Ops$,op2
) 
For op3=</sp
an>1 to 4</s
pan> 
Op$(3
)=word$(Ops$,op3'print "*" 
'substitute all brackets 
for t = 
1 to NBrackets 
Tmpl$=Brakets$(t)
 
'print , Tmpl$ 
'now, substitute all digits: permutations. 
for p = 1 to nPerm 
r
es$= "" 
nOp=0 
nD=0 
for i = 1 to len(Tmpl$) 
c$ = mid$(Tmpl$, i, <spa
n class="nu0">1) 
select case c$ 
case "#"</s
pan>
'operations 
nOp = nOp+1 
res$ = res$+Op$(nOp) 
case <s
pan class="st0">"4"
'digits</s
pan> 
nD = nOp+1 
res
$ = res$; perm(p,nD) 
<s
pan class="kw1">case else
'brackets goes here 
res$ = res$+ c$ 
end select 
next 
'print,, res$ 
'eval here 
if evalWithErrCheck<spa
n class="br0">(res$) =
 24 then 
print "24 = &quot
;;res$ 
end 'comment it out if you want to see all versions 
end if 
count = count + <s
pan class="nu0">1 
next 
next 
Next 
Next next print "If you s

ee this, probably task cannot be solved with these digits" <spa
n class="co1">'print count end function evalWithErrCheck(expr$) 
on <s
pan class="kw1">error goto &#9
1;handler] 
evalWithErrCheck=eval(exp
r$) 
exit function [handler] end function</pre>
tion=edit&section=27" title="Edit section: Lua">edit</a>] <a href="/wiki/Category:Lua" title="Category:Lua">Lua</a
></h2>
Generic solver: pass card of any size with 1st argument and target number wit
h second.

<pre class="lua highlighted_source"> local S
IZE = #arg&#
91;1] local GOAL = tonumbe
r(arg[2]) <s
pan class="kw2">or 24 local input = {} for v in arg[1]:gmatch("%d")</spa
n> do 
table.insert<sp
an class="br0">(input, v&#
41; end assert(#input == SIZE, 'Invalid input'</spa
n>) local
operations = {'+', '-', '*', '/'} local function BinaryTrees(vert) 
if vert == 0 then 
return {false}</s
pan> 
else 
local buf = {<sp
an class="br0">} 
for lef
ten = 0,</sp
an> vert - 1 do 
local righten = vert - leften - 1 
for _, left in pairs(BinaryTrees(leften)) do 
for _, right in pairs(BinaryTrees(righten))</sp

an> do 
table.insert(buf
, {left, right<spa
n class="br0">}) 
end 
end</s
pan> 
return buf 
end end local trees = BinaryTrees(SIZE-</sp
an>1) local c, opc, oper<s
pan class="sy0">, str local max = math.pow(#opera
tions, SIZE-
1) local function op(a
,b) opc = o
pc + 1 local i = math.floor(oper/mat
h.pow(#operations, opc-1))%#operations+1 
return '('</s
pan>.. a .. operations[i] .. b ..')' end local 
function EvalTree(tree&#41
; if tree == <sp
an class="kw4">false then 
c = c + 1 
return input[</sp
an>c-1] 
return op(EvalTree(tree[1]), EvalTre
e(tree[2])) 
end end local function printResult(&#41
; for _, v in ipairs(</s
pan>trees) do 
for i = 0</s
pan>, max do
 
c, opc, oper = 1, 0, i 
str = EvalTree(v) 
loadstring</sp
an>('res='..str)() 
class="br0">(res == GOAL&
#41; then print(str, '='
, res) e
nd 
end end local uniq = {<s
pan class="br0">} local function permgen (a, n) 
if n <s
pan class="sy0">== 0 then</spa
n> 
local str = table.concat(a) 
if not uniq[str]</s
pan> then 
printResult() 
uniq[str] = true 
end 
for i = 1<spa
n class="sy0">, n do 
a[n]
, a[i] = a[i], a[n&#
93; 
permgen(a<s
pan class="sy0">, n - 1
) 
a[
n], a[i] = a<spa
n class="br0">[i],</sp
an> a[n] 
end end permgen(inp
ut, SIZE) </pre
>
<div>
</dt></dl>
<pre>
$ lua 24game.solve.lua 2389
(8*(9-(3*2))) =
24
(8*((9-3)/2)) =
24
((8*(9-3))/2) =
24
((9-3)*(8/2)) =
24
(((9-3)*8)/2) =
24
(8*(9-(2*3))) =
24
(8/(2/(9-3))) =
24
((8/2)*(9-3)) =
24
((9-3)/(2/8)) =
24
((9-(3*2))*8) =
24
(((9-3)/2)*8) =
24
((9-(2*3))*8) =
24
$ lua 24game.solve.lua 1172
((1+7)*(2+1)) =
24
((7+1)*(2+1)) =
24
((1+2)*(7+1)) =
24
((2+1)*(7+1)) =
24
((1+2)*(1+7)) =
24
((2+1)*(1+7)) =
24
((1+7)*(1+2)) =
24
((7+1)*(1+2)) =
24
$ lua 24game.solve.lua 123456789 1000
(2*(3+(4-(5+(6-(7*(8*(9*1))))))))
=
1000
(2*(3+(4-(5+(6-(7*(8*(9/1))))))))
=
1000
(2*(3*(4*(5+(6*(7-(8/(9*1))))))))
=
1000
(2*(3*(4*(5+(6*(7-(8/(9/1))))))))
=
1000
(2*(3+(4-(5+(6-(7*((8*9)*1)))))))
=
1000
(2*(3+(4-(5+(6-(7*((8*9)/1)))))))
=
1000
(2*(3*(4*(5+(6*(7-((8/9)*1)))))))
=
1000
(2*(3*(4*(5+(6*(7-((8/9)/1)))))))
=
1000
.....
</pre>
tion=edit&section=28" title="Edit section: Mathematica / Wolfram Language">e
dit</a>] 
<a href="/wiki/Category:Mathematica" title="Category:Mathematica">Mathematica</a
> / <a href="/wiki/Category:Wolfram_Language" title="Category:Wolfram Language">
Wolfram Language</a></h2>
The code:

<pre class="text highlighted_source"> treeR[n_] := Table[o[trees
[a], trees[n - a]], {a, 1, n - 1}] treeR[1] := n tree[n_] :=
 Flatten[treeR[n] //. {o[a_List, b_] :> (o[#, b] & /@ a), 
o[a_, b_List] :> (o[a, #] & /@ b)}] game24play[val_List]
:= Union[StringReplace[StringTake[ToString[#, InputForm], {10, -2}]
, 
"-1*" ~~ n_ :> "-" <> n] & /@
(HoldForm /@ 
Select[Union@ 
Flatten[Outer[# /. {o[q_Int
eger] :> #2[[q]], 
n[q_] :> #3[[q]]} &, 
Block[{O = 1, N = 1}, # /. {o :> o[O++], n :> n[N+
+]}] & /@ 
tree[4], Tuples[{Plus, Subtract, Times, Divide},
3], 
Permutations[Array[v, 4]], 1]], 
Quiet[(# /. v[q
_] :> val[[q]]) == 24] &] /. 
Table[v[q] -> val[[q]], {
q, 4}])]</pre>
The <code>treeR</code> method recursively computes all possible operator tree
s for a certain number of inputs. It does this by tabling all combinations of di
stributions 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 (g
eneric at this point).
The base case <code>treeR[1]</code> returns <code>n</code> (the input).
The final output of <code>tree[4]</code> (the 24 game has 4 random inputs) (<cod
e>tree</code> cleans up the output of <code>treeR</code>) is:

<pre>
{o[n, o[n, o[n, n]]],
o[n, o[o[n, n], n]],
o[o[n, n], o[n, n]],
o[o[n, o[n, n]], n],
o[o[o[n, n], n], n]}</pre>
<code>game24play</code> takes the four random numbers as input and does the f
ollowing (the <code>%</code> refers to code output from
previous bullets):

<ul><li><code>Block[{O = 1, N = 1}, # /. {o :> o[O++], n :> n[N+
+]}] & /@ tree[4]</code>
<ul><li> Assign ascending numbers to the input and operator placeholders.
</li><li> Ex: <code>o[1][o[2][n[1], n[2]], o[3][n[3], n[4]]]</code>
</li></ul>
</li><li><code>Tuples[{Plus, Subtract, Times, Divide}, 3]</code>
<ul><li> Find all combinations (<code>Tuples</code> allows repeats) of the four

allowed operations.
</li><li> Ex: <code>{{Plus, Plus, Plus}, {Plus, Plus, Subtract}, <<60>&
gt;, {Divide, Divide, Times}, {Divide, Divide, Divide}}</code>
</li></ul>
</li><li><code>Permutations[Array[v, 4]]</code>
<ul><li> Find all permutations (<code>Permutations</code> does not allow repeats
) of the four given values.
</li><li> Ex: <code>{{v[1],v[2],v[3],v[4]}, {v[1],v[2],v[4],v[3]}, <<20&gt
;>, {v[4],v[3],v[1],v[2]}, {v[4],v[3],v[2],v[1]}}</code>
</li></ul>
</li><li><code>Outer[# /. {o[q_Integer] :> #2[[q]], n[q_] :> #3[[q]]} &amp
;, %%%, %%, 
%, 1]</code>
<ul><li> Perform an outer join on the three above lists (every combination of ea
ch element) and with each combination put into the first (the operator tree) the
second (the operation at each level) and the third (the value indexes, n
ot actual values).
</li><li> Ex: <code>v[1] + v[2] - v[3] + v[4]</code>
</li></ul>
</li><li><code>Union@Flatten[%]</code>
<ul><li> Get rid of any sublists caused by <code>Outer</code> and remove any dup
licates (<code>Union</code>).
</li></ul>
</li><li><code>Select[%, Quiet[(# /. v[q_] :> val[[q
]]) == 24] &]</code>
<ul><li> Select the elements of the above list where substituting the real value
s returns 24 (and do it <code>Quiet</code>ly because of div-0 concerns).
</li></ul>
</li><li><code>HoldForm /@ % /. Table[v[q] -> val[[q
]], {q, 4}]</code>
<ul><li> Apply <code>HoldForm</code> so that substituting numbers will not cause
evaluation (otherwise it would only ever return lists like <code>{24, 24, 24}</
code>!) and substitute the numbers in.
</li></ul>
</li><li><code>Union[StringReplace[StringTake[ToString[#, InputForm], {10, -2}],
"-1*" ~~ n_ :> "-" <> n] & /@ %]</c
ode>
<ul><li>For each result, turn the expression into a string (for easy manipulatio
n), strip the "<code>HoldForm</code>" wrapper, replace numbers like "-1*7" with
"-7" (a idiosyncrasy of the conversion process), and remove any lingering duplic
ates. 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)". Exa
mple run input and outputs:
</li></ul>
</li></ul>
<pre class="text highlighted_source">game24play[RandomInteger[{1, 9}, 4]]</pre>
<div>
</dt></dl>
<pre>{7, 2, 9, 5}
{-2 - 9 + 7*5}</pre>
<pre>{7, 5, 6, 2}
{6*(7 - 5 + 2), (7 - 5)*6*2, 7 + 5 + 6*2}</pre>
<pre>{7, 6, 7, 7}
{}</pre>
<pre>{3, 7, 6, 1}
{(-3 + 6)*(7 + 1), ((-3 + 7)*6)/1, (-3 + 7)*6*1,
6 - 3*(-7 + 1), 6*(-3 + 7*1), 6*(-3 + 7/1),
6 + 3*(7 - 1), 6*(7 - 3*1), 6*(7 - 3/1), 7 + 3*6 - 1}</pre>
Note that although this program is designed to be extensible to higher number

s of inputs, the largest working set in the program (the output of the <code>Out
er</code> function can get very large:

<ul><li><code>tree[n]</code> returns a list with the length being the (n-1)-th <
a href="http://en.wikipedia.org/wiki/Catalan_number" class="extiw" title="wp:Cat
alan number">Catalan number</a>.
</li><li><code>Tuples[{Plus, Subtract, Times, Divide}, 3]</code> has fixed lengt
h 64 (or p3 for p operations).
</li><li><code>Permutations[Array[v, n]]</code> returns n! permutations.
</li></ul>
Therefore, the size of the working set is <img class="tex" alt="64 \cdot n!\,
C_{n-1} = 64 \cdot (n-1)!!!! = 64 \frac{(2n-2)!}{(n-1)!}" src="/mw/images/math/
a/8/3/a838adb896342b78cff998e6922d7203.png" />, where n!!!! is the <a href="http://en.wikipedia.org/wiki/quadruple
_factorial" class="extiw" title="wp:quadruple factorial">quadruple factorial</a>
. It goes without saying that this number increases very fast. For this game, th
e 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, ...}.

tion=edit&section=29" title="Edit section: OCaml">edit</a>] <a href="/wiki/Category:OCaml" title="Category:OCaml
">OCaml</a></h2>
<pre class="ocaml highlighted_source">type expression = | Const of <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasi
ves.html#VALfloat">float</a> |
 Sum of expression * e
xpression (* e1 + e2 *) |</s
pan> Diff of expression * expr
ession (* e1 - e2 *) | Prod of expression * express
ion (* e1 * e2 *) | Q
uot of expression * expression
(* e1 / e2 *) let
 rec eval = function | Const c -> c | Sum (f, g) -> eval f +. eval g | Diff(f, g) ->
 eval f -. eval g |</sp
an> Prod(f, g) -> eval f *. eval g | Quot(f, g&#41
; -> eval f /. eval
g let print_expr expr = let open_paren prec op_prec = 
if prec &g
t; op_prec then <a href="http://caml.inria.fr/pu
b/docs/manual-ocaml/libref/Pervasives.html#VALprint_string">pr
int_string</a> "(" i
n let close_paren prec op_prec = 
if prec &gt
; op_prec then <a href="http://caml.inria.fr/pub
/docs/manual-ocaml/libref/Pervasives.html#VALprint_string">pri
nt_string</a> ")" in
 let rec print p
rec = function (* prec is the current precedence *) 
|</s
pan> Const c -> <a href="http://caml.inria.fr/pub/do
cs/manual-ocaml/libref/Printf.html">Printf</a>.printf "%g" c 
| Sum(f, g&#4
1; -> 
open_paren prec 0; 
print 
0 f; <a href="http://caml.inria.fr/pub/docs/manu
al-ocaml/libref/Pervasives.html#VALprint_string">print_string</a> " + "; pr
int 0 g; 
close_pa
ren prec 0 
| Diff<spa
n class="br0">(f, g) > 
open_paren prec 0; 
print 0 f;
 <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.ht
ml#VALprint_string">print_string</a> 
" - "; print 1 g; 
close_paren prec 0 
| Prod(f,
g) -> 
open
_paren prec 2; 
pr
int 2 f; <a href="http://caml.
inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#VALprint_string">print_string</a> " * "; print 2 g;
 
close_paren prec 2 
| Quot(f, g)</spa
n> -> 
open_paren prec 2; 
print 2 f; <a href="http://caml.inria.fr/pub/docs/manual-ocam
l/libref/Pervasives.html#VALprint_string">print_string<
/a> " / "; print <sp
an class="nu0">3 g; 
close_paren pre
c 2 in print <sp
an class="nu0">0 expr let rec insert v = fu
nction | [<s
pan class="br0">] -> &#
91;[v]] | x::</s
pan>xs as li -> (v::li)
:: (<a href="http://caml.i
nria.fr/pub/docs/manual-ocaml/libref/List.html">List</a
>.map (f
un y -> x::y) (insert v xs)) 
let permutations li = <a href="http://ca
ml.inria.fr/pub/docs/manual-ocaml/libref/List.html">List</a>.fold_right (fun x z -> <a href="http://caml.inr
ia.fr/pub/docs/manual-ocaml/libref/List.html">List</a>.concat (<a href="http://ca
ml.inria.fr/pub/docs/manual-ocaml/libref/List.html">List</a>.map (insert x) z)) li [[]] let rec comp expr = function | x::xs -> 
comp (Sum (expr, x&#4
1;) xs; 
comp (Diff(expr, x<spa
n class="br0">)) xs; 
comp (Prod(expr, x)) xs<spa
n class="sy0">; 
comp (Quot(expr, x)&#
41; xs; | [] -> 
if (eval
expr) = 
24.0 
then (</sp
an>print_expr expr; <a href="http://caml.inria.fr/pub/d
ocs/manual-ocaml/libref/Pervasives.html#VALprint_newline">prin
t_newline</a>()
) ;; let (&#
41; = <a href="http://caml.inria.fr/pub/d
ocs/manual-ocaml/libref/Random.html">Random</a>.self_init()
; let digits <sp
an class="sy0">= <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libr
ef/Array.html">Array</a>.init
4 (fun _ -> 1 + <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Random.h
tml">Random</a>.<a href="http:
//caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#TYPEint">int</a> 9)
in <a href="http://caml.inria.fr/pub/docs/manual
-ocaml/libref/Pervasives.html#VALprint_string">print_string</s
pan></a> "Input digits: "; <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.h
tml">Array</a>.iter (<a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/P
rintf.html">Printf</a>.printf
" %d") digi
ts; <a href="http://caml.inria.fr/pub/docs/manual-ocaml
/libref/Pervasives.html#VALprint_newline">print_newline
</a>(); let digits =
<a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html">Array</a>.to_list&#4
0;<a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html">
Array</a>.map <a href="http://
caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#VALfloat_of_int"><spa
n class="kw3">float_of_int</a> digits) in let digits = <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/List.htm
l">List</a>.map (fun v -> Co
nst v) digits in <s
pan class="kw1">let all = permutations digits <s
pan class="kw1">in <a href="http://caml.inria.fr/pub/docs/manual-o
caml/libref/List.html">List</a>.</spa
n>iter (function 

| x::xs -&gt
; comp x xs 
| [] -> assert false ) all</pre>
<pre>
Input digits: 5 7 4 1
7 * 4 - 5 + 1
7 * 4 + 1 - 5
4 * 7 - 5 + 1
4 * 7 + 1 - 5
(5 - 1) * 7 - 4
</pre>
(notice that the printer only puts parenthesis when needed)

tion=edit&section=30" title="Edit section: Perl">edit</a>] <a href="/wiki/Category:Perl" title="Category:Perl">Pe
rl</a></h2>
Will generate all possible solutions of any given four numbers according to t
he rules of the <a href="/wiki/24_game" title="24 game">24 game</a>.
Note: the <code>permute</code> function was taken from <a rel="nofollow"
class="external text" href="http://faq.perl.org/perlfaq4.html#How_do_I_permute_N
_e">here</a>

<pre class="perl highlighted_source"># Fischer-Krause ordered
permutation generator # http://faq.perl.org/perlfa
q4.html#How_do_I_permute_N_e sub permute <s
pan class="br0">(&@&#4
1; { 
my</sp
an> $code = <a href="http://pe
rldoc.perl.org/functions/shift.html">shift</a>; 
my @i
dx = 0..$#_; 
while ( 
$code->(@_[@idx<s
pan class="br0">]) &#4
1; { 
my $p = $#idx; 
--$p while <s
pan class="re0">$idx[$p</s
pan>-1] > $idx[$p]; 
my <spa
n class="re0">$q = $p or <a href="http://perldoc.perl.org/functions/return.htm
l">return</a>; 
<a href="http://perldoc.perl.org/functions/push.html">push</sp
an></a> @idx, <a href="http://
perldoc.perl.org/functions/reverse.html">reverse</a> <a
href="http://perldoc.perl.org/functions/splice.html">splice</a> @idx, $p; 
++$q while $idx[$p<spa
n class="sy0">-1] > $idx&#91

;$q]; 
@idx[$p-1,$q]=@idx<spa
n class="br0">[$q,$p-1<s
pan class="br0">]; 
} } @formats = 
( 
'((%d %s %d) %s %
d) %s %d', 
'(%d %s (%d %s %d)) %s %d',
 '(%d %s %d) %s (%d %s&#16
0;%d)', '%d %s (
(%d %s %d) %s %d)', 
'%d %s (%d %s (%d %s %d))', 
)
; # generate all possible combinations
of operators @op = <a href="http://perldoc.perl.org/functions/qw.html">qw</a>( + - * / ); @operators = <a href="http://perldoc.perl.org/functions/map.html
">map</a>{ $a=$_; <a href="http://perldoc.perl.org/functions/map.html">map</a>{ $b<sp
an class="sy0">=$_; <a
href="http://perldoc.perl.org/functions/map.html">map</
a>{ "$a $b $_"
}@op &#
125;@op }@op; while(1) { <a href="http://
perldoc.perl.org/functions/print.html">print</a> "Enter four integers or 'q' to exit: "; 
<a href="http://perldoc.perl.org/functions/chomp.html">chomp</a>($ent = <>); last if $ent eq 'q'; 
>$ent !~ /^[
1-9] [1-9] [1-9] [1-9]$/)&
#123; <a href="http://perldoc.perl.org/functions/print.html">print</a> "invalid input\n
"; next <sp
an class="br0">} @n <spa
n class="sy0">= <a href="http://perldoc.perl.org/functions/split.html"><s
pan class="kw3">split</a> / /,
$ent; 
permute
{ <a href="http://perldoc.perl.org/functions/push.
html">push</a> @numbers,<a href="http://perldoc.perl.org/functions/join.html">join</a> ' ',</spa
n>@_ }@

n; 
for</s
pan> $format (@formats) 
{ 
for&#
40;@numbers) 
{ 
@n</sp
an> = <a href="http://perldoc.perl.org/functions/split.
html">split</a>; 
for(@ope
rators) 
{ 
@o</sp
an> = <a href="http://perldoc.perl.org/functions/split.
html">split</a>; 
$str = <a href="http://perldoc
.perl.org/functions/sprintf.html">sprintf</a> $format,$n<spa
n class="br0">[0]</spa
n>,$o[0],
$n[1],$o[1],$n[2]<s
pan class="sy0">,$o[2],</sp
an>$n[3]; 
$r = <a href="http://perldoc.p
erl.org/functions/eval.html">eval</a>
($str); 
<a href="http://perldoc.perl.org
/functions/print.html">print</a> &quo
t;$str\n" if $r == 24<s
pan class="sy0">; 
br />
} }
 }</pre>
<div>
</dt></dl>
<pre>E:\Temp>24solve.pl
Enter four integers or 'q' to exit: 1 3 3 8
((1 + 8) * 3) - 3
((1 + 8) * 3) - 3
((8 + 1) * 3) - 3
((8 - 1) * 3) + 3
((8 + 1) * 3) - 3
((8 - 1) * 3) + 3
(3 * (1 + 8)) - 3
(3 * (8 + 1)) - 3
(3 * (8 - 1)) + 3
(3 * (1 + 8)) - 3
(3 * (8 + 1)) - 3
(3 * (8 - 1)) + 3
3 - ((1 - 8) * 3)
3 + ((8 - 1) * 3)
3 - ((1 - 8) * 3)
3 + ((8 - 1) * 3)
3 - (3 * (1 - 8))
3 + (3 * (8 - 1))
3 - (3 * (1 - 8))
3 + (3 * (8 - 1))
Enter four integers or 'q' to exit: q
E:\Temp></pre>
tion=edit&section=31" title="Edit section: Perl 6">edit</a>] <a href="/wiki/Category:Perl_6" title="Category:Pe
rl 6">Perl 6</a></h2>
A loose translation of the Perl entry. Does not return every possible permuta
tion of the possible solutions. Filters out duplicates (from repeated digits) an
d only reports the solution for a particular order of digits and operators with
the fewest parenthesis (avoids reporting duplicate solutions only differing by u
nnecessary parenthesis).
Since Perl 6 uses Rational numbers for division (whenever possible) there
is no loss of precision as is common with floating point division. So a compari
son like (1 + 7) / (1 / 3) == 24 "Just Works"™

<pre class="perl6 highlighted_source">my @digits; my <s
pan class="re0">$amount = 4</s
pan>; # Get $amount
digits from the user, # ask for more if they don't
supply enough while @dig
its.elems < $amount { 
@digits ,= (prompt "Enter {$amount - @digits} d
igits from 1 to 9, " 
~ '(repeats allowed): ').comb(/<[1..9]>/)
; } # Throw awa
y any extras @digits =</s
pan> @digits[^$amount]; # Generate combinations
of operators my @op</spa
n> = <+ * />; my @ops = <sp
an class="kw3">map {my</s
pan> $a = $_
; map {my $b = $_; map {[$a,$b,$_]</s
pan>}, 
@op}, @op}, @op; # Enough sprintf formats to cover most precedence orderings <spa
n class="kw1">my @formats =</s
pan> ( 
'%d %s&#160
;%d %s %d %s %d', 
'(%d %s %d) %s %d %s %d', 

'(%d %s %d
%s %d) %s %d', 
'((%d %s %d) %s %d) %s %d', 
'(%d %s %d) %s (%
d %s %d)', 
'%d %s (%d %s %d %s %d)',</sp
an> 
'%d %s (%d %s (%d %s %d))', ); # Brute force test the differen
t permutations for unique permutations <spa
n class="re0">@digits -> @p
 { 
for <s
pan class="re0">@ops -> @o { 
for
@formats -> $format { 
my $string = <spa
n class="kw3">sprintf $format,
 @p[0], @o[0], 
@p[1<sp
an class="br0">], @o[1]
, @p&
#91;2], @o[2], @p[3<sp
an class="br0">]; 
my $result = t
ry { EVAL($string) }</sp
an>; 
say <spa
n class="st0">"$string = 24" and last if $result and $result == 24; 
} 
} } # Perl 6 tra
nslation of Fischer-Krause ordered permutation algorithm sub permutations (@
array) { 
my @inde
x = ^
@array; 
my <sp
an class="re0">$last = @index[*
-1]; 
my (<s
pan class="re0">@permutations, $rev, $fwd); 
loop</sp
an> { 
push @permutations, [@array[@index]]; 
$rev = $last<s

--$rev while $rev <spa
n class="kw1">and @index[$rev-1] > @index[$rev]<s
return @permutations unless $
rev; 
$fwd
= $rev;</spa
n> 
push @index, @index.splice</spa
n>($rev&
#41;.reverse; ++$fwd
while @inde
x[$rev-1] > @index<spa
n class="br0">[$fwd]; @index[$rev-1,$fwd] =
@index[$fwd,$
rev-1
]; 
br />} # Only r
eturn unique sub-arrays sub unique (@array)</sp
an> { 
my %h = map <sp
an class="br0">{ $_.</spa
n>Str => 
$_ }, @array; 
%h</spa
n>.values; } </pre>
<div>
</dt></dl>
<pre>
Enter 4 digits from 1 to 9, (repeats allowed): 3711
3 * (7 + 1 * 1) = 24
3 * (7 + 1 / 1) = 24
3 * (7 * 1 + 1) = 24
3 * (7 / 1 + 1) = 24
(3 + 1) * (7 - 1) = 24
3 * (1 + 7 * 1) = 24
3 * (1 + 7 / 1) = 24
(3 * 1) * (7 + 1) = 24
(3 / 1) * (7 + 1) = 24
3 / (1 / (7 + 1)) = 24
3 * (1 + 1 * 7) = 24
(3 * 1) * (1 + 7) = 24
3 * (1 / 1 + 7) = 24
(3 / 1) * (1 + 7) = 24
3 / (1 / (1 + 7))
(7 + 1) * 3 * 1 =
(7 + 1) * 3 / 1 =
(7 - 1) * (3 + 1)
(7 + 1) * 1 * 3 =
(7 + 1) / 1 * 3 =
(7 + 1) / (1 / 3)
(7 - 1) * (1 + 3)
(7 * 1 + 1) * 3 =
(7 / 1 + 1) * 3 =
(1 + 3) * (7 - 1)
(1 * 3) * (7 + 1)
(1 * 3) * (1 + 7)
(1 + 7) * 3 * 1 =
(1 + 7) * 3 / 1 =
(1 + 7) * 1 * 3 =
(1 + 7) / 1 * 3 =
(1 + 7) / (1 / 3)
(1 * 7 + 1) * 3 =
(1 + 1 * 7) * 3 =
(1 * 1 + 7) * 3 =
(1 / 1 + 7) * 3 =
= 24
24
24
= 24
24
24
= 24
= 24
24
24
= 24
= 24
= 24
24
24
24
24
= 24
24
24
24
24
Enter 4 digits from 1 to 9, (repeats allowed): 5 5 5 5

5 * 5 - 5 / 5 = 24
Enter 4 digits from 1 to 9, (repeats allowed): 8833
8 / (3 - 8 / 3) = 24
</pre>
tion=edit&section=32" title="Edit section: Phix">edit</a>] <a href="/wiki/Category:Phix" title="Category:Phix">Ph
ix</a></h2>
<pre class="text highlighted_source">-- -- 24_game_solve.exw -- ======
=========== -- -- Write a function that given four digits subject to t
he rules of the 24 game, computes an expression to solve the game if possible.-- Show examples of solutions generated by the function -- -- The
following 5 parse expressions are possible. -- Obviously numbers 1234 repre
sent 24 permutations from -- {1,2,3,4} to {4,3,2,1} of indexes to the rea
l numbers. -- Likewise "+-*" is like "123" representing
64 combinations -- from {1,1,1} to {4,4,4} of indexes to "+-*/"
. -- Both will be replaced if/when the strings get printed. -- co
nstant OPS = "+-*/" constant expressions = {"1+(2-(3*4))&quo
t;, 
"1+((2-3)*4)", 
"(1+2)-(3*4)", 
"(1+(2-3))*4&q
uot;, 
"((1+2)-3)*4"} -- (equivalent to &
quot;1+2-3*4") --TODO: I'm sure there is a simple (recursive) way to p
rogramatically -generate the above (for n=2..9) but I'm not seeing i
t yet... -- The above represented as three sequential operation
s (the result gets -- left in <(map)1>, ie vars[perms[operations[i]
[3][1]]] aka vars[lhs]): constant operations = {{{3,'*',4},{2,'-',3},{1,'+'
,2}}, --3*=4; 2-=3; 1+=2 
{{2,'-',3},{2,'*',4},{1,'+'
,2}}, --2-=3; 2*=4; 1+=2 
{{1,'+',2},{3,'*',4},{1,'-'
,3}}, --1+=2; 3*=4; 1-=3 
{{2,'-',3},{1,'+',2},{1,'*'
,4}}, --2-=3; 1+=2; 1*=4 
{{1,'+',2},{1,'-',3},{1,'*'
,4}}} --1+=2; 1-=3; 1*=4 --TODO: ... and likewise for parsing "express
ions" to yield "operations". function evalopset(
sequence opset, sequence perms, sequence ops, sequence vars) -- invoked 5*2
4*64 = 7680 times, to try all possible expressions/vars/operators -- (btw,
vars is copy-on-write, like all parameters not explicitly returned, so --
we can safely re-use it without clobbering the callee version.) intege

r lhs,op,rhs atom inf 
for i=1 to length(opset) do 
{lh
s,op,rhs} = opset[i] 
lhs = perms[lhs] 
op = ops[find(op
,OPS)] 
rhs = perms[rhs] 
if op='+' then 
vars[lhs] += vars[rhs] 
elsif op='-' then 
vars[lh
s] -= vars[rhs] 
elsif op='*' then 
vars[lhs] *= var
s[rhs] 
elsif op='/' then 
if vars[rhs]=0 then inf =
1e300*1e300 return inf end if 
vars[lhs] /= vars[rhs] 
end if 
end for 
return vars[lhs] end function &#1
60; integer nSolutions sequence xSolutions procedure
success(string expr, sequence perms, sequence ops, sequence vars, atom r) i
nteger ch 
for i=1 to length(expr) do 
ch = expr[i] 
if ch>='1' and ch<='9' then 
expr[i] = vars[perms[ch'0']]+'0' 
else 
ch = find(ch,OPS) 
if ch then 
expr[i] = ops[ch] 
end if 
end if 
end for 
if not find(expr,xSolutions) then 
-- avoid duplicates for eg {1,1,2,7} because this has found 
-- the "same" solution but with the 1st and 2nd 1s swapped, 
-- and likewise whenever an operator is used more than once. 
pri
ntf(1,"success: %s = %s\n",{expr,sprint(r)}) 
nS
olutions += 1 
xSolutions = append(xSolutions,expr) 
end if end procedure procedure tryperms(sequence perms, sequence
ops, sequence vars) atom r 
for i=1 to length(operations) do 
-- 5 parse expressions 
r = evalopset(operations[i], perms, o
ps, vars) 
if r=24 then 
success(expressions[i], per
ms, ops, vars, r) 
end if 
end for end procedure &
#160; include builtins/factorial.e include builtins/permute.e &#1
60; procedure tryops(sequence ops, sequence vars) 
for p=1 to facto
rial(4) do 
-- 24 var permutations 
tryperms(permute(p,{
1,2,3,4}),ops, vars) 
end for end procedure global
procedure solve24(sequence vars) 
nSolutions = 0 
xSolutions =
{} 
for op1=1 to 4 do 
for op2=1 to 4 do 
fo
r op3=1 to 4 do 
-- 64 operator combinations 
tryops({OPS[op1],OPS[op2],OPS[op3]},vars) 
end for 
end for 
end for 
printf(1,"\n%d solution
s\n",{nSolutions}) end procedure 
solve24({1,1,2,7
}) 
if getc(0) then end if</pre>
<div>
</dt></dl>
<pre>
success: (1+2)*(7+1) = 24
success: (1+7)*(1+2) = 24
success: (1+2)*(1+7) = 24
success: (2+1)*(7+1) = 24
success: (7+1)*(1+2) = 24
success: (2+1)*(1+7) = 24
success: (1+7)*(2+1) = 24
success: (7+1)*(2+1) = 24
8 solutions
</pre>
tion=edit&section=33" title="Edit section: PicoLisp">edit</a>] <a href="/wiki/Category:PicoLisp" title="Categ
ory:PicoLisp">PicoLisp</a></h2>
We use Pilog (PicoLisp Prolog) to solve this task

<pre class="text highlighted_source">(be play24 (@Lst @Expr)
# De
fine Pilog rule (permute @Lst (@A @B @C @D)) (member @Op1 (+ - *
/)) (member @Op2 (+ - * /)) (member @Op3 (+ - * /)) (or
 
((equal @Expr (@Op1 (@Op2 @A @B) (@Op3 @C @D)))) 
((equal
@Expr (@Op1 @A (@Op2 @B (@Op3 @C @D))))) ) (^ @ (= 24 (catch '("Div
/0") (eval (-> @Expr))))) ) (de play24 (A B C D)
# Define PicoLisp function (pilog 
(quote 
@L (list A B C D) 
(play24 @L @X) ) 
(println @X) )
) (play24 5 6 7 8)
# Call 'play24' funct
ion</pre>
<div>
</dt></dl>
<pre>(* (+ 5 7) (- 8 6))
(* 6 (+ 5 (- 7 8)))
(* 6 (- 5 (- 8 7)))
(* 6 (- 5 (/ 8 7)))
(* 6 (+ 7 (- 5 8)))
(* 6 (- 7 (- 8 5)))
(* 6 (/ 8 (- 7 5)))
(/ (* 6 8) (- 7 5))
(* (+ 7 5) (- 8 6))
(* (- 8 6) (+ 5 7))
(* (- 8 6) (+ 7 5))
(* 8 (/ 6 (- 7 5)))
(/ (* 8 6) (- 7 5))</pre>
tion=edit&section=34" title="Edit section: ProDOS">edit</a>] <a href="/wiki/Category:ProDOS" title="Category:Pr
oDOS">ProDOS</a></h2>
Note
This example uses the math module:

<pre class="text highlighted_source">editvar /modify -random- = <10 :aeditvar /newvar /withothervar /value=-random- /title=1 editvar /newvar
/withothervar /value=-random- /title=2 editvar /newvar /withothervar /value
=-random- /title=3 editvar /newvar /withothervar /value=-random- /title=4printline These are your four digits: -1- -2- -3- -4- printline Use an
algorithm to make the number 24. editvar /newvar /value=a /userinput=1 /tit
le=Algorithm: do -a- if -a- /hasvalue 24 printline Your algorithm work
ed! & goto :b ( ) else printline Your algorithm did not work. editvar /newvar /value=b /userinput=1 /title=Do you want to see how you could h
ave done it? if -b- /hasvalue y goto :c else goto :b :b editvar /newvar /value=c /userinput=1 /title=Do you want to play again? i
f -c- /hasvalue y goto :a else exitcurrentprogram :c editvar /new
var /value=do -1- + -2- + -3- + -4- /title=c & do -c- >d & if -d- /ha
svalue 24 goto :solve editvar /newvar /value=do -1- - -2- + -3- + -4/title=c & do -c- >d & if -d- /hasvalue 24 goto :solve edit
var /newvar /value=do -1- / -2- + -3- + -4- /title=c & do -c- >d & if
-d- /hasvalue 24 goto :solve editvar /newvar /value=do -1- * -2- + -3
- + -4- /title=c & do -c- >d & if -d- /hasvalue 24 goto :solveeditvar /newvar /value=do -1- + -2- - -3- + -4- /title=c & do -c- >d
& if -d- /hasvalue 24 goto :solve editvar /newvar /value=do -1- +
-2- / -3- + -4- /title=c & do -c- >d & if -d- /hasvalue 24 goto
:solve editvar /newvar /value=do -1- + -2- * -3- + -4- /title=c & do -c
- >d & if -d- /hasvalue 24 goto :solve editvar /newvar /value=d
o -1- + -2- + -3- - -4- /title=c & do -c- >d & if -d- /hasvalue 24 go
to :solve editvar /newvar /value=do -1- + -2- + -3- / -4- /title=c &am
p; do -c- >d & if -d- /hasvalue 24 goto :solve editvar /newvar
/value=do -1- + -2- + -3- * -4- /title=c & do -c- >d & if -d- /hasval
ue 24 goto :solve editvar /newvar /value=do -1- - -2- - -3- - -4- /tit
le=c & do -c- >d & if -d- /hasvalue 24 goto :solve editvar
/newvar /value=do -1- / -2- / -3- / -4- /title=c & do -c- >d & if -d/hasvalue 24 goto :solve editvar /newvar /value=do -1- * -2- * -3- *
-4- /title=c & do -c- >d & if -d- /hasvalue 24 goto :solve 
:solve printline you could have done it by doing -c- stoptask got
o :b</pre>
<div>
</dt></dl>
<pre>These are your four digits: 1 4 5 2
Use an algorithm to make the number 24.
Algorithm: 4 + 2 - 5 + 1
Your algorithm did not work.
Do you want to play again? y
These are your four digits: 1 8 9 6
Use an algorithm to make the number 24.
Algorithm: 1 + 8 + 9 + 6
Your algorithm worked!
Do you want to play again? n</pre>
tion=edit&section=35" title="Edit section: Prolog">edit</a>] <a href="/wiki/Category:Prolog" title="Category:Pr
olog">Prolog</a></h2>
Works with SWI-Prolog. 
The game is generic, you can choose to play with a goal different of 24,
any number of numbers in other ranges than 1 .. 9 ! 
rdiv/2 is use instead of //2 to enable the program to solve difficult cases as [
3 3 8 8].

<pre class="prolog highlighted_source">play24(Len<s
pan class="sy4">, Range, Goal&
#41; :- game(</spa
n>Len, Range, Goal, L, S), 
maplist(my_write<sp
an class="sy4">, L), format(': ~w~n'<s
pan class="sy4">, [S]). 
game(Len, Range, Value, L, S<sp
an class="br0">) :- length(L, Len), 
maplist(cho
ose(Range), L), 
compute(L, Value, []<sp
an class="sy4">, S). choose(Range, V) :-
V <a href="http://pauillac.inria.fr/~deransar/prolog/bips.html">is</a> random(Range) + 1. write_tree([M], [M]). write_tree<s
pan class="br0">([+</s
pan>, M, N&#
93;, S) :- write_tree(M, MS), 
write_tree(N, NS), 
append
(MS, [+ | NS]<sp
an class="sy4">, S). write_tree(&#9
1;-, M, N], S) :- write_tree(M, MS)<spa
n class="sy4">, 
write_tree(N, NS),
( is_add(N<s
pan class="br0">) -></s
pan> append(MS, [-, '(' | NS]</spa
n>, Temp), append(Temp, <sp
an class="st_h">')', S)</s
pan> 
; append(MS, [- | NS], S)). write_tree&#
40;[<a href="http://pauillac.inria.fr/~deran
sar/prolog/bips.html">Op</a>,
M, N], S) :- member<s
pan class="br0">(<a href="http://pauillac.inria.fr/~deransar/prolog/b
ips.html">Op</a>, [*, /])<sp
an class="sy4">, write_tree(M, MS),
write_tree(N, NS<s
pan class="br0">), 
( is_add(M)</s
pan> -> append(['(' <sp
an class="sy5">| MS],</spa
n> [')'
], TempM) 
; TempM = MS), (
is_add(N) -> append(['(' |
 NS], [')']<spa
n class="sy4">, TempN) 
; TempN = NS), append(Temp
M, [<a href="http://pauill
ac.inria.fr/~deransar/prolog/bips.html">Op</a> | TempN],
S). is_a
dd([<a href="http://pa

uillac.inria.fr/~deransar/prolog/bips.html">Op</a>, _, _]) :- 
member<s
pan class="br0">(<a href="http://pauillac.inria.fr/~deransar/prolog/b
ips.html">Op</a>, [+, -])<sp
an class="sy4">. compute(<s
pan class="br0">[Value], Value, [[_R-S1]</spa
n>], S&#
41; :- 
write_tree&#40
;S1, S2), with_output_to(<a href="htt
p://pauillac.inria.fr/~deransar/prolog/bips.html">atom<
/a>(S), maplist(<a href="http://pauillac.inria.f
r/~deransar/prolog/bips.html">write</a>, S2)). compute(L, Value, CS,</spa
n> S) :- 
select<s
pan class="br0">(M, L,</sp
an> L1), 
select<s
pan class="br0">(N, L1,</s
pan> L2), next_val
ue(M, N,
 R, CS, Expr), 
compute([R|L2], Value,
Expr, S). next_value(M, N, R, CS,[[R
- [+</s
pan>, M1, N1
]] | CS2]) :- R <a href="http://pauillac.inria.fr/~deransar/prolog/bips.html">is</a> M+N,
( member(<sp
an class="br0">[M-ExprM&#9
3;, CS) -> select([M-ExprM], CS, CS1), M1 = E
xprM 
; M1 = [M],</spa
n> CS1 = CS 
)<s
pan class="sy4">, ( member([N-Ex
prN], CS1) -> select<spa
n class="br0">([N-</sp
an>ExprN], CS1, CS2), N1 <s
pan class="sy6">= ExprN 

; N1 = [N]
, CS2 = CS1 
). next_value<spa
n class="br0">(M, N, R, CS,&#91
;[R - [-, M1, N1]] | CS2]
) :- R <a href="http://pauillac.inria
.fr/~deransar/prolog/bips.html">is</a> M-N, 
(
member([M-ExprM], CS<s
pan> select([M-ExprM],
CS, CS1)
, M1 = ExprM 
;</spa
n> M1 = [M], CS1 = CS 
), ( member(&
#91;N-ExprN], CS1) -
> select([N-ExprN]<s
pan class="sy4">, CS1, CS2&#41
;, N1 = ExprN 
; N1 = &#9
1;N], CS2 = CS1 
. next_value(M, N, R, CS,[[R
- [*</sp
an>, M1, N1&
#93;] | CS2]) :-
 R <a href="http://pauillac.inria.fr/~deransar/prolog/bips.html">is</a> M*N,
( member(<sp
an class="br0">[M-ExprM&#9
3;, CS) -> select([M-ExprM], CS, CS1), M1 = E
xprM 
; M1 = [M],</spa
n> CS1 = CS 
)<s
pan class="sy4">, ( member([N-Ex
prN], CS1) -> select<spa
n class="br0">([N-</sp
an>ExprN], CS1, CS2), N1 <s
pan class="sy6">= ExprN 
; N1 = [N]

, CS2 = CS1 
). next_value<spa
n class="br0">(M, N, R, CS,&#91
;[R - [/, M1, N1]] | CS2]
) :- N \= <s
pan class="nu0">0, 
R <a href="http:
//pauillac.inria.fr/~deransar/prolog/bips.html">is</a>
rdiv(M,N
), 
(
member([M-ExprM], CS<s
pan> select([M-ExprM],
CS, CS1)
, M1 = ExprM 
;</spa
n> M1 = [M], CS1 = CS 
), ( member(&
#91;N-ExprN], CS1) -
> select([N-ExprN]<s
pan class="sy4">, CS1, CS2&#41
;, N1 = ExprN 
; N1 = &#9
1;N], CS2 = CS1 
. my_write(V) :- 
format
('~w ', [V]).</pre>
<div>
</dt></dl>
<pre>?- play24(4,9, 24).
6 2 3 4 : (6-2+4)*3
true ;
6 2 3 4 : 3*(6-2+4)
true ;
6 2 3 4 : (6-2+4)*3
true ;
6 2 3 4 : 3*(6-2+4)
true ;
6 2 3 4 : (6*2-4)*3
true ;
6 2 3 4 : 3*(6*2-4)
true ;
6 2 3 4 : 3*4+6*2
true ;
6 2 3 4 : 3*4+6*2
true ;
6 2 3 4 : 4*3+6*2
true ;
6 2 3 4 :
true ;
6 2 3 4 :
true ;
6 2 3 4 :
true ;
6 2 3 4 :
true ;
6 2 3 4 :
true ;
6 2 3 4 :
true ;
6 2 3 4 :
true ;
6 2 3 4 :
...
4*3+6*2
(6/2+3)*4
4*(6/2+3)
(6/2+3)*4
4*(6/2+3)
(6-3)*2*4
4*(6-3)*2
(6-3)*4*2
?- play24(7,99, 1).
66 40 2 76 95 59 12 : (66+40)/2-76+95-59-12
true ;
66 40 2 76 95 59 12 : (66+40)/2-76+95-12-59
true ;
66 40 2 76 95 59 12 : (66+40)/2-76-59+95-12
true ;
66 40 2 76 95 59 12 : (66+40)/2-76-59-12+95
true ;
66 40 2 76 95 59 12 : 95+(66+40)/2-76-59-12
true ;
66 40 2 76 95 59 12 : 95+(66+40)/2-76-59-12
true ;
66 40 2 76 95 59 12 : 95-12+(66+40)/2-76-59
true ;
66 40 2 76 95 59 12 : (66+40)/2-76-59+95-12
....
</pre>
tion=edit&section=36" title="Edit section: Minimal version">edit</a>]
Minimal version</h3>
<div class="examplemeta workswith">Works with: <a href="/wiki/GNU_Prolog"
title="GNU Prolog">GNU Prolog</a> version 1.4.4</div>
Little efforts to remove dublicates (e.g. output for [4,6,9,9]).

<pre class="prolog highlighted_source">:- <a href="http
://pauillac.inria.fr/~deransar/prolog/bips.html">initializatio
n</a>(main)<spa
n class="sy4">. solve(N<spa
n class="sy4">,Xs,Ast)</sp
an> :- 
Err = evaluati
on_error(zero_divisor)
 , gen_ast(Xs,Ast),
<a href="http://pauillac.inria.fr/~deransar/prolog/bips.html">
catch</a>(Ast =:= N
, error(Err,_), <a href="ht
tp://pauillac.inria.fr/~deransar/prolog/bips.html">fail
</a>) . 
 gen_ast([N],N) :- between(1,9,N). gen_as
t(Xs,Ast
) :- 
Ys =
[_|_&#93
;, Zs = [_|_], split(Xs,</sp
an>Ys,Zs) , ( member(<a href="http://pauillac.inria.fr/~deransar/prolog/bips.html">Op</a>, [(+),(*</sp
an>)]), Ys @=< Zs ; member(<a href="http://pauillac.inria.fr/~deransar/prolog/bips.html">Op</a>, [<spa
n class="br0">(-)</spa
n>,(//)]) ) ,
gen_ast(Ys,A), gen_ast(Zs,B), Ast =.. [<a href="http://pauillac.inria.fr/~deransar/prolog/bips.html"><sp
an class="kw1">Op</a>,A,B] . split(Xs,Ys,Zs) :- subl
ist(Ys,Xs), select_all(
Ys,Xs,Zs&#41
;. 
% where 
select_all([<spa
n class="br0">],Xs,
Xs). 
select_all<s
pan class="br0">([Y|Ys],Xs,Zs) :- select<s
pan class="br0">(Y,Xs,</sp
an>X1), 
!, select_all(Ys<sp
an class="sy4">,X1,Zs)</sp
an>. test(T) :- solve<s
pan class="br0">(24, [2,</s
pan>3,8</spa
n>,9]</s
pan>, T)
. main :- forall(</sp
an>test(T), (<a href="http://pauillac.inria.fr/~
deransar/prolog/bips.html">write</a>&
#40;T), <a href="ht
tp://pauillac.inria.fr/~deransar/prolog/bips.html">nl</
a>))

, <a href="http://pauillac.inria.fr/~deransar/prolog/bips.html">halt</a>.</pre>
<div>
</dt></dl>
<pre>(9-3)*8//2
3*8-2//9
(8+9)//2*3
(8-2//9)*3
(2//9+8)*3
(2+8*9)//3
2//9+3*8
8//2*(9-3)
(9-3)//2*8
(9-2*3)*8
(3-2//9)*8
(2//9+3)*8
(2+9)//3*8</pre>
tion=edit&section=37" title="Edit section: Python">edit</a>] <a href="/wiki/Category:Python" title="Category:Py
thon">Python</a></h2>
The function is called solve, and is integrated into the game player.
The docstring of the solve function shows examples of its use when isolated at t
he Python command line.

<pre class="python highlighted_source">''' The 24 Game P
layer Given any four digits in the range 1 to 9, which may hav
e repetitions, Using just the +, -, *, and / operators; and the possible u
se of brackets, (), show how to make an answer of 24. An
answer of "q" will quit the game. An answer of "!"
will generate a new set of four digits. An answer of "!!" will a
sk you for a new set of four digits. An answer of "?" will comp
ute an expression for the current digits. Otherwise you are re
peatedly asked for an expression until it evaluates to 24 Note
: you cannot form multiple digit numbers from the supplied digits, so an a
nswer of 12+12 when given 1, 2, 2, and 1 would not be allowed. 
''' from __
future__ import division,</spa
n> print_function from itertoo
ls import permutations, combinations, product, \ 
chain from pprint
import ppri
nt as pp from fr
actions import Fraction as F import random, ast, re <s
pan class="kw1">import sys <spa
n class="kw1">if sys.version_i
nfo[0] < 3: 
input = 
raw_input 
from iterto
ols import izip_longest as</sp
an> zip_longest else: 
f
rom itertools import zi
p_longest def choose4(): 
'four random digits >0 as characters' 

r
eturn [str(random.randint(1,
9)) for i in range(4)] <sp
an class="kw1">def ask4(&#
41;: 
'get four random digits >0 from the pl
ayer' 
digits = ''</sp
an> 
while len(digits) != 4 or 
not all(d in '123456789' for</s
pan> d in digits): 
digits = input('Enter the digits to solve for: '<s
pan class="br0">) 
digits = <spa
n class="st0">''.join(</sp
an>digits.strip().split()) 
return list(</spa
n>digits) def</s
pan> welcome(digits): 
print (__doc__<sp
an class="br0">) 
print ("Your four digits: " + <spa
n class="st0">' '.join(</s
pan>digits)) &#16
0; def check(answer<s
pan class="sy0">, digits): 
allowed
= set('() +-*/\t'+''.join(digits
)) 
ok = all(ch
in allowed for ch in answer) and</spa
n> \ 
all(dig
its.count(dig) == answer.count</sp
an>(dig) for dig in set<spa
n class="br0">(digits)
) \ 
and not re.search('\d
\d', answer)
 
if ok: 
try</sp
an>: 
ast.parse(answer) 
except
: 
ok = False 
return ok def solve(digits&#41
;: 
"""\ 
>>> for digits in '3246 4788 1111 123456 1127 3838'.split():
 
solve(list(digits)) 
Solution
found: 2 + 3 * 6 + 4 

'2 + 3 * 6 + 4' 
Solution found: ( 4 + 7 8 ) * 8 
'( 4 + 7 - 8 ) * 8' 
No solution found for: 1 1 1 1 
'!' 
Solution found: 1 + 2 + 3 * ( 4 + 5 ) - 6 
'1 + 2 +
3 * ( 4 + 5 ) - 6' 
Solution found: ( 1 + 2 ) * ( 1 + 7 ) 
'( 1
+ 2 ) * ( 1 + 7 )' 
Solution found: 8 / ( 3 - 8 / 3 ) 
'8 / ( 3
- 8 / 3 )' 
>>> """ 
digilen <spa
n class="sy0">= len(digits) 
# length of an
exp without brackets 
exprlen = 2 * digilen - 1 
# permute all the digits 
digiperm =</spa
n> sorted(set(permutations(</s
pan>digits))# All the possible operator comb
inations 
opcomb = l
ist(product(<sp
an class="st0">'+-*/', repeat=
digilen-1)) 
# All the bracket insertion poi
nts: 
brackets = (
 [()] + [(x,y&#4
1; 
for x in range(0, exprlen, 2) 
for y in range(x+4
, exprlen+2,
 2) 
if (x,y) !=
(0,</spa
n>exprlen+1)] 
+ [(0, 3+1, 4+2, 7+3)<sp
an class="br0">] ) # d
ouble brackets case 
for d in digiperm: 
for ops in opcomb: 
if '/' in ops: 
d2 <s
pan class="sy0">= [('F(%s)' % i) <sp
an class="kw1">for i in d]
 # Use Fractions for accuracy 
else: 
d2 =
d 
ex = list(chain.from_iterable(zip_longest(d2, ops, fillvalue=<s
pan class="st0">''))) 
for b in brackets: 
exp = ex[::]
for insertpoint, bracket in zip(b, '()'*(len(
b)//2)): 
exp.<sp
an class="me1">insert(insertpoint, bracket) 
txt = ''.join</sp
an>(exp) 
try: 
num = eval(txt<spa
n class="br0">) 
except
ZeroDivisionError: 
continue 
if num <spa
n class="sy0">== 24: 
<s
pan class="kw1">if '/' in</spa
n> ops: 
exp = [ (term if not term.startswith('F(')
else term[2]) 
for term 
in exp ] 
ans = ' '.join(exp).rstrip() 
print ("Solution found:",a
ns) 
retu
rn ans 
print (</s
pan>"No solution found for:", ' '.join(digits))</s
pan>
 
return '!' def main(
):
 
digits = choose4() 
welcome(digits) 
trial = 0 
answe
r = '' 
chk = ans = False
while not (chk and ans ==</spa
n> 24): 
trial
+=1 
answer = input(</spa
n>"Expression %i: " % trial) 
chk = check(answer, digits&
#41; 
if answer ==
 '?': 
solve&#
40;digits) 
answer = '!' 
if
 answer.lower() == 'q'</spa
n>: 
break 
if answer == '!': 
digits = choose4() 
trial = 0 

print ("\n</sp
an>New digits:", ' '</spa
n>.join(digits)) 
continue 
if answer == '!!': 
digits = ask4()</spa
n> 
trial = 0 
print (<s
pan class="st0">"\nNew digits:", ' '.join<s
pan class="br0">(digits)) 
continue 
if not chk: 
<s
pan class="kw1">print (&qu
ot;The input '%s' was wonky!" % answer) 
else: 
if '/' in answer: 
# Use Fractions for accuracy in divisions
 
answer = ''.join( (('F(%s)'</sp
an> % char) if char in '123456789' else char) 
for char in answer <sp
an class="br0">) 
ans = <spa
n class="kw2">eval(answer&
#41; 
print &#
40;" = ", ans
) 
if ans
== 24: 
<s
pan class="kw1">print (&qu
ot;Thats right!") 
print ("Thank y
ou and goodbye") ma
in()</pre>
<div>
</dt></dl>
<pre>
The 24 Game Player
Given any four digits in the range 1 to 9, which may have repetitions,
Using just the +, -, *, and / operators; and the possible use of
brackets, (), show how to make an answer of 24.
An answer of "q" will quit the game.
An answer of "!" will generate a new set of four digits.
An answer of "?" will compute an expression for the current digits.
Otherwise you are repeatedly asked for an expression until it evaluates to 24
Note: you cannot form multiple digit numbers from the supplied digits,
so an answer of 12+12 when given 1, 2, 2, and 1 would not be allowed.
Your four digits: 6 7 9 5
Expression 1: ?
Solution found: 6 - ( 5 - 7 ) * 9
Thank you and goodbye</pre>
tion=edit&section=38" title="Edit section: Difficult case requiring precise
division">edit</a>] Difficult case requiring precise division</h3>
The digits 3,3,8 and 8 have a solution that is not equal to 24 when using Pyt
hons double-precision floating point because of a division in all answers.
The solver above switches to precise fractional arithmetic when division is invo
lved and so can both recognise and solve for cases like this, (rather than allow
ing some range of closeness to 24).
Evaluation needing precise division

<div>
</dt></dl>
<pre>...
Expression 1: !!
Enter the digits to solve for: 3388
New digits: 3 3 8 8
Expression 1: 8/(3-(8/3))
= 24
Thats right!
Thank you and goodbye</pre>
Solving needing precise division

<div>
</dt></dl>
<pre>...
Expression 1: !!
Enter the digits to solve for: 3388
New digits: 3 3 8 8
Expression 1: ?
Solution found: 8 / ( 3 - 8 / 3 )</pre>
tion=edit&section=39" title="Edit section: R">edit</a>] <a href="/wiki/Category:R" title="Category:R">R</a></
h2>
This uses exhaustive search and makes use of R's ability to work with express
ions as data. It is in principle general for any set of operands and binary oper
ators.

<pre class="text highlighted_source"> library(gtools) solve24 <- function(vals=c(8, 4, 2, 1), 
goal=24,
ops=c("+", "-", "*", &quot
;/")) { val.perms <- as.data.frame(t( 
permutations(length(vals), length(vals)))) nop <length(vals)-1 op.perms <- as.data.frame(t( 
do.
call(expand.grid, 
replicate(nop, list(ops))))) ord.perms <- as.data.frame(t( 
do.cal
l(expand.grid, 
replicate(n <- nop, 1:((n <
<- n-1)+1))))) for (val.perm in val.perms) 
for (o
p.perm in op.perms) 
for (ord.perm in ord.perms) 
{ 
expr <- as.list(vals[val.perm]) 
for (i in 1:nop) { 
expr[[ ord.perm[i] ]] <- call(as.character(op.perm[i]), 
expr[[ ord.perm[i] ]], 
expr[[ ord.perm[i]+1 ]]) 
expr
<- expr[ -(ord.perm[i]+1) ] 

} 
if (identical(eva
l(expr[[1]]), goal)) return(expr[[1]]) 
} return(
NA) } </pre>
<div>
</dt></dl>
<pre class="text highlighted_source"> > solve24() 8 * (4 - 2
+ 1) > solve24(c(6,7,9,5)) 6 + (7 - 5) * 9 > solve24(c(8,8,
8,8)) [1] NA > solve24(goal=49) #different goal value 8 * (4 +
2) + 1 > solve24(goal=52) #no solution [1] NA > solve24(op
s=c('-', '/')) #restricted set of operators (8 - 2)/(1/4) </pre>
tion=edit&section=40" title="Edit section: Racket">edit</a>] <a href="/wiki/Category:Racket" title="Category:Ra
cket">Racket</a></h2>
The sequence of all possible variants of expressions with given numbers n1
, n2, n3, n4 and operations o1, o2, o3.

<pre class="text highlighted_source"> (define (in-variants n1 o1 n2 o
2 n3 o3 n4) (let ([o1n (object-name o1)] 
[o2n (object-name o
2)] 
[o3n (object-name o3)]) 
(with-handlers ((exn:fail:cont
ract:divide-by-zero? ( (_) empty-sequence))) 
(in-para e 
( ist (o1 (o2 (o3 n1 n2) n3) n4) 
(o1 (o2 n1 (o3 n2 n3)) n4
) 
(o1 (o2 n1 n2) (o3 n3 n4)) 
(o1 n1 (o2 (o
3 n2 n3) n4)) 
(o1 n1 (o2 n2 (o3 n3 n4)))) 
( ist `
(((,n1 ,o3n ,n2) ,o2n ,n3) ,o1n ,n4) 
`((,n1 ,o2n (,n2 ,o3n ,n3
)) ,o1n ,n4) 
`((,n1 ,o2n ,n2) ,o1n (,n3 ,o3n ,n4)) 
`(,n1 ,o1n ((,n2 ,o3n ,n3) ,o2n ,n4)) 
`(,n1 ,o1n (,n2 ,
o2n (,n3 ,o3n ,n4)))))))) </pre>
Search for a so utions using brute force:

<pre c ass="text high ighted_source"> (define (find-so utions numbers
(goa 24)) (define in-operations ( ist + - * /)) (remove-dup icat
es (for*/ ist ([n1 numbers] 
[n2 (remove-from numbers
n1)] 
[n3 (remove-from numbers n1 n2)] 
[
n4 (remove-from numbers n1 n2 n3)] 
[o1 in-operations] 
[(res expr) (in-variants n1 o1 n2 o2 n3 o3 n4)] 
#:when (= res goa )) 
expr))) (define (remove-from num
bers . n) (fo dr remq numbers n)) </pre>
Examp es:

<pre>
> (find-so utions '(3 8 3 8))
'((8 / (3 - (8 / 3))))
> (find-so utions '(3 8 2 9))
'(((8 / 2) * (9 - 3))
(8 / (2 / (9 - 3)))
(8 * (9 - (3 * 2)))
(8 * ((9 - 3) / 2))
((8 * (9 - 3)) / 2)
(8 * (9 - (2 * 3)))
((9 - 3) * (8 / 2))
(((9 - 3) * 8) / 2)
((9 - (3 * 2)) * 8)
(((9 - 3) / 2) * 8)
((9 - 3) / (2 / 8))
((9 - (2 * 3)) * 8))
</pre>
In order to find just one so ution effective y one needs to change <tt>for*/
ist</tt> to <tt>for*/first</tt> in the function <tt>find-so utions</tt>.


<h2>[<a href="/mw/index.php?tit e=24_game/So ve&ac
tion=edit&section=41" tit e="Edit section: REXX">edit</a>] <a href="/wiki/Category:REXX" tit e="Category:REXX">RE
XX</a></h2>
<pre c ass="rexx high ighted_source">/*REXX program to he
p the user find so utions to the game of 24.
*/ /* Arg
 where one or both strings must be exact y four numera s (digit
s) comprised so ey of the numera s (digits) 1 9 (no zeroes). 
 In
SSS
S-FFFF
SSSS is the start,
 
FFFF is the start.
 
/*get the guess from the argument. */parse var orig start '-' finish /*get the start and finish
(maybe). */ start=space(start,0)
/*remove any b anks from the START. */ finish=space(finish,0)
/*remove any b anks from the FINISH. */ finish=word(finish start,1
)
/*if no FINISH
specified, use START.*/ digs=123456789
/*numera s (digits) that can be used. */
 ca va idate start ca va idate finish opers='+-*/'
/*define the ega arithmetic operators*/</spa
n> ops= ength(opers<s
pan c ass="br0">)
/* and the count
of them ( ength). */ 
do j=1 for ops
/*define a version for fast execution. */ 
o.j=substr(ope
rs,j,1) 
<spa
n c ass="kw3">end /*j*/ finds=0
/*number of f
ound so utions (so far). */ x.=0
/*a method to
ho d unique expressions. */ indent= eft<spa
n c ass="br0">('',30)
/*used to in
dent disp ay of so utions. */ 
/*a ternative: indent=copies(' ',30) */ Lpar=<spa
n c ass="st0">'('
/*a strin
g to make REXX code prettier. */ Rpar=')'
/*ditto.
*/ do g=start to finish
/*process a (possib e) r
ange of va ues.*/ if po
s(0,g)\==0 then iterate /*
ignore va ues with zero in them.
*/ 
do _=1 for
4
/*define versions for
faster execution.*/ 
g._=substr(g,_,1</sp
an>) 

end
/*_*/ 
do</sp
an> i=1
for ops
/*insert an operator after 1st number. */ 
do j=1 f
or ops
/*insert an operator after 2nd num
ber. */ 
do k=1</s
pan> for ops
/*insert a
n operator after 2nd number. */ 
do m=0 for 4
; L.= /*assume no eft
parenthesis so far. */ 
do n=
m+1 to 4</s
pan>
/*match eft paren with a right paren. */ 
L.m=Lpar
/*define a eft paren, m=0 means ignore*/ 
R.=
/*un-define a rig
ht parenthesis.
*/ 
if m==<s
pan c ass="nu0">1 & n==2 then L.=
/*specia case: (n)+ */ 
e se if m\==0 then R.n=Rpar
/*no (, no )*/ 
e= L.1 g.1 o.i L.2 g.2 o<sp
an c ass="sy0">.j L.3 g.</sp
an>3 R.3 o.k g.4 R.4 
e=space(e,0)
/*remove a b anks from th
e expression*/ 
/*(be ow) change expression:
*/ 
/*
/(yyy) ===> /div(yyy)
*/ 
/*Ena
b es to check for division by zero*/ 
origE=e
/*keep o d version for the disp ay.
*/ 
if pos('/(',e)<sp
an c ass="sy0">\==0 then</spa
n> e=changestr('/(', e, "/div(") 
/*Th
e above cou d be rep aced by:
*/ 
/* e=changestr('/(',e,"/div(")
*/</sp
an> 
/*IN
TERPRET stresses REXX's groin, so */ 
/* try to avoid repeated heavy ifting.*/ 
if x.e then iterate /*was
the expression a ready used?
*/ 
x.
e=1
/*mark
this expression as unique.
*/ 
/*have REXX do the heavy ifting (ugh).*/ 
interpret 'x=' e
/* strain
*/ 
pan c ass="sy0">/1
/*remove trai ing decima points(maybe)*/ 
if x\==24
then iterate
/*Not correct? Try again.

*/ 
finds=finds+
1
/*bump number of found s
o utions.
*/ 
_=trans ate<s
pan c ass="br0">(origE, '][', ")(")
/*show [], not ().
*/ 
say</spa
n> indent 'a so ution:' _
/*disp ay a so ution.
*/ 
end /*n*/ 
end</spa
n>
/*m*/ 
end</sp
an>
/*k*/ 
end</s
pan>
/*j*/ 
end
/*i*/ end
/*g*/ so s=find
s if so s==0 then so s='No'
/*make the sentence not so geek- ike. */ say</s
pan>; say so s 'unique so ution'</s
pan>s(finds) "found for" orig /*p ura ize.*/
 exit /*
pan>; parse arg q
/*tests if dividing by 0 (zero).
*/ if q=0 then q=1
e9
/*if dividing by zero, change divisor. */
 return q
/*changing Q inva idates the expression*/ /*GER subroutine*/ ;
if _\=='' then say 'guess=' _ say <sp
an c ass="kw1">arg(1);
say;
exit 13 /*S subroutine*/</spa
c ass="nu0">1)==1
then return 
''; return 's'
/*simp e p ura izer.*/ /
*va idate subroutine*/ va idat
an c ass="nu0">0;
_v=verify(y,digs) 
s
e ect 
when y==''</spa
n>
then ca ger 'no digits entered.' 
when ength(y&
#41;& t;4 then ca ger 'not enoug
h digits entered, must be 4' 
when ength(y)
>4 then ca ger 'too many digi
ts entered, must be 4' 
when pos(0,y)\==0
then ca ger "can't use the digit 0 (zero)" 
wh
en _v\==0
then ca ger 'i e
ga character:' substr(</s
pan>y,_v,1) 

otherwise nop 
end
/*se ect*/ return \errCode</pre>
Some o der REXXes don't have a changestr BIF, so one is
inc uded here <a href="/wiki/CHANGESTR.REX" tit e="CHANGESTR.REX">CH
ANGESTR.REX</a>.
 
output when the fo owing input is used: <tt> 1111-1234 </tt>

<pre sty e="height:30ex">
a so ution: [1+1+1]*8
a so ution: [1+1+2]*6
a so ution: [1+1*2]*8
a so ution: [1*1+2]*8
a so ution: 1*[1+2]*8
a so ution: [1/1+2]*8
a so ution: [1+1*3]*6
a so ution: [1*1+3]*6
a so ution: 1*[1+3]*6
a so ution: [1/1+3]*6
a so ution: 1-1+3*8
a so ution: [1-1+3]*8
a so ution: [1-1+3*8]
a so ution: 1-1+[3*8]
a so ution: 1-[1-3*8]
a so ution: 1*1*3*8
a so ution: [1*1*3]*8
a so ution: [1*1*3*8]
a so ution: 1*[1*3]*8
a so ution: 1*[1*3*8]
a so ution: 1*1*[3*8]
a so ution: 1/1*3*8
a so ution: [1/1*3]*8
a so ution: [1/1*3*8]
a so ution: 1/1*[3*8]
a so ution: 1/[1/3]*8
a so ution: 1/[1/3/8]
a so ution: [1+1+4]*4
a so ution: 1-1+4*6
a so ution: [1-1+4]*6
a so ution: [1-1+4*6]
a so ution: 1-1+[4*6]
a so ution: 1-[1-4*6]
a so ution: 1*1*4*6
a so ution: [1*1*4]*6
a so ution: [1*1*4*6]
a so ution: 1*[1*4]*6
a so ution: 1*[1*4*6]
a so ution: 1*1*[4*6]
a so ution: 1/1*4*6
a so ution: [1/1*4]*6
a so ution: [1/1*4*6]
a so ution: 1/1*[4*6]
a so ution: 1/[1/4]*6
a so ution: 1/[1/4/6]
a so ution: [1+1*5]*4
a so ution: [1*1+5]*4
a so ution: 1*[1+5]*4
a so ution: [1/1+5]*4
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
so
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
ution:
107 unique so utions found for 1111-1234
[1+1+6]*3
1-1+6*4
[1-1+6]*4
[1-1+6*4]
1-1+[6*4]
1-[1-6*4]
1*1*6*4
[1*1*6]*4
[1*1*6*4]
1*[1*6]*4
1*[1*6*4]
1*1*[6*4]
1/1*6*4
[1/1*6]*4
[1/1*6*4]
1/1*[6*4]
1/[1/6]*4
[1+1*7]*3
[1*1+7]*3
1*[1+7]*3
[1/1+7]*3
1-1+8*3
[1-1+8]*3
[1-1+8*3]
1-1+[8*3]
1-[1-8*3]
1*1*8*3
[1*1*8]*3
[1*1*8*3]
1*[1*8]*3
1*[1*8*3]
1*1*[8*3]
1/1*8*3
[1/1*8]*3
[1/1*8*3]
1/1*[8*3]
1/[1/8]*3
1/[1/8/3]
[1+2+1]*6
[1+2*1]*8
[1+2/1]*8
[1*2+1]*8
1*[2+1]*8
[1*2+2]*6
1*[2+2]*6
1*2*2*6
[1*2*2]*6
[1*2*2*6]
1*[2*2]*6
1*[2*2*6]
1*2*[2*6]
[1+2+3]*4
1*2*3*4
[1*2*3]*4
[1*2*3*4]
1*[2*3]*4
1*[2*3*4]
1*2*[3*4]
</pre>
tion=edit&section=42" tit e="Edit section: Ruby">edit</a>] <a href="/wiki/Category:Ruby" tit e="Category:Ruby">Ru
by</a></h2>
<div c ass="examp emeta trans ation">Trans ation of: <a href="/wiki/24_ga
me/So ve#Tc " tit e="24 game/So ve">Tc </a></div>
<pre c ass="ruby high ighted_source">c ass TwentyFourGa
meP ayer EXPRESSIONS = [ 
'((%d %s %d) %s %d) %s %d', 
'(%d %s (%d %s %d)) %s %d', 
'(%d %s %d) %s (%d %s %d)', 
'%d %s ((%d %s %d) %s&#160
;%d)', 
'%d %s (%d %s (%d %s&#16
0;%d))', ].map</spa
n>{|expr| [expr, expr.gsub
('%d', '
Rationa (%d,1)')]</spa
n>} OPERATORS = [:+, :-,&#1
60;:*, :/].repeated_permutation&#
40;3) OBJECTIVE = Rationa (24,1) def se f</sp
an>.so ve(digits[] 
digits.permutation.<spa
n c ass="me1">to_a.uniq.each do |a,b,c,d| 
OPERATORS.each do |op1,op2,op3| 
EXPRESSIONS.each do
|expr,expr_rat| 
# eva uate using rationa arithmetic 
te
st = expr_rat % [a, op1, b
, op2, c, op3, d] 
va ue = eva (test)</sp
an> rescue -
1 # catch division by zero 
if va ue == OBJECTIVE 
so utions & t;& t; expr % [a, op1, b, op2, c, op3, d] 
<spa
n c ass="kw1">end 
end 
<s
pan c ass="kw1">end 
end 
so uti
ons end end &
#160; # va idate user input digits = ARGV.<sp
an c ass="me1">map do |
arg| begin 
<s
pan c ass="kw3">Integer(arg) rescue ArgumentE
rror 
raise "erro
r: not an integer: '#{arg}'" end end digits.size == <spa
n c ass="nu0">4 or raise "error: need 4 digits, on y have #{digits.size}" so utions = TwentyFourGameP ayer.so ve(digits) <s
pan c ass="kw1">if so utions.empty? puts "no so utions" 
e se puts "found #{so utions.size} so utions, inc uding #{so utions.first}"
 puts so utions.sort</s
pan> end</pre>
<div>
<d ><dt>Output:</div>
</dt></d >
<pre>$ ruby 24game.p ayer.rb 1 1 1 1
no so utions
$ ruby 24game.p ayer.rb 1 1 2 7
found 8 so utions, inc uding (1 + 2) * (1 + 7)
(1 + 2) * (1 + 7)
(1 + 2) * (7 + 1)
(1 + 7) * (1 + 2)
(1 + 7) * (2 + 1)
(2 + 1) * (1 + 7)
(2 + 1) * (7 + 1)
(7 + 1) * (1 + 2)
(7 + 1) * (2 + 1)
$ ruby 24game.p ayer.rb 2 3 8 9
found 12 so utions, inc uding (8 / 2) * (9 - 3)
((9 - 3) * 8) / 2
((9 - 3) / 2) * 8
(8 * (9 - 3)) / 2
(8 / 2) * (9 - 3)
(9 - (2 * 3)) * 8
(9 - (3 * 2)) * 8
(9 - 3) * (8 / 2)
(9 - 3) / (2 / 8)
8 * ((9 - 3) / 2)
8 * (9 - (2 * 3))
8 * (9 - (3 * 2))
8 / (2 / (9 - 3))</pre>
tion=edit&section=43" tit e="Edit section: Sca a">edit</a>] <a href="/wiki/Category:Sca a" tit e="Category:Sca a
">Sca a</a></h2>
A non-interactive p ayer.

<pre c ass="sca a high ighted_source"><a href="http://sca a- ang.org">def</a> permute( :
 List[Doub e]<s
pan c ass="br0">): List&#9
1;List[Doub e]] =
<a href="http://sca a
- ang.org">match</a> { <a href="http://sca a- ang.org">case</a> Ni => List(Ni ) <a href="http://sca a- ang.org">case</spa
n></a> x :: xs => 
<a href="http://sca a- ang.org">for</a> { 
ys & t;- permute(xs) 
position & t;- 0 to ys. ength
 
( eft, right&#
41; = ys sp itAt position 
} <a href="http://sca a- ang.org">yie d</a> eft ::: (x :: right) &
#125; <a href="http://sca a- ang.org">
def</a> computeA Operations( : List[Doub e]</sp
an>): List[(Doub e,String)
] =
<a href="http
://sca a- ang.org">match</a> { <a href="http://sca a- ang.org">case</a> N
i => Ni <a href="http://sca a- ang.org"><sp
an c ass="kw1">case</a> x :: Ni => List((
x, "%1.0f" format x)</s
pan>) <a href="http://sca a- ang.org">case</a> x :: xs =
> 
<a href="http://sca a- ang.org">for</a> { 
(y
, ops) & t;- computeA Ope
rations(xs) 
(z, op) & t;- 
<a href="http://sca a- ang.org">if</a> (y == <spa
n c ass="nu0">0) 
List((x*
y, "*"), (x+y, "+"), (x-y, "-&q
uot;)) 
<a href="http://sca a- ang.org">e se</a> 
List((x*y, "*"&#
41;, (x/y, "/"), (x+y, "+"), 
(x-y, "-")) 
} <a
href="http://sca a- ang.org">yie d</a> (z, "(%1.0f%s%s)" format (x,op,ops)&
#41; } <a href="http:
//sca a- ang.org">def</a> hasSo ution
( : List[Doub e
]) =
 permute( ) f a
tMap computeA Operations fi ter (_._1 == 24) map (<s
pan c ass="sy0">_._2)</spa
n></pre>
Examp e:

<pre>
va prob emsIterator = (
Iterator
continua y List.fi (4)(sca a.uti .Random.nextInt(9) + 1 toDoub e)
fi ter (!hasSo ution(_).isEmpty)
)
va so utionIterator = prob emsIterator map hasSo ution

sca a> so utionIterator.next
res8: List[String] = List((3*(5-(3-6))), (3*(5-(3-6))), (3*(5+(6-3))), (3+(6+(3*
5))), (3*(6-(3-5))), (3+(6+(5*3))), (3*(
6+(5-3))), (3*(5+(6-3))), (3+(6+(5*3))), (3*(6+(5-3))), (6+(3+(5*3))), (6*(5-(3/
3))), (6*(5-(3/3))), (3+(6+(3*5))), (3*(
6-(3-5))), (6+(3+(3*5))), (6+(3+(3*5))), (6+(3+(5*3))))
res9: List[String] = List((4-(5*(5-9))), (4-(5*(5-9))), (4+(5*(9-5))), (4+(5*(95))), (9-(5-(4*5))), (9-(5-(5*4))), (9-(
5-(4*5))), (9-(5-(5*4))))
res10: List[String] = List((2*(4+(3+5))), (2*(3+(4+5))), (2*(3+(5+4))), (4*(3-(2
-5))), (4*(3+(5-2))), (2*(4+(5+3))), (2*
(5+(4+3))), (2*(5+(3+4))), (4*(5-(2-3))), (4*(5+(3-2))))
res11: List[String] = List((4*(5-(2-3))), (2*(4+(5+3))), (2*(5+(4+3))), (2*(5+(3
+4))), (2*(4+(3+5))), (2*(3+(4+5))), (2*
(3+(5+4))), (4*(5+(3-2))), (4*(3+(5-2))), (4*(3-(2-5))))
</pre>
tion=edit&section=44" tit e="Edit section: Sidef">edit</a>] <a href="/wiki/Category:Sidef" tit e="Category:Sidef
">Sidef</a></h2>
With eva uation:

<pre c ass="ruby high ighted_source">var formats = [ 
'((%d %s %d) %s %d) %s&#16
0;%d', 
'(%d %s (%d %s %d))&#160
;%s %d', 
'(%d %s %d) %s (%
d %s %d)', 
'%d %s ((%d %s&
#160;%d) %s %d)', 
'%d %s (%d&#1
60;%s (%d %s %d))', ]; &
#160; var op = %w( <s
pan c ass="sy0">+ - * / ); var operators = o
p.map { |a| op.map {|b| op.<sp
an c ass="me1">map {|</sp
an>c| "#{a} #{b} #{c}"</spa
n> } } }.f atten; oop { 
var input = Sys.<sp
an c ass="me1">scan n(&quo
t;Enter four integers or 'q' to exit: "); 
input == 'q' && break; 
input ~~ /^\h*[1-9]\h+[1-9<sp
an c ass="br0">]\h+[1-9</sp
an>]\h+&
#91;1-9]\h*$/ || ( 
say "Inva id input!"; next; 
); 
var
n = input.sp it.map{.to_i}</spa
n>; 
var numbers = n.permute; 
formats.each { |format| 
numbers.each {
|n| 
operator
s.each { |operator| 
var o = operat
or.sp it; 
var str = (format % (n[0</spa
n>],o[0],n[1],o[
1],n&#91
;2],o[2],n[3]
)); 
eva (str) == 24 &&</spa
n> say str; 
} 
} 
} }</pre>
Without eva uation:

<pre c ass="ruby high ighted_source">var formats = [ 
{|a,b,c| 
Hash.new( 
func => {|d,e,f,
g| (&#40
;d.$a(e)).$b(f)
).$c(g) }.copy</sp
an>, 
format =></s
pan> "((%d #{a} %d) #{b} %d) #{c} %d"
 
) 
&
#125;, 
{|
a,b,c| 
Hash.new( 
func <s
pan c ass="sy0">=> {|d,e,f,g| (d.$a((e.$b&#40
;f)))).$c(</spa
n>g) }.copy, 
format => "(%d #{a} (%d #{b} %d)) #{c} %
d", 
}, 
{
|a,b,c| 
Hash</spa
n>.new( 
f
unc => {|d,e,f,g| (d.

$a(e)).$b(f.$c(
g)) 
}.copy, 

format => "(%d #{a}&#1
60;%d) #{b} (%d #{c} %d)", 
)
 
}, 
&#1
23;|a,b,c| 
Hash.new&#4
0; 
func => {|d,e,f,g| <spa
n c ass="br0">(d.$a(e&
#41;).$b(f.$c<s
pan c ass="br0">(g)&#4
1; }.copy, 
format => "(%d #{a} %d) #{b} (%d #{c} %d)", 
}, 
{|a,b,c| 
Hash.new
( 
func 
=> {|d,e,f,g<sp
an c ass="sy0">| d.$a(e.$b
(f.$c(g)<sp
an c ass="br0">)) &#12
5;.copy, 
form
at => "%d #{a} (%d #{b
} (%d #{c} %d))", 
)
}, ]; var op = %w( + - *</spa
n> / ); var b ocks =
op.map { |a| op.map { |b| op.map { |c| formats.map { |format
| 
format(a,b,c) &#12
5;}}}.f atten; oop { 
var input = Sys
.scan n(
"Enter four integers or 'q' to exit: "); 
input == 'q' &&am
p; break; 
input ~~ /^\h*[<sp
an c ass="nu0">1-9]\h+[</sp
an>1-9]\h+&#9
1;1-9
]\h+[1-9]\h*$/ || ( 
say "Inva id input!"; next; 
); 
var n = input.sp it.map{.to_num&#125
;; 
var numbers = n.permute; 
 
b ocks.each { |b ock| 
numbers.<s
pan c ass="me1">each { |n| 
if (b ock[:func].ca (n...) == 
24) { 
say (b ock[</spa
n>:format] % (n...)<spa
n c ass="br0">); 
} 
}</spa
n> }</pre>
<div>
</dt></d >
<pre>
Enter four integers or 'q' to exit: 8 7 9 6
(8 / (9 - 7)) * 6
(6 / (9 - 7)) * 8
(8 * 6) / (9 - 7)
(6 * 8) / (9 - 7)
8 / ((9 - 7) / 6)
6 / ((9 - 7) / 8)
8 * (6 / (9 - 7))
6 * (8 / (9 - 7))
Enter four integers or 'q' to exit: q
</pre>
tion=edit&section=45" tit e="Edit section: Swift">edit</a>] <a href="/wiki/Category:Swift" tit e="Category:Swift
">Swift</a></h2>
<pre c ass="text high ighted_source"> import Darwin import Found
ation var so ution = "" print n(&quo
t;24 Game") print n("Generating 4 digits...") func randomDigits() -> [Int] { var resu t = [Int]() for i in
0 ..& t; 4 { 
resu t.append(Int(arc4random_uniform(9)+1)) } return resu t } // Choose 4 digits et digits = ra
ndomDigits() print("Make 24 using these digits : &quo
t;) for digit in digits { print("\(digit) ")} print n() // get input from operator var input
= NSString(data:NSFi eHand e.fi eHand eWithStandardInput().avai ab eData, encodi
ng:NSUTF8StringEncoding)! var enteredDigits = [Doub e]() &
#160; var enteredOperations = [Character]() et inputStrin
g = input as String // store input in the appropriate tab e for character in inputString { switch character { case "1&q
uot;, "2", "3", "4", "5", "6",
"7", "8", "9": 
et digit = String(charac
ter) 
enteredDigits.append(Doub e(digit.toInt()!)) case "+&q
uot;, "-", "*", "/": 
enteredOperations.ap
pend(character) case "\n": 
print n() defau t:
print n("Inva id expression") } } // check va ue of expression provided by the operator var va ue = 0.0 if enteredDigits.count == 4 && enteredOperations.count == 3
{ va ue = enteredDigits[0] for (i, operation) in enumerate(entere
dOperations) { 
switch operation { 
case "+": 
va ue = va ue + enteredDigits[i+1] 
case "-": 
va
ue = va ue - enteredDigits[i+1] 
case "*": 
va ue =
va ue * enteredDigits[i+1] 
case "/": 
va ue = va u
e / enteredDigits[i+1] 
defau t: 
print n("This message s
hou d never happen!") 
} } } func eva
uate(dPerm: [Doub e], oPerm: [String]) -> Boo { var va ue = 0.0 
 if dPerm.count == 4 && oPerm.count == 3 { 
va ue =
dPerm[0] 
for (i, operation) in enumerate(oPerm) { 
switch op
eration { 
case "+": 
va ue = va ue + dPerm[i+1]
 
case "-": 
va ue = va ue - dPerm[i+1] 
case "*": 
va ue = va ue * dPerm[i+1] 
case &
quot;/": 
va ue = va ue / dPerm[i+1] 
defau t: 
print n("This message shou d never happen!") 
} 
} } return (abs(24 - va ue) & t; 0.001) } func isSo vab e(inout digits: [Doub e]) -> Boo { var re
su t = fa se var dPerms = [[Doub e]]() permute(&digits, &d
Perms, 0) 
et tota = 4 * 4 * 4 var oPerms = [[String]
]() permuteOperators(&oPerms, 4, tota ) 
for dig in dPerms { 
for opr in oPerms { 
var expression = &
quot;" 
if eva uate(dig, opr) { 
for digi
t in dig { 
expression += "\(digit)" 
} 
for oper in opr { 
expression += oper 
} 
so ution = beautify(expression) 
re
su t = true 
} 
} } return resu t } &#
160; func permute(inout st: [Doub e], inout res: [[Doub e]], k: Int) ->
Void { for i in k ..& t; st.count { 
swap(& st[i], & st
[k]) 
permute(& st, &res, k + 1) 
swap(& st[k], &amp
; st[i]) } if k == st.count { 
res.append( st) }} // n=4, tota =64, npow=16 func permuteOperators(inou
t res: [[String]], n: Int, tota : Int) -> Void { et posOperations = [
"+", "-", "*", "/"] 
et npow = n
* n for i in 0 ..& t; tota { 
res.append([posOperations[(i / npo
w)], posOperations[((i % npow) / n)], posOperations[(i % n)]]) 
} } func beautify(infix: String) -> String { 
et
newString = infix as NSString var so ution = "" so ution += newString.substringWithRange(NSMakeRange(0, 1)) so ution += newString.substringWithRange(NSMakeRange(12, 1)) so ution
+= newString.substringWithRange(NSMakeRange(3, 1)) so ution += newString
.substringWithRange(NSMakeRange(13, 1)) so ution += newString.substringWi
thRange(NSMakeRange(6, 1)) so ution += newString.substringWithRange(NSMak
eRange(14, 1)) so ution += newString.substringWithRange(NSMakeRange(9, 1)
) return so ution } if va ue != 24
{ print n("The va ue of the provided expression is \(va ue) instead
of 24!") if isSo vab e(&enteredDigits) { 
print n(&quot
;quot;A possib e so ution cou d have been " + so ution) } e se { 
print n("Anyway, there was no known so ution to this one.") } } e se { print n("Congratu ations, you found a so ution!&q
uot;) }</pre>
<div>
<d ><dt>Output:</div>The program in action:
</dt></d >
<pre sty e="height:30ex;overf ow:scro ">
24 Game
Generating 4 digits...
Make 24 using these digits : 2 4 1 9
2+1*4+9
The va ue of the provided expression is 21.0 instead of 24!
A possib e so ution cou d have been 9-2-1*4
24 Game
7-2*2*3
A possib e so ution cou d have been 3+7+2*2
24 Game
4+4+6+3
A possib e so ution cou d have been 3*4-6*4
24 Game
8+8+2+6
Congratu ations, you found a so ution!
24 Game
6+7+8+9
Anyway, there was no known so ution to this one.
</pre>
tion=edit&section=46" tit e="Edit section: Tc ">edit</a>] <a href="/wiki/Category:Tc " tit e="Category:Tc ">Tc </a
></h2>
This is a comp ete Tc script, intended to be invoked from the command ine.

<div c ass="examp emeta ibheader">Library: <a href="/wiki/Category:Tc i
b" tit e="Category:Tc ib">Tc ib</a> <sma >(Package: struct:: ist)</sma
></div>
<pre c ass="tc high ighted_source">package require str
uct:: ist # Encoding the various
expression trees that are possib e set pat
terns { 
{<s
pan c ass="br0">((A x B) y C) z D}</spa
n> 
{(A x <s
pan c ass="br0">(B y C)) z D} 
23;(A x B) y <s
pan c ass="br0">(C z D)} 
{A x &
#40;(B y C) z D
)} 
{A x (B y 
(C z D))<sp
an c ass="br0">} } # Encoding the various permutations of digits set permutations [struct:: ist map [struct:: is
t permutations {a b c d&#

125;] \ 
;app y {v { a
ssign $v a b c d; ist A $a B $b C
$c D $d&#125
;}}] # The permitted operations set operations {+ - <s
pan c ass="sy0">* /} # Given a ist of four integers (precondition not checked!) 
 # return a ist of so utions to the 24 game using those
four integers. proc find24GameSo utions <sp
an c ass="br0">{va ues} { 
g oba operations patterns p
ermutations 
set found {
} 
# For each pos
sib e structure with numbers at the eaves... 

foreach pattern $patterns &#12
3; foreach permutation $
permutations { 
set p [string
map [subst { 
a [ index $va ues 0].0 
b [
 index $va ues 1].0 
c [ index $va ues
2].0 
d [ index $va ues 3].0 
}] [string map $p
ermutation $pattern]] 
#
For each possib e structure with operators at the branches... 
foreach x $operations <spa
n c ass="br0">{ 
foreach
y $operations { 
foreach z $operations <spa
n c ass="br0">{ 
set</s
pan> e [string map [subst {x $x y $y z $z}] <spa
n c ass="re0">$p] 
# Try to eva uate (div-zero is an issue!) and add it to
 
# the resu t if it is 24 
catch { 
if {[expr $e] == 24.0}</s
pan> { 
 append found [s
tring map {.0 {</spa
n>}} $e] 
<spa
n c ass="br0">} 
}
 

} 
}
 
return $found } # Wrap the so
ution finder into a p ayer proc print24Game
So utionFor {va ues}
{ 
set found <sp
an c ass="br0">[ sort -unique [find24GameSo utions $va ues]] 
if {![ ength $found<sp
an c ass="br0">]} &#1
23; 
puts "No
so ution possib e" 
} e se { 
puts "Tota [ ength $found] so utions (may inc
ude ogica dup icates)" 
puts
"First so ution: [ index $found 0]" 
} } print2
4GameSo utionFor $argv</pre>
<div>
</dt></d >
Demonstrating it in use:

<pre>bash$ tc
sh8.4 24p ayer.tc 3 2 8 9
Tota 12 so utions (may inc ude ogica dup icates)
First so ution: ((9 - 3) * 8) / 2
bash$ tc sh8.
4 24p ayer.tc 1 1 2 7
Tota 8 so utions (may inc ude ogica dup icates)
First so ution: (1 + 2) * (1 + 7)
bash$ tc sh8.
4 24p ayer.tc 1 1 1 1
No so ution possib e
</pre>
tion=edit&section=47" tit e="Edit section: Ursa a">edit</a>] <a href="/wiki/Category:Ursa a" tit e="Category:Ur
sa a">Ursa a</a></h2>
This uses exhaustive search and exact rationa arithmetic to enumerate a so
utions. The a gorithms accommodate data sets with any number of digits and any
target va ue, but wi be imited in practice by combinatoria exp osion as note
d e sewhere. (Rationa s are stored as pairs of integers, hence
<code>("n",1)</code> for n/1, etc..)
The <code>tree_shapes</code> function generates a ist of binary trees of
a possib e shapes for a given
number of eaves. The <code>with_ eaves</code> function substitutes a ist of nu
mbers into the eaves of
a tree in every possib e way. The <code>with_roots</code> function substitutes a
ist of operators into the
non-termina nodes of a tree in every possib e way. The <code>va ue</code> funct
ion eva uates a tree and the
<code>format</code> function disp ays it in a readab e form.

<pre c ass="text high ighted_source">#import std #import nat #import r
at tree_shapes = "n". (@vLPiYo //eq iota "n&quo
t;)*~ (rep"n" ~&iiiK0N rNCCVSPTs) {0^:& t;>} with_ eaves =
^|Dr Dr K34SPSL/permutations ~& with_roots = ^Dr Dr K35d PvVoPSPSL\~&

amp;r @ rhvdNCBvLPTo2D S @hiNCSPtCx ~&K0=> va ue
= *^ ~&v?
\(@d ~&\1) ^|H\~&hthPX '+-*/'-$& t;sum,difference,product,quotient>format
= *^ ~&v?\-+~&h,%zP@d+- ^H/mat@d *v ~&t?\~&&#160
;:/`(+ --')' game"n" "d" = format* va ue==(
"n",1)*~ with_roots/'+-*/' with_ eaves/"d"*-1 tree_shapes e
ngth "d"</pre>
test program:

<pre c ass="text high ighted_source">#show+ test_games = mat` *
pad` *K7 pad0 game24* & t;& t;2,3,8,9>,& t;5,7,4,1>,& t;5,6,7,8>></
pre>
output:

<pre>
8/(2/(9-3)) 1-(5-(7*4)) 6*(5+(7-8))
8*(9-(2*3)) 1-(5-(4*7)) 6*(7+(5-8))
8*(9-(3*2)) 1+((7*4)-5) 6*(7-(8-5))
8*((9-3)/2) 1+((4*7)-5) 6*(5-(8-7))
(8/2)*(9-3) (7*4)-(5-1) 6*(8/(7-5))
(9-3)/(2/8) (7*4)+(1-5) 8*(6/(7-5))
(9-3)*(8/2) (4*7)-(5-1) 6*((5+7)-8)
(8*(9-3))/2 (4*7)+(1-5) 6*((7+5)-8)
(9-(2*3))*8 (1-5)+(7*4) 6/((7-5)/8)
(9-(3*2))*8 (1-5)+(4*7) 6*((7-8)+5)
((9-3)/2)*8 (7*(5-1))-4 6*((5-8)+7)
((9-3)*8)/2 (1+(7*4))-5 8/((7-5)/6)
(1+(4*7))-5 (5+7)*(8-6)
((7*4)-5)+1 (7+5)*(8-6)
((7*4)+1)-5 (6*8)/(7-5)
((4*7)-5)+1 (8-6)*(5+7)
((4*7)+1)-5 (8-6)*(7+5)
((5-1)*7)-4 (8*6)/(7-5)
(6/(7-5))*8
(5+(7-8))*6
(7+(5-8))*6
(7-(8-5))*6
(5-(8-7))*6
(8/(7-5))*6
((5+7)-8)*6
((7+5)-8)*6
((7-8)+5)*6
((5-8)+7)*6
</pre>
tion=edit&section=48" tit e="Edit section: zk ">edit</a>] <a href="/wiki/Category:Zk " tit e="Category:Zk ">zk </a
></h2>
A brute for search for a so utions. Lexicographica dup icates are removed.
Fi e so ve24.zk :

<pre c ass="text high ighted_source">var H=Uti s.He pers; fcn u(xs){xs.redu
ce(fcn(us,s){us.ho ds(s) and us or us.append(s)},L())} var ops=u(H.combosK(
3,"+-*/".sp it("")).app y(H.permute).f atten()); var fs
=T( fcn f0(a,b,c,d,x,y,z){Op(z)(Op(y)(Op(x)(a,b),c),d)}, // ((AxB)yC)zD fcn f1(a,b,c,d,x,y,z){Op(y)(Op(x)(a,b),Op(z)(c,d))}, // (AxB)y(CzD) fcn f2(a,b,c,d,x,y,z){Op(z)(Op(x)(a,Op(y)(b,c)),d)}, // (Ax(ByC))zD 
fcn f3(a,b,c,d,x,y,z){Op(x)(a,Op(z)(Op(y)(b,c),d))}, // Ax((ByC)zD) fcn
f4(a,b,c,d,x,y,z){Op(x)(a,Op(y)(b,Op(z)(c,d)))}, // Ax(By(CzD)) ); &#1
60; var fts= // format strings for human readab e formu as T("(
(d.d).d).d", "(d.d).(d.d)", "(d.(d.d)).d", "d.((d.

d).d)", "d.(d.(d.d))") .app y(T(T("rep ace",&quo
t;d","%d"),T("rep ace",".","%s")));
 fcn f2s(digits,ops,f){ // formu a (fs[n]) to string ft
s[f.name[1].toInt()] 
.fmt(H. istZip(digits,ops).f atten().xp ode(),di
gits[3]); } fcn game24So ver(digitsString){ digits
:=digitsString.sp it("").app y("toF oat"); [[(digits
4,ops3,f); H.permute(digits); ops; 
fs,{try{f(digits4.xp ode(),ops3.xp
ode()).c oseTo(24,0.001)} 
catch(MathError){Fa se}}; 
{f
2s(digits4,ops3,f)}]]; } so utions:=u(game24So ver(ask(0,&
quot;digits: "))); print n(so utions. en()," so utions:");so utions.app y2(Conso e.print n);</pre>
One trick used is to ook at the so ving functions name and use the digit in
it to index into the formats ist.

<div>
</dt></d >
<pre>
zk so ve24.zk 6795
6 so utions:
6+((7-5)*9)
6-((5-7)*9)
6-(9*(5-7))
6+(9*(7-5))
(9*(7-5))+6
((7-5)*9)+6
zk so ve24.zk 1111
0 so utions:
zk so ve24.zk 3388
1 so utions:
8/(3-(8/3))
zk so ve24.zk 1234
242 so utions:
((1+2)+3)*4
...
</pre>
<!-NewPP imit report
Preprocessor visited node count: 2247/1000000
Preprocessor generated node count: 4279/1000000
Post-expand inc ude size: 9169/2097152 bytes
Temp ate argument size: 1617/2097152 bytes
Highest expansion depth: 5/40
Expensive parser function count: 0/100
-->

</div>


<div c ass="printfooter">
Retrieved from "<a href="http://rosettacode.org/
mw/index.php?tit e=24_game/So ve&o did=210398">http://rosettacode.org/mw/ind
ex.php?tit e=24_game/So ve&o did=210398</a>"
</div>


<div id='cat inks' c ass='cat inks'><div id="mwnorma -cat inks" c ass="mw-norma -cat inks"><a href="/wiki/Specia :Categories" t
it e="Specia :Categories">Categories</a>: <a href="/wiki/Category:Progra
mming_Tasks" tit e="Category:Programming Tasks">Programming Tasks</a><a
href="/wiki/Category:So utions_by_Programming_Task" tit e="Category:So utions b
y Programming Task">So utions by Programming Task</a><a href="/wiki/Cat
egory:ABAP" tit e="Category:ABAP">ABAP</a><a href="/wiki/Category:Argi
e" tit e="Category:Argi e">Argi e</a><a href="/wiki/Category:AutoHotkey
" tit e="Category:AutoHotkey">AutoHotkey</a><a href="/wiki/Category:BBC
_BASIC" tit e="Category:BBC BASIC">BBC BASIC</a><a href="/wiki/Category
:C" tit e="Category:C">C</a><a href="/wiki/Category:C%2B%2B" tit e="Cat
egory:C++">C++</a><a href="/wiki/Category:C ojure" tit e="Category:C oj
ure">C ojure</a><a href="/wiki/Category:CoffeeScript" tit e="Category:C
offeeScript">CoffeeScript</a><a href="/wiki/Category:Common_Lisp" tit e
="Category:Common Lisp">Common Lisp</a><a href="/wiki/Category:D" tit e
="Category:D">D</a><a href="/wiki/Category:ERRE" tit e="Category:ERRE">
ERRE</a><a href="/wiki/Category:Eu er_Math_Too box" tit e="Category:Eu
er Math Too box">Eu er Math Too box</a><a href="/wiki/Category:F_Sharp"
tit e="Category:F Sharp">F Sharp</a><a href="/wiki/Category:Fortran" t
it e="Category:Fortran">Fortran</a><a href="/wiki/Category:GAP" tit e="
Category:GAP">GAP</a><a href="/wiki/Category:Go" tit e="Category:Go">Go
</a><a href="/wiki/Category:Gosu" tit e="Category:Gosu">Gosu</a><a href="/wiki/Category:Haske " tit e="Category:Haske ">Haske </a>
<a href="/wiki/Category:Icon" tit e="Category:Icon">Icon</a><a href="/w
iki/Category:Unicon" tit e="Category:Unicon">Unicon</a><a href="/wiki/C
ategory:Icon_Programming_Library" tit e="Category:Icon Programming Library">Icon
Programming Library</a><a href="/wiki/Category:J" tit e="Category:J">J
</a><a href="/wiki/Category:Java" tit e="Category:Java">Java</a><a href="/wiki/Category:JavaScript" tit e="Category:JavaScript">JavaScript</a>
<a href="/wiki/Category:Jq" tit e="Category:Jq">Jq</a><a href=
"/wiki/Category:Ju ia" tit e="Category:Ju ia">Ju ia</a><a href="/wiki/C
ategory:Liberty_BASIC" tit e="Category:Liberty BASIC">Liberty BASIC</a>
<a href="/wiki/Category:Lua" tit e="Category:Lua">Lua</a><a href="/wiki
/Category:Mathematica" tit e="Category:Mathematica">Mathematica</a><a h
ref="/wiki/Category:Wo fram_Language" tit e="Category:Wo fram Language">Wo fram
Language</a><a href="/wiki/Category:OCam " tit e="Category:OCam ">OCam
</a><a href="/wiki/Category:Per " tit e="Category:Per ">Per </a><a href="/wiki/Category:Per _6" tit e="Category:Per 6">Per 6</a><a
href="/wiki/Category:Phix" tit e="Category:Phix">Phix</a><a href="/wiki
/Category:PicoLisp" tit e="Category:PicoLisp">PicoLisp</a><a href="/wik
i/Category:ProDOS" tit e="Category:ProDOS">ProDOS</a><a href="/wiki/Cat
egory:Pro og" tit e="Category:Pro og">Pro og</a><a href="/wiki/Category
:Python" tit e="Category:Python">Python</a><a href="/wiki/Category:R" t
it e="Category:R">R</a><a href="/wiki/Category:Racket" tit e="Category:
Racket">Racket</a><a href="/wiki/Category:REXX" tit e="Category:REXX">R
EXX</a><a href="/wiki/Category:Ruby" tit e="Category:Ruby">Ruby</a><a href="/wiki/Category:Sca a" tit e="Category:Sca a">Sca a</a><a
href="/wiki/Category:Sidef" tit e="Category:Sidef">Sidef</a><a href="/w
iki/Category:Swift" tit e="Category:Swift">Swift</a><a href="/wiki/Cate
gory:Tc " tit e="Category:Tc ">Tc </a><a href="/wiki/Category:Tc ib" t
it e="Category:Tc ib">Tc ib</a><a href="/wiki/Category:Ursa a" tit e=
"Category:Ursa a">Ursa a</a><a href="/wiki/Category:Zk " tit e="Categor
y:Zk ">Zk </a><a href="/wiki/Category:GUISS/Omit" tit e="Category:GUISS
/Omit">GUISS/Omit</a><a href="/wiki/Category:ML/I/Omit" tit e="Category
:ML/I/Omit">ML/I/Omit</a></div></div>

<div c ass="visua C ear"></div>

-->



</div>


<div id="mw-head" c ass="noprint">

<div id="p-persona " c ass="">
<h5>Persona too s</h5>

<a href="/mw/index.php?tit e=Specia :U
serLogin&returnto=24+game%2FSo ve&type=signup">Create account</a>
<a href="/mw/index.php?tit e=Specia :UserLogin
&returnto=24+game%2FSo ve" tit e="You are encouraged to og in; however, it
is not mandatory [o]" accesskey="o">Log in</a>

</div>

<div id=" eft-navigation">

<div id="p-namespaces" c ass="vectorTabs">
<h5>Namespaces</h5>

<a href="/wiki/24_game/So ve" tit e="View the content page [c]" accesske
y="c">Page</a>
<a href="/wiki/T
a k:24_game/So ve" tit e="Discussion about the content page [t]" accesskey="t">
Discussion</a>

</div>


<div id="p-variants" c ass="vectorMenu emptyPort et">
<h4>
</h4>
<h5>Variants<a href="#"></a></h5>
<div c ass="menu">


</div>
</div>

</div>
<div id="right-navigation">

<div id="p-views" c ass="vectorTabs">
<h5>Views</h5>


<a href="/wiki/24_game/So ve" >Read</a>
<a href="/mw/inde
x.php?tit e=24_game/So ve&action=edit" tit e="You can edit this page. P eas
e use the preview button before saving [e]" accesskey="e">Edit</a>

<a href="/mw/index.php?tit e=24_game/So ve&action=history" tit e="Pas
t revisions of this page [h]" accesskey="h">View history</a>

</div>


<div id="p-cactions" c ass="vectorMenu emptyPort et">
<h5>Actions<a href="#"></a></h5>
<div c ass="menu">


</div>
</div>


<div id="p-search">
<h5>< abe for="searchInput">Search</ abe ></h5>
<form action="/mw/index.php" id="searchform">
<div>
<input type="search" name="search" tit e="Search Rosetta
Code [f]" accesskey="f" id="searchInput" />
<input type="sub
mit" name="go" va ue="Go" tit e="Go to a page with this exact name if exists" id
="searchGoButton" c ass="searchButton" />
<input type="sub
mit" name="fu text" va ue="Search" tit e="Search the pages for this text" id="m
w-searchButton" c ass="searchButton" />
<input t
ype='hidden' name="tit e" va ue="Specia :Search"/>
</div>
</form>
</div>

</div>
</div>


<div id="mw-pane " c ass="noprint">

<div id="p- ogo"><a sty e="background-im
age: ur (/mw/tit e.png);" href="/wiki/Rosetta_Code" tit e="Visit the main page"
></a></div>


<div c ass="porta " id='p-Community'>
<h5>Community</h5>
<div c ass="body">

<a href="http://twitter.com/rosettaco
de" re ="nofo ow">Twitter</a>
at/IRC</a>
<a href="/wiki/Specia :WebChat">Ch

<a href="http://rosettacode.org/p anet
" re ="nofo ow">P anet</a>
<a href="/wiki/Rosetta_Code:
Vi age_Pump">The Vi age Pump</a>
<a href="/wiki/Rosetta_Code:Finances
">Finances</a>

</div>
</div>


<div c ass="porta " id='p-Exp ore'>
<h5>Exp ore</h5>
<div c ass="body">

<a href="/wiki/Category:Programming
_Languages">Languages</a>
<a href="/wiki/Category:Programming_Tas
ks">Tasks</a>
<a href="/wiki/Specia :RecentCh
anges" tit e="A ist of recent changes in the wiki [r]" accesskey="r">Recent cha
nges</a>
<a href="/wiki/He p:Simi ar_Sit
es">Simi ar sites</a>
<a href="/wiki/Specia :Random" tit
e="Load a random page [x]" accesskey="x">Random page</a>

</div>
</div>


<div c ass="porta " id='p-Misc'>
<h5>Misc</h5>
<div c ass="body">

<g:p usone></g:p usone>

<script type="text/rocketscript">
(function() {
var po = document.createE ement('script'); po.type = 'text/javascript'; po.a
sync = true;
po.src = 'https://apis.goog e.com/js/p usone.js';
var s = document.getE ementsByTagName('script')[0]; s.parentNode.insertBefor
e(po, s);
})();
</script>
<a href="https://twitter.com/share" c ass="twitter-share-button" data- ang="en"
data-size=" arge" data-hashtags="rosettacode">Tweet</a>
<script type="text/rocketscript">!function(d,s,id){var js,fjs=d.getE ementsByTag
Name(s)[0];if(!d.getE ementById(id)){js=d.createE ement(s);js.id=id;js.src="//p
atform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"
script","twitter-wjs");</script>
<script data-rocketsrc="http://www.stumb eupon.com/hostedbadge.php?s=2" type="te
xt/rocketscript"></script>
</div>
</div>





<div c ass="porta " id='p-tb'>
<h5>Too box</h5>
<div c ass="body">

<a href="/wiki/Specia :WhatLink
sHere/24_game/So ve" tit e="A ist of a
wiki pages that ink here [j]" accessk
ey="j">What inks here</a>
<a href="/wiki/Specia :Re
centChangesLinked/24_game/So ve" tit e="Recent changes in pages inked from this
page [k]" accesskey="k">Re ated changes</a>
<a href="/wiki/Specia :Specia Pa
ges" tit e="A ist of a specia pages [q]" accesskey="q">Specia pages</a>
<a href="/mw/index.php?tit e=24_game/So
ve&printab e=yes" re ="a ternate" tit e="Printab e version of this page [p]
" accesskey="p">Printab e version</a>
<a href="/mw/index.php?tit e=24_gam
e/So ve&o did=210398" tit e="Permanent ink to this revision of the page">Pe
rmanent ink</a>
<a href="/wiki/Specia :Browse/24_game-2FSo ve" tit e="S
pecia :Browse/24 game-2FSo ve">Browse properties</a>

</div>
</div>



</div>


<div id="footer">

 This page was ast modified on 26 August 2015, at
18:58.
Content is avai ab e under <a c ass="externa " hr
ef="http://www.gnu.org/ icenses/fd -1.2.htm ">GNU Free Documentation License 1.2
</a>.


<a href="/wiki/Rosetta_Code:Privacy_po icy" tit e
="Rosetta Code:Privacy po icy">Privacy po icy</a>
<a href="/wiki/Rosetta_Code:About" tit e="Rosetta C
ode:About">About Rosetta Code</a>
<a href="/wiki/Rosetta_Code:Genera _disc aimer

" tit e="Rosetta Code:Genera disc aimer">Disc aimers</a>



<a href="http://www.gnu.org/ ice
nses/fd -1.2.htm "><img src="/mw/skins/common/images/gnu-fd .png" a t="GNU Free
Documentation License 1.2" width="88" height="31" /></a>


<a href="//www.mediawiki.org/"><
img src="/mw/skins/common/images/poweredby_mediawiki_88x31.png" a t="Powered by
MediaWiki" width="88" height="31" /></a>
<a href="http://www.semantic-med
iawiki.org/wiki/Semantic_MediaWiki"><img src="/mw/extensions/SemanticMediaWiki/s
kins/images/smw_button.png" a t="Powered by Semantic MediaWiki" width="88" heigh
t="31" /></a>


<div sty e="c ear:both"></div>
</div>

mw. oader.state({"site":" oading","user":"ready","user.groups":"ready"});
}</script>
<script data-rocketsrc="http://rosettacode.org/mw/ oad.php?debug=fa se& ang=
en&modu es=skins.vector&on y=scripts&skin=vector&*" type="text/r
ocketscript"></script>
mw. oader. oad(["mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest
"], nu , true);
}</script>
<script type="text/rocketscript">/* C oudF are ana ytics upgrade */
</script>
<script data-rocketsrc="http://rosettacode.org/mw/ oad.php?debug=fa se& ang=
en&modu es=site&on y=scripts&skin=vector&*" type="text/rocketscr
ipt"></script>

</body>
</htm >

123

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

123

Caricato da

Copyright:

Formati disponibili

<!

m input; see below","sfgBlankErrorStr":"cannot be blank","sfgBadURLErrorStr":"mu

">3</span> <span class="toctext">AutoHotkey</span></a></li>

<li class="toclevel-1 tocsection-31"><a href="#Perl_6"><span class="tocnumber">3

apdocu/en/ABAPCONSTANTS.htm"><span class="kw2">constants</span></a><span class="

/span> <span class="sy0">&amp;</span><span class="nu0">1</span> <span class="kw4

<span class="sy1">=</span> <span class="st0">'/'</span><span class="sy0">.</span

lass="kw3">subtract</span></a> <span class="nu0">1</span> <span class="kw4">from

/> <a href="http://help.sap.com/abapdocu/en/ABAPENDDO.htm"><span class="kw1">en

with the following input: 1

with the following input: 5 6 7 8

<span class="sy0">,</span> <span class="nu0">1</span><span class="br0">&#41;</sp

se<span class="sy0">,</span> s<br/>

ss="kw2">A_Index</span></a><span class="sy0">,</span> pC <span class="sy0">:=</s

<p>And for 8338:

2">#define max_digit 9</span><br/>&#160;<br/><span class="kw4">typedef</span> <s

prec <span class="sy0">&amp;&amp;</span> is_right<span class="br0">&#41;</span>

</span><span class="sy0">,</span> e<span class="sy0">-&gt;</span>op<span class="

<span class="kw1">return</span> <span class="nu0">1

pubs/009695399/functions/srand.html"><span class="kw3">srand</span></a><span cla

36 53 68 12 82 30 8: ((36 + 53 + 68) - 82) / 30 - 12 / 8

quot;&quot;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>

tart working on every permutation of the digits.</span><br/>

&quot; * &quot;</span>, <span class="st0">&quot; * &quot;</span>, <span class="s

class="br0">&#40;</span><span class="st0">&quot;( &quot;</span>, <span class="s

pan class="st0">&quot; - ( &quot;</span>, <span class="st0">&quot; + &quot;</spa

printOperation<span class="br0">&#40;</span><span class="st0">&quot;( &quot;</s

&quot;</span>, <span class="st0">&quot; )&quot;</span><span class="br0">&#41;</

an class="me1">n2</span> <span class="br0">&#40;</span>:<span class="me1">o3</sp

lve_24_game = <span class="br0">&#40;</span>digits...<span class="br0">&#41;</sp

pan><span class="sy0">,</span> arr<span class="br0">&#91;</span>j<span class="br

Solution for 7,1,5,6: (((7 - 1) * 5) - 6)

"br0">&#40;</span>digits <span class="sy0">&amp;</span>optional expr<span class=

/>&#160;<br/><span class="br0">&#40;</span><span class="kw1">defun</span> solve<span class="nu0">24</span>-game <span class="br0">&#40;</span>digits<span class

"br0">&#40;</span>T<span class="br0">&#40;</span>x<span class="sy0">,</span> x.<

="sy0">,</span> <span class="nu0">1</span><span class="sy0">,</span> <span class

br/> END FOR<br/> IF J=0 THEN<br/>

n=cols(v);<br/>$if n==1 and v[1]~=24 then<br/>$ &quot;Solved the problem&quot;,

class="sy0">*</span> y <span class="sy0">/</span> g<br/>

ass="kw1">if</span> y <span class="sy0">=</span> <span class="st0">&quot;&quot;<

0">&#40;</span>print <span class="nu0">2</span> g<span class="br0">&#41;</span><

&#40;</span>insert x<span class="br0">&#41;</span> z<span class="br0">&#41;</spa

il</span> x<span class="br0">&#41;</span><span class="br0">&#41;</span><br/>

r0">&#40;</span><span class="nu0">4</span><span class="br0">&#41;</span>, reals<

#40;</span>op<span class="br0">&#40;</span>op<span class="br0">&#40;</span>p,i,o

<span class="kw3">intent</span><span class="br0">&#40;</span><span class="kw3">o

ot;xxx**x*&quot;, &quot;xxx*x**&quot;, &quot;xxxx***&quot;];<br/>

class="sy1">,</span> <span class="st0">&quot;)&quot;</span><br/>

ative, so swap arguments</span><br/>

<h2><span class="editsection">[<a href="/mw/index.php?title=24_game/Solve&amp;ac

="sy0">++</span> <a href="http://haskell.org/ghc/docs/latest/html/libraries/base

n class="sy0">-&gt;</span> <a href="http://haskell.org/ghc/docs/latest/html/libr

to end.<span class="es0">\n</span><span class="es0">\n</span>&quot;</span><span

uot;</span><span class="sy1">,</span>e<span class="br0">&#41;</span> <span class

4">put</span><span class="br0">&#40;</span>lex<span class="sy1">,</span><span cl

ivalent to the sentence <code>8*(7-(4*1))</code>. [Many infix languages use oper

an> <span class="kw1">new</span> <a href="http://www.google.com/search?hl=en&amp

lass="nu0">3</span> <span class="sy0">*</span> <span class="nu0">2</span><span c

y0">=</span> expr.<span class="me1">pop</span><span class="br0">&#40;</span><spa

<span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="sy0">/

st<span class="sy0">&lt;</span>Integer<span class="sy0">&gt;</span> lst, Set<spa

y0">=</span>NOVAL<span class="sy0">;</span><br/> <span class="kw1">if</span><spa

class="br0">&#41;</span><span class="sy0">,</span>r<span class="sy0">,</span>t<s

span class="sy0">;</span><br/> say<span class="br0">&#40;</span>out<span class="

/span> <span class="sy0">&</span><span class="nu0">1</span> <span class="kw4

<span class="sy0">,</span> <span class="nu0">1</span><span class="br0">)</sp

2">#define max_digit 9</span><br/> <br/><span class="kw4">typedef</span> <s

prec <span class="sy0">&&</span> is_right<span class="br0">)</span>

</span><span class="sy0">,</span> e<span class="sy0">-></span>op<span class="

quot;"</span><span class="br0">)</span> <span class="br0">{</span>

" * "</span>, <span class="st0">" * "</span>, <span class="s

class="br0">(</span><span class="st0">"( "</span>, <span class="s

pan class="st0">" - ( "</span>, <span class="st0">" + "</spa

printOperation<span class="br0">(</span><span class="st0">"( "</s

"</span>, <span class="st0">" )"</span><span class="br0">)</

an class="me1">n2</span> <span class="br0">(</span>:<span class="me1">o3</sp

lve_24_game = <span class="br0">(</span>digits...<span class="br0">)</sp

pan><span class="sy0">,</span> arr<span class="br0">[</span>j<span class="br

"br0">(</span>digits <span class="sy0">&</span>optional expr<span class=

/> <br/><span class="br0">(</span><span class="kw1">defun</span> solve<span class="nu0">24</span>-game <span class="br0">(</span>digits<span class

"br0">(</span>T<span class="br0">(</span>x<span class="sy0">,</span> x.<

n=cols(v);<br/>$if n==1 and v[1]~=24 then<br/>$ "Solved the problem",

ass="kw1">if</span> y <span class="sy0">=</span> <span class="st0">""<

0">(</span>print <span class="nu0">2</span> g<span class="br0">)</span><

(</span>insert x<span class="br0">)</span> z<span class="br0">)</spa

il</span> x<span class="br0">)</span><span class="br0">)</span><br/>

r0">(</span><span class="nu0">4</span><span class="br0">)</span>, reals<

#40;</span>op<span class="br0">(</span>op<span class="br0">(</span>p,i,o

<span class="kw3">intent</span><span class="br0">(</span><span class="kw3">o

ot;xxx**x", "xxxx", "xxxx*"];<br/>

class="sy1">,</span> <span class="st0">")"</span><br/>

<h2><span class="editsection">[<a href="/mw/index.php?title=24_game/Solve&ac

n class="sy0">-></span> <a href="http://haskell.org/ghc/docs/latest/html/libr

to end.<span class="es0">\n</span><span class="es0">\n</span>"</span><span

uot;</span><span class="sy1">,</span>e<span class="br0">)</span> <span class

4">put</span><span class="br0">(</span>lex<span class="sy1">,</span><span cl

ivalent to the sentence <code>8(7-(41))</code>. [Many infix languages use oper

y0">=</span> expr.<span class="me1">pop</span><span class="br0">(</span><spa

<span class="br0">(</span><span class="br0">)</span> <span class="sy0">/

st<span class="sy0"><</span>Integer<span class="sy0">></span> lst, Set<spa

class="br0">)</span><span class="sy0">,</span>r<span class="sy0">,</span>t<s

span class="sy0">;</span><br/> say<span class="br0">(</span>out<span class="

br /> <br /><span class="kw1">print</span> <span class="st0">"If you s

r0">(</span>righten<span class="br0">)</span><span class="br0">)</sp

="br0">]</span><span class="br0">]</span><br /> <br /><span class="

n>iter <span class="br0">(</span><span class="kw1">function</span><br />

span class="sy0">></span> <span class="re0">$idx</span><span class="br0">&#91

n><span class="co5">@_</span> <span class="br0">}</span><span class="re0">@

93;</span><span class="sy4">,</span> S<span class="br0">)</span> <span class

dd<span class="br0">(</span><span class="br0">[</span><a href="http://pa

ass="sy6">=</span> <span class="br0">[</span>N<span class="br0">]</span>

> <span class="sy1">:-</span> between<span class="br0">(</span><span class="

a><span class="br0">)</span><span class="br0">)</span><span class="sy4">

t0">'four random digits >0 as characters'</span><br />

<- expr[ -(ord.perm[i]+1) ]<br />

an><span c ass="br0">)</span><br />

pan>y,_v,<span c ass="nu0">1</span><span c ass="br0">)</span><br />

br0">}</span> <a href="http://sca a- ang.org"><span c ass="kw1">yie d</span

>9</span><span c ass="br0">]</span>\h<span c ass="sy0">*</span>$<span c ass=

"sy0">|</span>d,e,f,g<span c ass="sy0">|</span> <span c ass="br0">(</span>d.

t</span> permutations <span c ass="br0">{</span>a b c d<span c ass="br0">&#

<span c ass="br0">}</span><br />

^|Dr Dr K34SPSL/permutations ~&<br />with_roots = ^Dr Dr K35d PvVoPSPSL\~&

(d.d).d).d", "(d.d).(d.d)", "(d.(d.d)).d", "d.((d.