How would you code a countdown solver?
You have 30 seconds to reach the target number using 6 numbers and the four mathematics operations..
You don't have to use all numbers.
Players can select small numbers (1-10) or larger number (25, 50, 75, 100).
I wrote one when learning C
https://paste.debian.net/1280875/
Why don't you add comments? This is hard to read
>Why don't you add comments?
I'm a hobbyist
>This is hard to read
it tries every possible RPN expression with given numbers and four arithmetic operations and prints the shortest that evaluates to the target number
there is no faster algorithm to solve those questions other than perhaps storing the answer to every possible question and looking up the one asked
God already coded my dick to dick her.
What a dumbass boring show. Is this what british "people" really watch for entertainment?
RAPE DA JOOS !!
I'm too thick to come with my own, but there's an example in Programming in Haskell. (1/2)
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveAnyClass #-}
module Countdown (Result, countdown) where
import Control.DeepSeq (NFData)
import GHC.Generics (Generic)
data Expr' = Val' Int | App Op Expr' Expr' deriving (Generic, NFData)
instance Show Expr' where
show (Val' n) = show n
show (App o l r) = let
brak (Val' x) = show x
brak e = "(" ++ show e ++ ")"
in brak l ++ " " ++ show o ++ " " ++ brak r
instance Num Expr' where
(*) = App Mul
(+) = App Add'
(-) = App Sub
abs = id
signum = const (Val' 1)
fromInteger = Val' . fromIntegral
instance Eq Expr' where
Val' x == Val' y = x == y
(App op l r) == (App op' l' r') = op == op' && l == l' && r == r'
_ == _ = False
-- 6 c)
instance Ord Expr' where
ap <= ap' = depth ap <= depth ap'
where depth :: Expr' -> Int
depth (Val' _) = 0
depth (App _ l r) = 1 + depth l + depth r
data Op = Add' | Sub | Mul | Div deriving (Eq, Generic, NFData)
instance Show Op where
show Add' = "+"
show Sub = "-"
show Div = "/"
show Mul = "*"
valid :: Op -> Int -> Int -> Bool
valid Add' _ _ = True
valid Mul _ _ = True
valid Sub x y = x > y
valid Div x y = x `mod` y == 0
applyOp :: Op -> Int -> Int -> Int
applyOp Add' = (+)
applyOp Sub = (-)
applyOp Mul = (*)
applyOp Div = div
subs :: [a] -> [[a]]
subs [] = [[]]
subs (x:xs) = yss ++ map (x:) yss where yss = subs xs
interleave :: a -> [a] -> [[a]]
interleave x [] = [[x]]
interleave x (y:ys) = (x:y:ys) : map (y:) (interleave x ys)
perms :: [a] -> [[a]]
perms [] = [[]]
perms (x:xs) = concatMap (interleave x) (perms xs)
choices :: [a] -> [[a]]
choices = concatMap perms . subs
(2/2)
splitLists :: [a] -> [([a], [a])]
splitLists [] = []
splitLists [_] = []
splitLists (x:xs) = ([x], xs) : [(x:ls, rs) | (ls,rs) <- splitLists xs]
type Result = (Expr', Int)
results :: [Int] -> [Result]
results [] = []
results [n] = [(Val' n, n) | n > 0]
results ns = [res | (ls, rs) <- splitLists ns,
lx <- results ls,
ry <- results rs,
res <- combine' lx ry]
combine' :: Result -> Result -> [Result]
combine' (l,x) (r,y) = [(App o l r, applyOp o x y) | o <- ops, valid o x y]
where ops = [Add', Sub, Div, Mul]
countdown :: [Int] -> Int -> [Expr']
countdown ns n = [e | ns' <- choices ns, (e,m) <- results ns', m == n]
Maybe I misunderstand the show based on your screenshot, but if it's always 3 digits numbers can't it be solved every time by (hundreds place x 100)+(tens place x 10)+(ones place)?
sirs, good morning. That is a nice tnetennba
alright then, in python:
from itertools import permutations, combinations, product
def countdown_solver(numbers, target):
operations = ['+', '-', '*', '/']
for n in range(1, len(numbers)+1):
for c in combinations(numbers, n):
for p in permutations(c):
for op in product(operations, repeat=n-1):
equation = ''.join([str(p[i])+op[i] for i in range(n-1)] + [str(p[-1])])
try:
if eval(equation) == target:
return equation
except ZeroDivisionError:
pass
return 'No solution found'
numbers = [100, 75, 50, 25, 10, 5]
target = 999
print(countdown_solver(numbers, target))
that's neat
>[50, 9, 2, 1, 10, 5] 727
5 727
50 + 2 = 52
9 + 5 = 14
52 * 14 = 728
728 - 1 = 727
I know, I mean
can't solve it
fails on OP
Pseudo code doesn't have imports (aside from the bare bones stdlibs). The whole point of it is to show the logic of a program.
What do you mean select numbers?
If you can choose any number like that it's trivial.
Surely you have to make do with random numbers like in the screenshot. (100 * (5+2+1) - 10 + 4) = 794
not him but I think he meant each instances of this game have a set of 6 numbers taken from the numbers 1 to 10 and from the numbers 25, 50, 75, 100.
That way it is realistically solvable by an average man, else it would be too hard.
It's slow as shit and inefficient, but it works.
from random import choice as ch
def solveCountdown(result: int, numbers: list) -> str:
symbols = ["+", "-", "*", "/"]
if result in numbers:
return result
for n in range(2, len(numbers)):
count = 0
for _ in range(10000):
eq = ""
for number in range(n - 1):
eq += str(ch(numbers)) + ch(symbols)
eq += str(ch(numbers))
if eval(eq) == result:
return eq
print(solveCountdown(467, [100, 50, 75, 3, 9, 8]))