Talk:24 game

Purpose

What's the theoretical or practical interest in this task? I'd be interested in a program that enumerated all the 4-tuples that have solutions or determined whether a given 4-tuple had a solution, but we've already got tasks for getting input from the user, parsing arithmetic expressions, and so on. —Underscore 19:22, 31 October 2009 (UTC)

Umm,

1. Playing the game.
2. We have a gazillion sorts for example, (some are very impractical); so we can stand some repetition.
3. We don't have many games, (of any description). Some site grazers might be attracted just by the word 'game'.
4. The input checking is novel.
5. The task is more than the some of its parts! (We have tasks covering most statement types, and it would not make sense to use that as a reason for not doing any composite task).
6. Prelude to possibly another task to solve the game.

(I don't like to write a task until I have a solution and so can better gauge its suitability, and so write a better task description). --Paddy3118 20:57, 31 October 2009 (UTC)

Without any official guidelines as to what's an appropriate Rosetta task and what isn't, I suppose it's all completely subjective, so I can't very well argue with you. Adding more games isn't such a bad idea; RCRPG is interesting from an implementation point of view but sorely lacking in the fun department. I wonder how hard it is to write a minimal Pong clone. —Underscore 22:24, 31 October 2009 (UTC)

Very easy, with modern hardware and programming languages.

FWIW, this task does strike me as being a somewhat useful one. I used to have a similar time waster game when I was a teen where you got 4 numbers and a goal, the end. (Except for the variable goal, identical to this task.) -- Eriksiers 02:23, 1 November 2009 (UTC)

Since there really is no body of multiple individuals to give any sort of official policy, any concept of "official" falls to whatever I say by fiat. Which sucks, because I'm nowhere near as knowledgeable on programming as many of RC's contributors are, regular or not. All I really know is that I have a good mental picture of the kinds of roles I want to the site to fill. Beyond that, I don't pretend to have expertise; Many of my early ideas and attempts at trying to come up with task descriptions were too specific, enforcing my own limited view of programming on the examples, so I've learned to stand back. I step in from time to time if I see discussion heading in a direction counter to where I'd like the site to go, but that's about it.

As for "redundant" tasks, it doesn't bother me. In fact, I can think of ways to take advantage of it, such as category tagging individual examples with techniques, features or principles they may illustrate, to offer another way to browse and search the site, and to be more illustrative of alternate approaches. --Michael Mol 17:12, 1 November 2009 (UTC)

Methinks you're turning into a Python-esque BDFL ;-)

--Paddy3118 18:49, 1 November 2009 (UTC)

It's also practical; I've got one paid 50hr/wk job coding, one 30+hr/wk job taking care of an elderly family member, and one 50hr/wk job sleeping. Not much time left to micromanage RC, as well as have any [other] hobbies. :) --Michael Mol 23:13, 1 November 2009 (UTC)

A game player was not too difficult so I created it as a separate (but linked), task. --Paddy3118 04:52, 1 November 2009 (UTC)

Autohotkey and Untested

Does untested mean that it has not been shown to run? If so, could we restrict ourselves to examples that have at least been run? (Or do you mean: "insufficiently tested but has at least been run")? --Paddy3118 05:37, 11 November 2009 (UTC)

I also agree (that the program should at least run (execute).   There have been entries that do not work at all for the computer programming language (category) entry that it was entered for.   It's a whole 'nother can of worms.   -- Gerard Schildberger (talk) 01:56, 10 May 2016 (UTC)

Floating point

Is recommending floating point wise? Precision and rounding errors would seem to defeat the purpose of preserving remainders. --Michael Mol 03:58, 8 December 2009 (UTC)

It isn't rigorous, (I'm an engineer, not a theoretical mathematician captain), but with the restricted range of single digit numbers, the given operators, and the precision of most FP implementations on a PC; I don't think it will matter. --Paddy3118 07:12, 8 December 2009 (UTC)

Certainly rationals are a better choice than floating point for this type of task, but I think you should be able to use floating point safely so long as you say something like if abs(ans - 24) < 1e-6 instead of if ans == 24. It's considered good practice, in general, to never test a floating-point variable for exact equality. That said, I'm at a loss for an input that the Python program would wrongly reject, so maybe floating point is better than I think it is. —Underscore (Talk) 12:49, 8 December 2009 (UTC)

If someone can exhibit a solution that a floating-point version won't find, that's when action becomes necessary. However, when I try out likely problems then I find I still cannot trigger any issues. For example:

<lang tcl>$ tclsh8.5

% expr {(((1.0/3.0)*9.0)*8.0) - 24.0} 0.0</lang>Despite a definitely non-representable intermediate (I know the implementation) the answer is exact. I just can't trigger the problem for anything that might be a solution. (Non-solutions… who cares about them?) Rationals might be theoretically better, but IEEE double seems good enough here. –Donal Fellows 13:32, 8 December 2009 (UTC)

You mentioned in Talk:24_game_Player#Should_we_enumerate_all_solutions.3F that it was practicable to identify all 7,860 solutions. That sounds like a pretty small test set. (Or am I misunderstanding your description of the enumeration?) --Michael Mol 18:49, 8 December 2009 (UTC)

Hi Donal, you might try 3 3 8 8 in the TCL example. Floating point won't work for this in Python. --Paddy3118 14:18, 15 February 2011 (UTC)

3 3 8 8 has different values depending on the Tcl versions it seems <lang>:> /opt/tcltk_8.0.3/bin/tclsh8.0

% expr 8.0 / ( 3.0 - 8.0 / 3.0 ) 24.0 %

> /opt/tcltk_8.3.4/bin/tclsh

% expr 8.0 / ( 3.0 - 8.0 / 3.0 ) 24.0 %

> /opt/tcltk_8.4.13/bin/tclsh

% expr 8.0 / ( 3.0 - 8.0 / 3.0 ) 24.0 %

> /opt/TWWfsw/bin/tclsh8.5

% expr 8.0 / ( 3.0 - 8.0 / 3.0 ) 23.99999999999999 %</lang> --Paddy3118 14:34, 15 February 2011 (UTC)

One potential problem with floating point, when you get to more than 4 digits, is that in some languages (not Python), division by 0.0 evaluates to infinity (which can be divided by again to get 0), instead of raising an error, so for example, this in Ruby: 3.0 * (8.0 + 4.0 / (2.0 / (5.0 - 5.0))) results in 24.0, which you might not want to allow. But I agree that this is not an issue with only 4 digits. --Spoon! 14:16, 8 December 2009 (UTC)

Precisely. That's why it matters that it is a “24-game player”. A solution with computation using rationals would be interesting though. –Donal Fellows 14:57, 8 December 2009 (UTC)

Does the Perl code work?

I have tryed to run the Perl code, and it seems that it doesn't recognise when the correct answer is given. --Blue Prawn 00:42, 26 January 2010 (UTC)

Scala only presenting numbers with solutions

I note that the impressive Scala example seems to only present a set of numbers guaranteed to have a solution. i can't help but think that from playing the game, some of the fun is lost, as we quite enjoyed trying the toughies - not knowing if they actually had a solution or not as most numbers do. I guess they don't have to add much for a solution to 24 game Player. --Paddy3118 06:43, 28 April 2010 (UTC)

I couldn't quite understand fully the meaning of the penultimate statement as it appears it may be missing an Oxford comma.   Most numbers don't have a solution.   (See the next talk section).   -- Gerard Schildberger (talk) 08:04, 15 March 2017 (UTC)

REXX only presenting digits with at least one solution

I have programmed the REXX example to also only present a set of digits that have a solution   (as does Scala).

From the task preamble:

The goal is for the player to enter an expression that (numerically) evaluates to 24. 

Nowhere does it imply that an impossible set of digits is to be determined and, somehow, the user is supposed to   not   enter a solution;   as it is, no computer programming entry checks for a   not possible   answer for a solution.

When presented with the digits     1 7 6 8,     what should a carbon-based life form (user) respond with for an answer (which is a non-solution)?

No such animal?
N/A
there ain't one
not possible
nope.
I give up.
I don't know
Please tell me the answer!!!
bupkis

Some of the solvable digits (numbers) are hard enough to find a solution, and presenting an unsolvable problem doesn't seem to be fair or realistic, since this is a game, not a riddle, and the game is to find a solution, not   "none-solutions".

unsolvable solutions for the 24 game

Of the   6,561   legal/valid numbers (with four digits) that can be presented   (numbers without any zeroes),   2,501   1,263   are   unsolvable   (that represents about   38%   19%   unsolvable).   This presumes that the REXX program correctly solved all possible (allowable) numbers.

(I have a complete list of the 1,501 unsolvable numbers for the 24 game.)   -- Gerard Schildberger (talk) 08:04, 15 March 2017 (UTC)
I found an error in the way the output file was massaged and created a list from the post-edited output file.

I have an updated complete list of the 1,263 unsolvable numbers for the 24 game.     -- Gerard Schildberger (talk) 00:27, 5 January 2019 (UTC)

Here are the formatted (indexed) unsolvable numbers (the order of the digits are preserved) for the 24 game:

(I'm in the process of re-running the list)

I'd be interested if anyone would verify that all the numbers above are unsolvable for the 24 game.     -- Gerard Schildberger (talk) 23:31, 3 January 2019 (UTC)

Edited: I accidentally listed the groups with only one solution as unsolvable. Fixed now.

Um. You may want to re-read the task rules, specifically the one stating "The order of the digits when given does not have to be preserved."

I don't need to re-read the task rules, I programmed the REXX program which does NOT preserve the order of digits when presenting solutions, but it does honor the original number being processed and shows (all) the solutions for that number, for any order of its digits.   The task's requirement said that it   does not not have to be preserved,   it didn't say   should not be preserved.   I choose to preserve the order of digits for the REXX entry.     -- Gerard Schildberger (talk) 00:27, 5 January 2019 (UTC)

That being the case, there are only 495 unique combinations of 4 non-zero digits. This is ALL of them.

   Unsolvable:
   1111 1112 1113 1114 1115 1116 1117 1119 1122 1123 1124 1125 1133 1159 1167 1177
   1178 1179 1189 1199 1222 1223 1299 1355 1499 1557 1558 1577 1667 1677 1678 1777
   1778 1899 1999 2222 2226 2279 2299 2334 2555 2556 2599 2677 2777 2779 2799 2999
   3358 3467 3488 3555 3577 4459 4466 4467 4499 4779 4999 5557 5558 5569 5579 5777
   5778 5799 5899 5999 6667 6677 6678 6699 6777 6778 6779 6788 6999 7777 7778 7779
   7788 7789 7799 7888 7899 7999 8888 8889 8899 8999 9999

   Solvable:
   1118 1126 1127 1128 1129 1134 1135 1136 1137 1138 1139 1144 1145 1146 1147 1148
   1149 1155 1156 1157 1158 1166 1168 1169 1188 1224 1225 1226 1227 1228 1229 1233
   1234 1235 1236 1237 1238 1239 1244 1245 1246 1247 1248 1249 1255 1256 1257 1258
   1259 1266 1267 1268 1269 1277 1278 1279 1288 1289 1333 1334 1335 1336 1337 1338
   1339 1344 1345 1346 1347 1348 1349 1356 1357 1358 1359 1366 1367 1368 1369 1377
   1378 1379 1388 1389 1399 1444 1445 1446 1447 1448 1449 1455 1456 1457 1458 1459
   1466 1467 1468 1469 1477 1478 1479 1488 1489 1555 1556 1559 1566 1567 1568 1569
   1578 1579 1588 1589 1599 1666 1668 1669 1679 1688 1689 1699 1779 1788 1789 1799
   1888 1889 2223 2224 2225 2227 2228 2229 2233 2234 2235 2236 2237 2238 2239 2244
   2245 2246 2247 2248 2249 2255 2256 2257 2258 2259 2266 2267 2268 2269 2277 2278
   2288 2289 2333 2335 2336 2337 2338 2339 2344 2345 2346 2347 2348 2349 2355 2356
   2357 2358 2359 2366 2367 2368 2369 2377 2378 2379 2388 2389 2399 2444 2445 2446
   2447 2448 2449 2455 2456 2457 2458 2459 2466 2467 2468 2469 2477 2478 2479 2488
   2489 2499 2557 2558 2559 2566 2567 2568 2569 2577 2578 2579 2588 2589 2666 2667
   2668 2669 2678 2679 2688 2689 2699 2778 2788 2789 2888 2889 2899 3333 3334 3335
   3336 3337 3338 3339 3344 3345 3346 3347 3348 3349 3355 3356 3357 3359 3366 3367
   3368 3369 3377 3378 3379 3388 3389 3399 3444 3445 3446 3447 3448 3449 3455 3456
   3457 3458 3459 3466 3468 3469 3477 3478 3479 3489 3499 3556 3557 3558 3559 3566
   3567 3568 3569 3578 3579 3588 3589 3599 3666 3667 3668 3669 3677 3678 3679 3688
   3689 3699 3777 3778 3779 3788 3789 3799 3888 3889 3899 3999 4444 4445 4446 4447
   4448 4449 4455 4456 4457 4458 4468 4469 4477 4478 4479 4488 4489 4555 4556 4557
   4558 4559 4566 4567 4568 4569 4577 4578 4579 4588 4589 4599 4666 4667 4668 4669
   4677 4678 4679 4688 4689 4699 4777 4778 4788 4789 4799 4888 4889 4899 5555 5556
   5559 5566 5567 5568 5577 5578 5588 5589 5599 5666 5667 5668 5669 5677 5678 5679
   5688 5689 5699 5779 5788 5789 5888 5889 6666 6668 6669 6679 6688 6689 6789 6799
   6888 6889 6899 7889

   Solvable but only one solution:
   1277 1346 1668 3355 3388 5555 5588 5599

But even putting that aside, with a quick peek at your "unsolvable" list, I pick out 1164 (1*1*6*4), 1183 (1*1*8*3), 2232 (2*2*3*2) and many other that don't require digit reordering. I think you need to revisit your filtering algorithm. --Thundergnat (talk) 02:22, 4 January 2019 (UTC)

It wasn't the filtering that caused the error, but my post-editing process.   The REXX program did, in fact, find solutions for   1164   (and it's variants).     -- Gerard Schildberger (talk) 00:27, 5 January 2019 (UTC)