24 game/Solve: Difference between revisions

{{trans|Nim}}

op[Char(‘+’)] = (x, y) -> x + y

op[Char(‘-’)] = (x, y) -> x - y

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program game24Solvex64.s */

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

lv_number type i,

lt_numbers type table of i.

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

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

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program game24Solver.s */

{{works with|AutoHotkey_L}}

Output is in RPN.

InputBox, NNNN ; user input 4 digits

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

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

PROCsolve24("1234")

PROCsolve24("6789")

Note: This a brute-force approach with time complexity <em>O(6ⁿ.n.(2n-3)!!)</em> and recursion depth <em>n</em>.<br>

typedef struct {int val, op, left, right;} Node;

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

#include <iostream>

#include <ratio>

Redundant expressions are filtered out (based on https://www.4nums.com/theory/) but I'm not sure I caught them all.

{{works with|C sharp|8}}

using System.Collections.Generic;

using static System.Linq.Enumerable;

=={{header|Ceylon}}==

Don't forget to import ceylon.random in your module.ceylon file.

DefaultRandom

}

=={{header|Clojure}}==

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

[clojure.walk :as w]))

=={{header|COBOL}}==

*> This code is dedicated to the public domain

*> This is GNUCobol 2.0

=={{header|CoffeeScript}}==

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

# expression that adds up to 24.

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

(defun digits ()

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

{{trans|Scala}}

std.concurrency, permutations2, arithmetic_rational;

The program takes n numbers - not limited to 4 - builds the all possible legal rpn expressions according to the game rules, and evaluates them. Time saving : 4 5 + is the same as 5 4 + . Do not generate twice. Do not generate expressions like 5 6 * + which are not legal.

;; use task [[RPN_to_infix_conversion#EchoLisp]] to print results

(define (rpn->string rpn)

=={{header|Elixir}}==

{{trans|Ruby}}

@expressions [ ["((", "", ")", "", ")", ""],

["(", "(", "", "", "))", ""],

=={{header|ERRE}}==

ERRE hasn't an "EVAL" function so we must write an evaluation routine; this task is solved via "brute-force".

PROGRAM 24SOLVE

Via brute force.

>function try24 (v) ...

$n=cols(v);

</syntaxhighlight>

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

Solved the problem

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

The basic solution is an adaption of the OCaml program.

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

=={{header|Factor}}==

Factor is well-suited for this task due to its homoiconicity and because it is a reverse-Polish notation evaluator. All we're doing is grouping each permutation of digits with three selections of the possible operators into quotations (blocks of code that can be stored like sequences). Then we <code>call</code> each quotation and print out the ones that equal 24. The <code>recover</code> word is an exception handler that is used to intercept divide-by-zero errors and continue gracefully by removing those quotations from consideration.

prettyprint quotations random sequences sequences.deep ;

IN: rosetta-code.24-game

=={{header|Fortran}}==

use helpers

implicit none

end program solve_24</syntaxhighlight>

contains

=={{header|GAP}}==

check := function(x, y, z)

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

=={{header|Go}}==

import (

=={{header|Gosu}}==

uses java.lang.Integer

uses java.lang.Double

=={{header|Haskell}}==

import Data.Ratio

import Control.Monad

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

===Alternative version===

import Data.List

import Text.PrettyPrint

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

link strings # for csort, deletec, permutes

=={{header|J}}==

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

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

Here is an alternative version that supports multi-digit numbers. It prefers expressions without parens, but searches for ones with if needed.

perms=: [: ":"0 [: ~. i.@!@# A. ]

build=: 1 : '(#~ 24 = ".) @: u'

Note that this version does not extend to different digit ranges.

public class Game24Player {

=={{header|JavaScript}}==

This is a translation of the C code.

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

'''Infrastructure:'''

def permutations:

if length == 0 then []

end;</syntaxhighlight>

'''Evaluation and pretty-printing of allowed expressions'''

def eval:

if type == "array" then

'''24 Game''':

# Input: an array of 4 digits

solve(24), "Please try again."</syntaxhighlight>

{{out}}

[1,2,3,4]

That was too easy. I found 242 answers, e.g. [4 * [1 + [2 + 3]]]

For julia version 0.5 and higher, the Combinatorics package must be installed and imported (`using Combinatorics`). Combinatorial functions like `nthperm` have been moved from Base to that package and are not available by default anymore.

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

syms = [+,-,*,/]

=={{header|Kotlin}}==

{{trans|C}}

import java.util.Random

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

input "Enter 4 digits: "; a$

nD=0

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

local SIZE = #arg[1]

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

=={{header|Mathematica}} / {{header|Wolfram Language}}==

The code:

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

treeR[1] := n

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

{{out}}

An alternative solution operates on Mathematica expressions directly without using any inert intermediate form for the expression tree, but by using <code>Hold</code> to prevent Mathematica from evaluating the expression tree.

evaluate[x_] := x;

combine[l_, r_ /; evaluate[r] != 0] := {HoldForm[Plus[l, r]],

{{works with|Nim Compiler|0.19.4}}

type

=={{header|OCaml}}==

| Const of float

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

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

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

sub permute (&@) {

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">-- demo\rosetta\24_game_solve.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

=={{header|Picat}}==

foreach (_ in 1..10)

Nums = [D : _ in 1..4, D = random() mod 9 + 1],

{{trans|Raku}}

main =>

Another approach:

main =>

=={{header|PicoLisp}}==

We use Pilog (PicoLisp Prolog) to solve this task

(permute @Lst (@A @B @C @D))

(member @Op1 (+ - * /))

Note

This example uses the math module:

:a

editvar /newvar /withothervar /value=-random- /title=1

rdiv/2 is use instead of //2 to enable the program to solve difficult cases as [3 3 8 8].

game(Len, Range, Goal, L, S),

maplist(my_write, L),

{{Works with|GNU Prolog|1.4.4}}

Little efforts to remove duplicates (e.g. output for [4,6,9,9]).

solve(N,Xs,Ast) :-

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 the Python command line.

The 24 Game Player

==={{header|Python}} Succinct===

Based on the Julia example above.

import operator

from itertools import product, permutations

==={{header|Python}} Recursive ===

This works for any amount of numbers by recursively picking two and merging them using all available operands until there is only one value left.

# Python 3

from operator import mul, sub, add

===Python: using tkinter===

''' Python 3.6.5 code using Tkinter graphical user interface.

Combination of '24 game' and '24 game/Solve'

<code>permutations</code> is defined at [[Permutations#Quackery]] and <code>uniquewith</code> is defined at [[Remove duplicate elements#Quackery]].

permutations ] constant is numorders ( --> [ )

=={{header|R}}==

This uses exhaustive search and makes use of R's ability to work with expressions as data. It is in principle general for any set of operands and binary operators.

library(gtools)

</syntaxhighlight>

{{out}}

> solve24()

8 * (4 - 2 + 1)

=={{header|Racket}}==

The sequence of all possible variants of expressions with given numbers ''n1, n2, n3, n4'' and operations ''o1, o2, o3''.

(define (in-variants n1 o1 n2 o2 n3 o3 n4)

(let ([o1n (object-name o1)]

Search for all solutions using brute force:

(define (find-solutions numbers (goal 24))

(define in-operations (list + - * /))

Since Raku uses Rational numbers for division (whenever possible) there is no loss of precision as is common with floating point division. So a comparison like (1 + 7) / (1 / 3) == 24 "Just Works"^&trade;

my @digits;

Alternately, a version that doesn't use EVAL. More general case. Able to handle 3 or 4 integers, able to select the goal value.

sub MAIN (*@parameters, Int :$goal = 24) {

=={{header|REXX}}==

/* start-of-help

┌───────────────────────────────────────────────────────────────────────┐

{{trans|Tcl}}

{{works with|Ruby|2.1}}

EXPRESSIONS = [

'((%dr %s %dr) %s %dr) %s %dr',

=={{header|Rust}}==

{{works with|Rust|1.17}}

enum Operator {

Sub,

A non-interactive player.

case Nil => List(Nil)

case x :: xs =>

This version outputs an S-expression that will '''eval''' to 24 (rather than converting to infix notation).

#!r6rs

Example output:

> (solve 1 3 5 7)

((* (+ 1 5) (- 7 3))

'''With eval():'''

'((%d %s %d) %s %d) %s %d',

'(%d %s (%d %s %d)) %s %d',

'''Without eval():'''

{|a,b,c|

Hash(

=={{header|Simula}}==

=={{header|Swift}}==

import Darwin

import Foundation

This is a complete Tcl script, intended to be invoked from the command line.

{{tcllib|struct::list}}

# Encoding the various expression trees that are possible

set patterns {

non-terminal nodes of a tree in every possible way. The <code>value</code> function evaluates a tree and the

<code>format</code> function displays it in a readable form.

#import nat

#import rat

game"n" "d" = format* value==("n",1)*~ with_roots/'+-*/' with_leaves/"d"*-1 tree_shapes length "d"</syntaxhighlight>

test program:

test_games = mat` * pad` *K7 pad0 game24* <<2,3,8,9>,<5,7,4,1>,<5,6,7,8>></syntaxhighlight>

{{trans|Kotlin}}

{{libheader|Wren-dynamic}}

import "/dynamic" for Tuple, Enum, Struct

=={{header|Yabasic}}==

space$ = " "

File solve24.zkl:

fcn u(xs){ xs.reduce(fcn(us,s){us.holds(s) and us or us.append(s) },L()) }

var ops=u(H.combosK(3,"+-*/".split("")).apply(H.permute).flatten());

{ f2s(digits4,ops3,f) }]];

}</syntaxhighlight>

println(solutions.len()," solutions:");

solutions.apply2(Console.println);</syntaxhighlight>

...

</pre>

{{omit from|GUISS}}

{{omit from|ML/I}}