如何优化穷举法算出的24点结果?

gust 2001-10-25 12:57:59
结果实在多了,
例如输入数据 1,2,3,4
1 ((1+2)+3)*4
2 (1+(2+3))*4
3 ((1*2)*3)*4
4 (1*(2*3))*4
5 (1*2)*(3*4)
6 1*((2*3)*4)
7 1*(2*(3*4))
8 ((1*2)*4)*3
9 (1*(2*4))*3
. .
. .
. .
有两百多个结果

第一:如何判断两个运算表达式完全相同以便略去;化为逆波兰式吗?
第二:按通常运算24点思维,又如何判断两表达式相同,可归纳出那些规则?
...全文
19753 19 打赏 收藏 转发到动态 举报
写回复
用AI写文章
19 条回复
切换为时间正序
请发表友善的回复…
发表回复
mathe 2001-10-30
  • 打赏
  • 举报
回复
I have written a code.

#include <stdio.h>
#define RESULT 24

//Total count:2036
const short T1[]={
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 187, 188, 189, 190, 191, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 252, 253, 254, 255, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 316, 317, 318, 319, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 380, 381, 382, 383, 385, 387, 389, 391, 393, 395, 397, 399, 401, 403, 405, 407, 409, 411, 413, 415, 417, 419, 421, 423, 425, 427, 429, 431, 433, 435, 437, 439, 441, 443,
445, 447, 465, 467, 469, 471, 473, 475, 477, 479, 497, 499, 501, 503, 505, 507, 509, 511, 516, 517, 518, 519, 524, 525, 526, 527, 532, 533, 534, 535, 540, 541, 542, 543, 548, 549, 550, 551, 556, 557, 558, 559, 564, 565, 566, 567, 572, 573, 574, 575, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 636, 637, 638, 639, 644, 645, 646, 647, 652, 653, 654, 655, 660, 661, 662, 663, 668, 669, 670, 671, 676, 677, 678, 679, 684, 685, 686, 687, 692, 693, 694, 695, 700, 701, 702, 703, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 764, 765, 766, 767, 773, 775, 781, 783, 789, 791, 797, 799, 805, 807, 813, 815, 821, 823, 829, 831, 849, 851, 853, 855, 857, 859, 861, 863, 881, 883, 885, 887, 889, 891, 893, 895, 901, 903, 909, 911, 917, 919, 925, 927, 933, 935, 941, 943, 949, 951, 957, 959, 979, 981, 983, 985, 987, 989, 991, 1009, 1011, 1013, 1015, 1017, 1021, 1023, 1028, 1029, 1030, 1031, 1036, 1037, 1038, 1039, 1044, 1045, 1046, 1047, 1052, 1053, 1054, 1055, 1060, 1061, 1062, 1063, 1068, 1069, 1070, 1071, 1076, 1077, 1078, 1079, 1084, 1085, 1086, 1087, 1108, 1109, 1110, 1111, 1116, 1117, 1118, 1119, 1140, 1141, 1142, 1143, 1148, 1149, 1150, 1151, 1157, 1159, 1165, 1167, 1173, 1175, 1181, 1183
, 1189, 1191, 1197, 1199, 1205, 1207, 1213, 1215, 1237, 1239, 1245, 1247, 1269, 1271, 1277, 1279, 1285, 1287, 1293, 1295, 1301, 1303, 1309, 1311, 1317, 1319, 1325, 1327, 1333, 1335, 1341, 1343, 1365, 1367, 1373, 1375, 1397, 1399, 1405, 1407, 1413, 1415, 1421, 1423, 1429, 1431, 1437, 1439, 1445, 1447, 1453, 1455, 1461, 1463, 1469, 1471, 1493, 1495, 1501, 1503, 1525, 1527, 1533, 1535, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1596, 1597, 1599, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1672, 1673, 1676, 1677, 1686, 1687, 1688, 1689, 1692, 1693, 1698, 1699, 1702, 1703, 1714, 1715, 1718, 1719, 1724, 1725, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1800, 1801, 1804, 1805, 1814, 1815, 1816, 1817, 1820, 1821, 1826, 1827, 1830, 1831, 1842, 1843, 1846, 1847, 1852, 1853, 1864, 1865, 1868, 1869, 1880, 1881, 1884, 1885, 1890, 1891, 1894, 1895, 1906, 1907, 1910, 1911, 1929, 1931, 1933, 1935, 1941, 1943, 1945, 1947, 1949, 1951, 1953, 1955, 1957, 1959, 1969, 1971, 1973, 1975, 1981, 1983, 1993, 1995, 1997, 1999, 2009, 2011, 2013, 2015, 2017, 2019, 2021, 2023, 2033, 2035
, 2037, 2039, 2056, 2057, 2060, 2061, 2070, 2071, 2072, 2073, 2076, 2077, 2082, 2083, 2086, 2087, 2098, 2099, 2102, 2103, 2108, 2109, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2184, 2185, 2188, 2189, 2198, 2199, 2200, 2201, 2204, 2205, 2210, 2211, 2214, 2215, 2226, 2227, 2230, 2231, 2236, 2237, 2248, 2249, 2252, 2253, 2264, 2265, 2268, 2269, 2274, 2275, 2278, 2279, 2290, 2291, 2294, 2295, 2313, 2317, 2319, 2325, 2327, 2329, 2333, 2335, 2339, 2341, 2343, 2355, 2357, 2359, 2365, 2367, 2377, 2379, 2381, 2383, 2393, 2395, 2397, 2399, 2401, 2403, 2405, 2407, 2417, 2419, 2421, 2423, 2441, 2445, 2455, 2457, 2461, 2467, 2471, 2483, 2487, 2493, 2505, 2507, 2509, 2511, 2521, 2523, 2525, 2527, 2529, 2531, 2533, 2535, 2545, 2547, 2549, 2551, 2568, 2569, 2572, 2573, 2582, 2583, 2584, 2585, 2588, 2589, 2594, 2595, 2598, 2599, 2610, 2611, 2614, 2615, 2620, 2621, 2632, 2633, 2636, 2637, 2648, 2649, 2652, 2653, 2658, 2659, 2662, 2663, 2674, 2675, 2678, 2679, 2697, 2701, 2703, 2709, 2711, 2713, 2717, 2719, 2723, 2725, 2727, 2739, 2741, 2743, 2749, 2751, 2761, 2765, 2767, 2777, 2781, 2783, 2787, 2789, 2791, 2803, 2805, 2807, 2825, 2829, 2839, 2841, 2845, 2851, 2855, 2867, 2871, 2877, 2889, 2893, 2895, 2905, 2909, 2911, 2915, 2917, 2919, 2931, 2933, 2935, 2953, 2957, 2967, 2969, 2973, 2979, 2983, 2995, 2999, 3005, 3017, 3021, 3033, 3037, 3043, 3047, 3059, 3063, 3075, 3079, 3083, 3087
, 3091, 3095, 3099, 3103, 3105, 3109, 3113, 3117, 3121, 3125, 3129, 3133, 3139, 3143, 3147, 3151, 3155, 3159, 3163, 3167, 3169, 3173, 3177, 3181, 3185, 3189, 3193, 3197, 3207, 3215, 3223, 3231, 3237, 3245, 3253, 3261, 3267, 3271, 3275, 3279, 3283, 3287, 3291, 3295, 3297, 3301, 3305, 3309, 3313, 3317, 3321, 3325, 3335, 3343, 3351, 3359, 3365, 3373, 3381, 3389, 3399, 3407, 3415, 3423, 3429, 3437, 3445, 3453, 3459, 3463, 3467, 3471, 3475, 3479, 3483, 3487, 3489, 3493, 3497, 3501, 3505, 3509, 3513, 3517, 3523, 3527, 3531, 3535, 3539, 3543, 3547, 3551, 3553, 3557, 3561, 3565, 3569, 3573, 3577, 3581, 3591, 3599, 3607, 3615, 3621, 3629, 3637, 3645, 3651, 3655, 3659, 3663, 3667, 3671, 3675, 3679, 3681, 3685, 3689, 3693, 3697, 3701, 3705, 3709, 3719, 3727, 3735, 3743, 3749, 3757, 3765, 3773, 3783, 3791, 3799, 3807, 3813, 3821, 3829, 3837, 3843, 3847, 3851, 3855, 3859, 3863, 3867, 3871, 3873, 3877, 3881, 3885, 3889, 3893, 3897, 3901, 3907, 3911, 3915, 3919, 3923, 3927, 3931, 3935, 3937, 3941, 3945, 3949, 3953, 3957, 3961, 3965, 3975, 3983, 3991, 3999, 4005, 4013, 4021, 4029, 4035, 4039, 4043, 4047, 4051, 4055, 4059, 4063, 4065, 4069, 4073, 4077, 4081, 4085, 4089, 4093, 4103, 4111, 4119, 4127, 4133, 4141, 4149, 4157, 4167, 4175, 4183, 4191, 4197, 4205, 4213, 4221, 4227, 4231, 4235, 4239, 4243, 4247, 4251, 4255, 4257, 4261, 4265, 4269, 4273, 4277, 4281, 4285, 4291, 4295, 4299, 4303, 4307, 4311, 4315, 4319, 4321, 4325, 4329, 4333, 4337, 4341, 4345, 4349, 4359, 4367, 4375, 4383, 4389, 4397, 4405, 4413, 4419, 4423, 4427, 4431
, 4435, 4439, 4443, 4447, 4449, 4453, 4457, 4461, 4465, 4469, 4473, 4477, 4487, 4495, 4503, 4511, 4517, 4525, 4533, 4541, 4551, 4559, 4567, 4575, 4581, 4589, 4597, 4605, 4609, 4611, 4613, 4615, 4617, 4619, 4621, 4623, 4625, 4627, 4629, 4631, 4633, 4635, 4637, 4639, 4641, 4643, 4645, 4647, 4649, 4651, 4653, 4655, 4657, 4659, 4661, 4663, 4665, 4667, 4669, 4671, 4681, 4683, 4685, 4687, 4697, 4699, 4701, 4703, 4705, 4707, 4709, 4711, 4721, 4723, 4725, 4727, 4741, 4743, 4749, 4751, 4757, 4759, 4765, 4767, 4773, 4775, 4781, 4783, 4789, 4791, 4797, 4799, 4809, 4811, 4813, 4815, 4825, 4827, 4829, 4831, 4833, 4835, 4837, 4839, 4849, 4851, 4853, 4855, 4877, 4879, 4885, 4887, 4893, 4895, 4901, 4903, 4917, 4919, 4925, 4927, 4941, 4943, 4957, 4959, 4965, 4967, 4981, 4983, 4993, 4995, 4997, 4999, 5001, 5003, 5005, 5007, 5009, 5011, 5013, 5015, 5017, 5019, 5021, 5023, 5025, 5027, 5029, 5031, 5033, 5035, 5037, 5039, 5041, 5043, 5045, 5047, 5049, 5051, 5053, 5055, 5065, 5067, 5069, 5071, 5081, 5083, 5085, 5087, 5089, 5091, 5093, 5095, 5105, 5107, 5109, 5111, 5125, 5127, 5133, 5135, 5141, 5143, 5149, 5151, 5157, 5159, 5165, 5167, 5173, 5175, 5181, 5183, 5193, 5195, 5197, 5199, 5209, 5211, 5213, 5215, 5217, 5219, 5221, 5223, 5233, 5235, 5237, 5239, 5261, 5263, 5269, 5271, 5277, 5279, 5285, 5287, 5301, 5303, 5309, 5311, 5325, 5327, 5341, 5343, 5349, 5351, 5365, 5367, 5377, 5379, 5381, 5383, 5385, 5387, 5389, 5391, 5393, 5395, 5397, 5399, 5401, 5403, 5405, 5407, 5409, 5411, 5413, 5415, 5417, 5419, 5421, 5423, 5425, 5427, 5429, 5431
, 5433, 5435, 5437, 5439, 5449, 5451, 5453, 5455, 5465, 5467, 5469, 5471, 5473, 5475, 5477, 5479, 5489, 5491, 5493, 5495, 5509, 5511, 5517, 5519, 5525, 5527, 5533, 5535, 5541, 5543, 5549, 5551, 5557, 5559, 5565, 5567, 5577, 5579, 5581, 5583, 5593, 5595, 5597, 5599, 5601, 5603, 5605, 5607, 5617, 5619, 5621, 5623, 5645, 5647, 5653, 5655, 5661, 5663, 5669, 5671, 5685, 5687, 5693, 5695, 5709, 5711, 5725, 5727, 5733, 5735, 5749, 5751, 5761, 5763, 5765, 5767, 5769, 5771, 5773, 5775, 5777, 5779, 5781, 5783, 5785, 5787, 5789, 5791, 5793, 5795, 5797, 5799, 5801, 5803, 5805, 5807, 5809, 5811, 5813, 5815, 5817, 5819, 5821, 5823, 5833, 5835, 5837, 5839, 5849, 5851, 5853, 5855, 5857, 5859, 5861, 5863, 5873, 5875, 5877, 5879, 5893, 5895, 5901, 5903, 5909, 5911, 5917, 5919, 5925, 5927, 5933, 5935, 5941, 5943, 5949, 5951, 5961, 5963, 5965, 5967, 5977, 5979, 5981, 5983, 5985, 5987, 5989, 5991, 6001, 6003, 6005, 6007, 6029, 6031, 6037, 6039, 6045, 6047, 6053, 6055, 6069, 6071, 6077, 6079, 6093, 6095, 6109, 6111, 6117, 6119, 6133, 6135, 6149, 6151, 6157, 6159, 6165, 6167, 6173, 6175, 6181, 6183, 6189, 6191, 6197, 6199, 6205, 6207, 6229, 6231, 6237, 6239, 6261, 6263, 6269, 6271, 6277, 6279, 6285, 6287, 6293, 6295, 6301, 6303, 6309, 6311, 6317, 6319, 6325, 6327, 6333, 6335, 6357, 6359, 6365, 6367, 6389, 6391, 6397, 6399, 6405, 6407, 6413, 6415, 6421, 6423, 6429, 6431, 6437, 6439, 6445, 6447, 6453, 6455, 6461, 6463, 6485, 6487, 6493, 6495, 6517, 6519, 6525, 6527, 6533, 6535, 6541, 6543, 6549, 6551, 6557, 6559, 6565, 6567, 6573, 6575
, 6581, 6583, 6589, 6591, 6613, 6615, 6621, 6623, 6645, 6647, 6653, 6655, 6661, 6663, 6669, 6671, 6677, 6679, 6685, 6687, 6693, 6695, 6701, 6703, 6709, 6711, 6717, 6719, 6741, 6743, 6749, 6751, 6773, 6775, 6781, 6783, 6789, 6791, 6797, 6799, 6805, 6807, 6813, 6815, 6821, 6823, 6829, 6831, 6837, 6839, 6845, 6847, 6869, 6871, 6877, 6879, 6901, 6903, 6909, 6911, 6917, 6919, 6925, 6927, 6933, 6935, 6941, 6943, 6949, 6951, 6957, 6959, 6965, 6967, 6973, 6975, 6997, 6999, 7005, 7007, 7029, 7031, 7037, 7039, 7045, 7047, 7053, 7055, 7061, 7063, 7069, 7071, 7077, 7079, 7085, 7087, 7093, 7095, 7101, 7103, 7125, 7127, 7133, 7135, 7157, 7159, 7165, 7167, 7173, 7175, 7181, 7183, 7189, 7191, 7197, 7199, 7205, 7207, 7213, 7215, 7221, 7223, 7229, 7231, 7253, 7255, 7261, 7263, 7285, 7287, 7293, 7295, 7301, 7303, 7309, 7311, 7317, 7319, 7325, 7327, 7333, 7335, 7341, 7343, 7349, 7351, 7357, 7359, 7381, 7383, 7389, 7391, 7413, 7415, 7421, 7423, 7429, 7431, 7437, 7439, 7445, 7447, 7453, 7455, 7461, 7463, 7469, 7471, 7477, 7479, 7485, 7487, 7509, 7511, 7517, 7519, 7541, 7543, 7549, 7551, 7557, 7559, 7565, 7567, 7573, 7575, 7581, 7583, 7589, 7591, 7597, 7599, 7605, 7607, 7613, 7615, 7637, 7639, 7645, 7647, 7669, 7671, 7677, 7679
};
//For c==d
//Total count:814
const short T2[]={
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 34, 35, 36, 37, 38, 39, 42, 43, 44, 45, 46, 47, 50, 51, 52, 53, 54, 55, 59, 60, 61, 62, 63, 134, 135, 136, 137, 140, 141, 150, 151, 152, 153, 156, 157, 162, 163, 166, 167, 172, 173, 178, 179, 182, 183, 188, 189, 262, 263, 264, 265, 268, 269, 278, 279, 280, 281, 284, 285, 290, 291, 294, 295, 300, 301, 306, 307, 310, 311, 316, 317, 389, 391, 397, 399, 405, 407, 413, 415, 421, 423, 429, 431, 437, 439, 445, 447, 518, 519, 524, 525, 534, 535, 540, 541, 550, 551, 556, 557, 566, 567, 572, 573, 646, 647, 652, 653, 662, 663, 668, 669, 678, 679, 684, 685, 694, 695, 700, 701, 773, 775, 781, 783, 789, 791, 797, 799, 805, 807, 813, 815, 821, 823, 829, 831, 903, 909, 919, 925, 935, 941, 951, 957, 1030, 1031, 1036, 1037, 1046, 1047, 1052, 1053, 1062, 1063, 1068, 1069, 1078, 1079, 1084, 1085, 1157, 1159, 1165, 1167, 1173, 1175, 1181, 1183, 1189, 1191, 1197, 1199, 1205, 1207, 1213, 1215, 1287, 1293, 1303, 1309, 1319, 1325, 1335, 1341, 1415, 1421, 1431, 1437, 1447, 1453, 1463, 1469, 1544, 1545, 1546, 1547, 1548, 1549, 1551, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1567, 1568, 1569, 1570, 1571, 1573, 1574, 1575, 1584, 1585, 1586, 1587, 1589, 1590, 1591, 1596, 1597, 1599, 1686, 1687, 1692, 1693, 1718, 1719, 1724, 1725, 1814, 1815, 1820, 1821, 1846, 1847, 1852, 1853, 1933, 1935, 1941, 1943, 1945, 1949, 1951, 1957, 1959, 1971, 1973
, 1975, 1981, 1983, 2070, 2071, 2076, 2077, 2102, 2103, 2108, 2109, 2198, 2199, 2204, 2205, 2230, 2231, 2236, 2237, 2317, 2319, 2325, 2327, 2329, 2333, 2335, 2341, 2343, 2355, 2357, 2359, 2365, 2367, 2455, 2461, 2487, 2493, 2582, 2583, 2588, 2589, 2614, 2615, 2620, 2621, 2701, 2703, 2709, 2711, 2713, 2717, 2719, 2725, 2727, 2739, 2741, 2743, 2749, 2751, 2839, 2845, 2871, 2877, 2967, 2973, 2999, 3005, 3075, 3079, 3083, 3087, 3091, 3095, 3099, 3103, 3105, 3109, 3113, 3117, 3121, 3125, 3129, 3133, 3223, 3231, 3253, 3261, 3351, 3359, 3381, 3389, 3459, 3463, 3467, 3471, 3475, 3479, 3483, 3487, 3489, 3493, 3497, 3501, 3505, 3509, 3513, 3517, 3607, 3615, 3637, 3645, 3735, 3743, 3765, 3773, 3843, 3847, 3851, 3855, 3859, 3863, 3867, 3871, 3873, 3877, 3881, 3885, 3889, 3893, 3897, 3901, 3991, 3999, 4021, 4029, 4119, 4127, 4149, 4157, 4227, 4231, 4235, 4239, 4243, 4247, 4251, 4255, 4257, 4261, 4265, 4269, 4273, 4277, 4281, 4285, 4375, 4383, 4405, 4413, 4503, 4511, 4533, 4541, 4609, 4611, 4613, 4615, 4617, 4619, 4621, 4623, 4629, 4631, 4633, 4635, 4637, 4639, 4641, 4643, 4645, 4647, 4649, 4651, 4653, 4655, 4657, 4659, 4661, 4663, 4669, 4671, 4757, 4759, 4765, 4767, 4789, 4791, 4797, 4799, 4885, 4887, 4893, 4895, 4917, 4919, 4925, 4927, 4993, 4995, 4997, 4999, 5001, 5003, 5005, 5007, 5013, 5015, 5017, 5019, 5021, 5023, 5025, 5027, 5029, 5031, 5033, 5035, 5037, 5039, 5041, 5043, 5045, 5047, 5053, 5055, 5141, 5143, 5149, 5151, 5173, 5175, 5181, 5183, 5269, 5271, 5277, 5279, 5301, 5303, 5309, 5311, 5377, 5379, 5381, 5383, 5385
, 5387, 5389, 5391, 5397, 5399, 5401, 5403, 5405, 5407, 5409, 5411, 5413, 5415, 5417, 5419, 5421, 5423, 5425, 5427, 5429, 5431, 5437, 5439, 5525, 5527, 5533, 5535, 5557, 5559, 5565, 5567, 5653, 5655, 5661, 5663, 5685, 5687, 5693, 5695, 5761, 5763, 5765, 5767, 5769, 5771, 5773, 5775, 5781, 5783, 5785, 5787, 5789, 5791, 5793, 5795, 5797, 5799, 5801, 5803, 5805, 5807, 5809, 5811, 5813, 5815, 5821, 5823, 5909, 5911, 5917, 5919, 5941, 5943, 5949, 5951, 6037, 6039, 6045, 6047, 6069, 6071, 6077, 6079, 6149, 6151, 6157, 6159, 6165, 6167, 6173, 6175, 6181, 6183, 6189, 6191, 6197, 6199, 6205, 6207, 6277, 6279, 6285, 6287, 6293, 6295, 6301, 6303, 6309, 6311, 6317, 6319, 6325, 6327, 6333, 6335, 6405, 6407, 6413, 6415, 6421, 6423, 6429, 6431, 6437, 6439, 6445, 6447, 6453, 6455, 6461, 6463, 6533, 6535, 6541, 6543, 6549, 6551, 6557, 6559, 6565, 6567, 6573, 6575, 6581, 6583, 6589, 6591, 6661, 6663, 6669, 6671, 6677, 6679, 6685, 6687, 6693, 6695, 6701, 6703, 6709, 6711, 6717, 6719, 6789, 6791, 6797, 6799, 6805, 6807, 6813, 6815, 6821, 6823, 6829, 6831, 6837, 6839, 6845, 6847, 6917, 6919, 6925, 6927, 6933, 6935, 6941, 6943, 6949, 6951, 6957, 6959, 6965, 6967, 6973, 6975, 7045, 7047, 7053, 7055, 7061, 7063, 7069, 7071, 7077, 7079, 7085, 7087, 7093, 7095, 7101, 7103, 7173, 7175, 7181, 7183, 7189, 7191, 7197, 7199, 7205, 7207, 7213, 7215, 7221, 7223, 7229, 7231, 7301, 7303, 7309, 7311, 7317, 7319, 7325, 7327, 7333, 7335, 7341, 7343, 7349, 7351, 7357, 7359, 7429, 7431, 7437, 7439, 7445, 7447, 7453, 7455, 7461, 7463, 7469, 7471, 7477
, 7479, 7485, 7487, 7557, 7559, 7565, 7567, 7573, 7575, 7581, 7583, 7589, 7591, 7597, 7599, 7605, 7607, 7613, 7615
};

//For a=b and c=d
//Total count:424
const short T3[]={
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 34, 35, 36, 37, 38, 39, 42, 43, 44, 45, 46, 47, 50, 51, 52, 53, 54, 55, 59, 60, 61, 62, 63, 134, 135, 136, 137, 140, 141, 150, 151, 152, 153, 156, 157, 162, 163, 166, 167, 172, 173, 178, 179, 182, 183, 188, 189, 262, 263, 264, 265, 268, 269, 278, 279, 280, 281, 284, 285, 290, 291, 294, 295, 300, 301, 306, 307, 310, 311, 316, 317, 518, 519, 524, 525, 534, 535, 540, 541, 550, 551, 556, 557, 566, 567, 572, 573, 646, 647, 652, 653, 662, 663, 668, 669, 678, 679, 684, 685, 694, 695, 700, 701, 1030, 1031, 1036, 1037, 1046, 1047, 1052, 1053, 1062, 1063, 1068, 1069, 1078, 1079, 1084, 1085, 1544, 1545, 1546, 1547, 1548, 1549, 1551, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1567, 1568, 1569, 1570, 1571, 1573, 1574, 1575, 1584, 1585, 1586, 1587, 1589, 1590, 1591, 1596, 1597, 1599, 1686, 1687, 1692, 1693, 1718, 1719, 1724, 1725, 1814, 1815, 1820, 1821, 1846, 1847, 1852, 1853, 2070, 2071, 2076, 2077, 2102, 2103, 2108, 2109, 2198, 2199, 2204, 2205, 2230, 2231, 2236, 2237, 2582, 2583, 2588, 2589, 2614, 2615, 2620, 2621, 3075, 3079, 3083, 3087, 3091, 3095, 3099, 3103, 3105, 3109, 3113, 3117, 3121, 3125, 3129, 3133, 3223, 3231, 3253, 3261, 3351, 3359, 3381, 3389, 3607, 3615, 3637, 3645, 3735, 3743, 3765, 3773, 4119, 4127, 4149, 4157, 4609, 4611, 4613, 4615, 4617, 4619, 4621, 4623, 4629, 4631, 4633, 4635, 4637, 4639, 4641, 4643, 4645, 4647, 4649, 4651, 4653, 4655, 4657
, 4659, 4661, 4663, 4669, 4671, 4757, 4759, 4765, 4767, 4789, 4791, 4797, 4799, 4885, 4887, 4893, 4895, 4917, 4919, 4925, 4927, 5141, 5143, 5149, 5151, 5173, 5175, 5181, 5183, 5269, 5271, 5277, 5279, 5301, 5303, 5309, 5311, 5653, 5655, 5661, 5663, 5685, 5687, 5693, 5695, 6149, 6151, 6157, 6159, 6165, 6167, 6173, 6175, 6181, 6183, 6189, 6191, 6197, 6199, 6205, 6207, 6277, 6279, 6285, 6287, 6293, 6295, 6301, 6303, 6309, 6311, 6317, 6319, 6325, 6327, 6333, 6335, 6405, 6407, 6413, 6415, 6421, 6423, 6429, 6431, 6437, 6439, 6445, 6447, 6453, 6455, 6461, 6463, 6661, 6663, 6669, 6671, 6677, 6679, 6685, 6687, 6693, 6695, 6701, 6703, 6709, 6711, 6717, 6719, 6789, 6791, 6797, 6799, 6805, 6807, 6813, 6815, 6821, 6823, 6829, 6831, 6837, 6839, 6845, 6847, 7173, 7175, 7181, 7183, 7189, 7191, 7197, 7199, 7205, 7207, 7213, 7215, 7221, 7223, 7229, 7231
};

//For b=c=d
//Total count:374
const short T4[]={
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 30, 31, 34, 35, 36, 37, 38, 39, 42, 43, 44, 45, 46, 47, 51, 52, 53, 54, 55, 59, 60, 61, 62, 63, 389, 391, 397, 399, 405, 407, 413, 415, 421, 423, 429, 431, 437, 439, 445, 447, 773, 775, 781, 783, 789, 791, 797, 799, 805, 807, 813, 815, 821, 823, 829, 831, 1157, 1159, 1165, 1167, 1173, 1175, 1181, 1183, 1189, 1191, 1197, 1199, 1205, 1207, 1213, 1215, 1544, 1545, 1546, 1547, 1548, 1549, 1551, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1567, 1568, 1569, 1570, 1571, 1573, 1574, 1575, 1584, 1585, 1586, 1587, 1589, 1590, 1591, 1596, 1597, 1599, 1941, 1943, 1949, 1951, 1973, 1975, 1981, 1983, 2325, 2327, 2333, 2335, 2357, 2359, 2365, 2367, 2709, 2711, 2717, 2719, 2741, 2743, 2749, 2751, 3075, 3079, 3083, 3087, 3091, 3095, 3099, 3103, 3105, 3109, 3113, 3117, 3121, 3125, 3129, 3133, 3475, 3479, 3483, 3487, 3505, 3509, 3513, 3517, 3859, 3863, 3867, 3871, 3889, 3893, 3897, 3901, 4243, 4247, 4251, 4255, 4273, 4277, 4281, 4285, 4609, 4611, 4613, 4615, 4617, 4619, 4621, 4623, 4629, 4631, 4633, 4635, 4637, 4639, 4641, 4643, 4645, 4647, 4649, 4651, 4653, 4655, 4657, 4659, 4661, 4663, 4669, 4671, 4993, 4995, 4997, 4999, 5001, 5003, 5005, 5007, 5013, 5015, 5017, 5019, 5021, 5023, 5025, 5027, 5029, 5031, 5033, 5035, 5037, 5039, 5041, 5043, 5045, 5047, 5053, 5055, 5377, 5379, 5381, 5383, 5385, 5387, 5389, 5391, 5397, 5399, 5401, 5403, 5405, 5407, 5409, 5411, 5413, 5415, 5417, 5419, 5421, 5423, 5425, 5427, 5429, 5431, 5437, 5439
, 5761, 5763, 5765, 5767, 5769, 5771, 5773, 5775, 5781, 5783, 5785, 5787, 5789, 5791, 5793, 5795, 5797, 5799, 5801, 5803, 5805, 5807, 5809, 5811, 5813, 5815, 5821, 5823, 6149, 6151, 6157, 6159, 6165, 6167, 6173, 6175, 6181, 6183, 6189, 6191, 6197, 6199, 6205, 6207, 6533, 6535, 6541, 6543, 6549, 6551, 6557, 6559, 6565, 6567, 6573, 6575, 6581, 6583, 6589, 6591, 6917, 6919, 6925, 6927, 6933, 6935, 6941, 6943, 6949, 6951, 6957, 6959, 6965, 6967, 6973, 6975, 7301, 7303, 7309, 7311, 7317, 7319, 7325, 7327, 7333, 7335, 7341, 7343, 7349, 7351, 7357, 7359
};

//For a=b=c=d
//Total count:158
const short T5[]={
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 30, 31, 34, 35, 36, 37, 38, 39, 42, 43, 44, 45, 46, 47, 51, 52, 53, 54, 55, 59, 60, 61, 62, 63, 1544, 1545, 1546, 1547, 1548, 1549, 1551, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1567, 1568, 1569, 1570, 1571, 1573, 1574, 1575, 1584, 1585, 1586, 1587, 1589, 1590, 1591, 1596, 1597, 1599, 3075, 3079, 3083, 3087, 3091, 3095, 3099, 3103, 3105, 3109, 3113, 3117, 3121, 3125, 3129, 3133, 4609, 4611, 4613, 4615, 4617, 4619, 4621, 4623, 4629, 4631, 4633, 4635, 4637, 4639, 4641, 4643, 4645, 4647, 4649, 4651, 4653, 4655, 4657, 4659, 4661, 4663, 4669, 4671, 4993, 4995, 5033, 5035, 5377, 5379, 5417, 5419, 5761, 5763, 5801, 5803, 6149, 6151, 6157, 6159, 6165, 6167, 6173, 6175, 6181, 6183, 6189, 6191, 6197, 6199, 6205, 6207
};

const char *orig[]={
"abcd","abdc","acbd","acdb","adbc","adcb",
"bacd","badc","bcad","bcda","bdac","bdca",
"cabd","cadb","cbad","cbda","cdab","cdba",
"dabc","dacb","dbac","dbca","dcab","dcba"
};

typedef struct struct_factor{
int up;
int down;
}factor;

typedef factor * pfactor;
typedef const factor * pcfactor;

void add(pfactor r,pcfactor a,pcfactor b)
{
if(a->down==0||b->down==0){
r->down=0;
}
else
{
r->down=a->down*b->down;
r->up=a->up*b->down+b->up*a->down;
}
}

void sub(pfactor r,pcfactor a,pcfactor b)
{
if(a->down==0||b->down==0){
r->down=0;
}
else
{
r->down=a->down*b->down;
r->up=a->up*b->down-b->up*a->down;
}
}

void mul(pfactor r,pcfactor a,pcfactor b)
{
r->down=a->down*b->down;
r->up=a->up*b->up;
}

void div(pfactor r,pcfactor a,pcfactor b)
{
if(a->down==0||b->down==0){
r->down=0;
}
else
{
r->down=a->down*b->up;
r->up=a->up*b->down;
}
}

int equal(pcfactor a,pcfactor b)
{
if(a->down==0||b->down==0){
return 0;//false
}
else{
return a->down*b->up==a->up*b->down;
}
}

int equal_num(pcfactor a,int b)
{
if(a->down==0){
return 0;
}
else{
return a->up==b*a->down;
}
}

typedef void (*Operation)(pfactor,pcfactor,pcfactor);
Operation operators[]={add,sub,mul,div};

const char opprint[]="+-*/";

//total 14 bits needed, 5*24*4^3
#define FIRST_OP(x) ((x)&3) //type of op1
#define SECOND_OP(x) (((x)>>2)&3) //type of op2
#define THIRD_OP(x) (((x)>>4)&3) //type of op3
#define GRAPH_TYPE(x) (((x)>>6)/24) //type of graph, using 0 to 4.
#define NUM_ORDER(x) (((x)>>6)%24) //using 0 to 23 present order of number

#define C1(a) C(a,T1,sizeof(T1)/sizeof(T1[0]))
#define C2(a) C(a,T2,sizeof(T2)/sizeof(T2[0]))
#define C3(a) C(a,T3,sizeof(T3)/sizeof(T3[0]))
#define C4(a) C(a,T4,sizeof(T4)/sizeof(T4[0]))
#define C5(a) C(a,T5,sizeof(T5)/sizeof(T5[0]))

void C(const int s[4],const short T[],int count){
int total=0;//found operations count
int i;
factor a,b,c,d,r1,r2,r;
for(i=0;i<count;i++){
int op1,op2,op3,gtype,order;
const char *porder;
op1=FIRST_OP(T[i]);
op2=SECOND_OP(T[i]);
op3=THIRD_OP(T[i]);
gtype=GRAPH_TYPE(T[i]);
order=NUM_ORDER(T[i]);
a.down=b.down=c.down=d.down=1;
porder=orig[order];
a.up=s[porder[0]-'a'];
b.up=s[porder[1]-'a'];
c.up=s[porder[2]-'a'];
d.up=s[porder[3]-'a'];
if(i==411||i==395){
int x=1;
}
switch(gtype){
case 0:
// op2
// /// / // op1 op3
// /\ /// a bc d
operators[op1](&r1,&a,&b);
operators[op3](&r2,&c,&d);
operators[op2](&r,&r1,&r2);
if(equal_num(&r,RESULT))
{
total++;
if(op1<2&&op2>=2){
printf("(%d%c%d)%c",a.up,opprint[op1],b.up,opprint[op2]);
}else{
printf("%d%c%d%c",a.up,opprint[op1],b.up,opprint[op2]);
}
if(op2>op3||op2==op3&&(op2&1)){
printf("(%d%c%d)\n",c.up,opprint[op3],d.up);
}else{
printf("%d%c%d\n",c.up,opprint[op3],d.up);
}
}
break;
case 1:
// op3
// /// op2 d
// /\
// op1 c
// /\
// a b
operators[op1](&r1,&a,&b);
operators[op2](&r2,&r1,&c);
operators[op3](&r,&r2,&d);
if(equal_num(&r,RESULT)){
total++;
if(op2<2&&op3>=2){printf("(");}
if(op1<2&&op2>=2){printf("(");}
printf("%d%c%d",a.up,opprint[op1],b.up);
if(op1<2&&op2>=2){printf(")");}
printf("%c%d",opprint[op2],c.up);
if(op2<2&&op3>=2){printf(")");}
printf("%c%d\n",opprint[op3],d.up);
}
break;
case 2:
// op3
// /// op1 d
// /\
// a op2
// /\
// b c
operators[op2](&r1,&b,&c);
operators[op1](&r2,&a,&r1);
operators[op3](&r,&r2,&d);
if(equal_num(&r,RESULT)){
total++;
if(op1<2&&op3>=2){printf("(");}
printf("%d%c",a.up,opprint[op1]);
if(op1>op2||op2==op1&&(op2&1)){printf("(");}
printf("%d%c%d",b.up,opprint[op2],c.up);
if(op1>op2||op2==op1&&(op2&1)){printf(")");}
if(op1<2&&op3>=2){printf(")");}
printf("%c%d\n",opprint[op3],d.up);
}
break;
case 3:
// op1
// /// a op3
// /\
// op2 d
// /\
// b c
operators[op2](&r1,&b,&c);
operators[op3](&r2,&r1,&d);
operators[op1](&r,&a,&r2);
if(equal_num(&r,RESULT))
{
total++;
printf("%d%c",a.up,opprint[op1]);
if(op1>op3||op3==op1&&(op3&1)){printf("(");}
if(op2<2&&op3>=2){printf("(");}
printf("%d%c%d",b.up,opprint[op2],c.up);
if(op2<2&&op3>=2){printf(")");}
printf("%c%d",opprint[op3],d.up);
if(op1>op3||op3==op1&&(op3&1)){printf(")");}
printf("\n");
}
break;
case 4:
// op1
// /// a op2
// /\
// b op3
// /\
// c d
operators[op3](&r1,&c,&d);
operators[op2](&r2,&b,&r1);
operators[op1](&r,&a,&r2);
if(equal_num(&r,RESULT))
{
total++;
printf("%d%c",a.up,opprint[op1]);
if(op1>op2||op2==op1&&(op2&1)){printf("(");}
printf("%d%c",b.up,opprint[op2]);
if(op2>op3||op3==op2&&(op3&1)){printf("(");}
printf("%d%c%d",c.up,opprint[op3],d.up);
if(op2>op3||op3==op2&&(op3&1)){printf(")");}
if(op1>op2||op2==op1&&(op1&1)){printf(")");}
printf("\n");
}
break;
}
}
printf("Total count %d\n",total);
}



void main()
{
int a[4];
int i,j;
printf("Please input a (1<=a<=13):\n");
scanf("%d",&a[0]);
if(a[0]<1||a[0]>13)
{
printf("Out of range\n");
return;
}
printf("Please input b (1<=b<=13):\n");
scanf("%d",&a[1]);
if(a[1]<1||a[1]>13)
{
printf("Out of range\n");
return;
}
printf("Please input c (1<=b<=13):\n");
scanf("%d",&a[2]);
if(a[2]<1||a[2]>13)
{
printf("Out of range\n");
return;
}
printf("Please d (1<=d<=13):\n");
scanf("%d",&a[3]);
if(a[3]<1||a[3]>13)
{
printf("Out of range\n");
return;
}
for(i=0;i<4;i++)for(j=i;j<4;j++){
if(a[i]>a[j]){
int temp;
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
if(a[0]==a[1]){//a==b.
if(a[1]!=a[2]){
if(a[2]!=a[3]){//a==b
int temp;
temp=a[2];
a[2]=a[0];
a[0]=temp;
temp=a[3];
a[3]=a[1];
a[1]=temp;
C2(a);
}else{//a==b,c==d
C3(a);
}
}else if(a[2]!=a[3]){//a=b=c
int temp=a[0];
a[0]=a[3];
a[3]=temp;
C4(a);
}else{//a=b=c=d
C5(a);
}
}else{//a<b
if(a[1]==a[2]){
if(a[2]!=a[3]){//b==c
int temp=a[3];
a[3]=a[1];
a[1]=temp;
C2(a);
}else{//b=c=d
C4(a);
}
}else{//a<b<c
if(a[2]==a[3]){//c==d
C2(a);
}else{//a<b<c<d
C1(a);
}
}
}
}
njhhack 2001-10-30
  • 打赏
  • 举报
回复
嘿嘿,得了吧,太烦了哟
mathe 2001-10-30
  • 打赏
  • 举报
回复
I have pasted wrong table here.
try http://www.csdn.net/expert/topic/156/156716.shtm
njhhack 2001-10-29
  • 打赏
  • 举报
回复
回溯法,你写过吗,给我看看:)
student_ahu 2001-10-29
  • 打赏
  • 举报
回复
to nbxwj(我心飞扬)
能不能详细谈谈你的回溯法思路?
gust 2001-10-29
  • 打赏
  • 举报
回复
多谢剑影兄了
nbxwj 2001-10-28
  • 打赏
  • 举报
回复
用回溯法吧很简单的
cj520 2001-10-28
  • 打赏
  • 举报
回复
晚上我也回去写一个看看.
njhhack 2001-10-28
  • 打赏
  • 举报
回复
唉,本人的联系地址有所改变,这样有不懂的可以来找我
oicq:10772919
e-mail:njhhack@21cn.com
主页:hotsky.363.net
------------------------------------
其实算24也没什么困难的,我的思路是这样:
分两步走:1.找出所有可能的算24的表达式组合,并把不可能算出24的表达式剔除掉,
比如我们找到一个表达式a-b-c-d,但显然这个表达式是算不出24的,所以我们就不
要它了,经过选择,我们得到了下面这45个表达式:

a+b+c+d
a+b+c-d
;
a*b+c+d
a*b+c-d
a*b-c-d
a/b+c+d
;
(a+b)*c+d
(a+b)*c-d
(a-b)*c+d
(a-b)*c-d
(a+b)/c+d
;
(a+b+c)*d
(a+b-c)*d
(a-b-c)*d
(a+b+c)/d
;
(a+b)*(c+d)
(a+b)*(c-d)
(a-b)*(c-d)
;
a*b*c+d
a*b*c-d
a*b/c+d
a*b/c-d
;
a*b+c*d
a*b-c*d
a*b+c/d
a*b-c/d
;
(a+b)*c*d
(a+b)*c/d
(a-b)*c*d
(a-b)*c/d
a*b/(c+d)
a*b/(c-d)
;
a/(b-c/d)
a/(b/c-d)
(a+b*c)/d
(a*b-c)/d
(a+b/c)*d
(a+b*c)*d
(a-b*c)*d
(a-b/c)*d
(a*b-c)*d
(a/b-c)*d
;
a*b*c*d
a*b*c/d
a*b/c/d

然后我们进入第2步,对a,b,c,d这4个数字进行全排列,一共有24种排列方法,然后用这24种排列
方法对45个表达式都运算一次,这样就不会漏掉任何一种可能,但这理有一个问题,就是可能会出
现大量重复,比如2*3*4*1和3*2*4*1和4*3*2*1他们其实是同一种方法,是重复的,不过要去掉这
种重复是困难的,为此本人提出一个简化方法,就是每种表达式只取一种结果,这样就可以极大的
简化编程,同时又去掉了重复,虽然这样会漏掉一些同一个表达式有两种算法的情况,但至少达到
这样的效果,就是可以找出所以可以的表达式算法,也就是说只要这个表达式能算出24,我就一定
能把他找出来,这样就不会漏掉任何一个可能的表达式,我的程序用sum[]数组实现这种选择优化
方法是给每个表达式设定一个sum[x]变量,每算到一种可能的结果,就把sum[x]的值加1,我们只
输出当sum[x]是0的结果
在运算时还有一个问题要注意,在遇到除法时要注意分母不能等于0,还有就是除法的整除性
比如a*b/(c-d)要注意c-d=0的情况,还有比如4/3不能整除的情况,这可以用4%3的方法来求余,
从而达到判断是否整除的目的,
呵呵,我想我的这个算法虽不是最优的,但也是很不错的一种穷举算法,若有兄弟比我想的更好,不
要忘了和多说一下,我要好好学学哟:)


njhhack 2001-10-28
  • 打赏
  • 举报
回复
嘿嘿这次全部能处理代码也简单多了包你看得懂
njhhack 2001-10-28
  • 打赏
  • 举报
回复
int DEBUG,sum[45],a,b,c,d;
void make24(int a,int b,int c,int d);
main(int argc,char *argv[])
{
DEBUG=1;
if(argc<5)
{
printf("Error:use as\nm1.exe 2 3 4 5");
exit(0);
}
a=atoi(argv[1]);
b=atoi(argv[2]);
c=atoi(argv[3]);
d=atoi(argv[4]);
;
make24(a,b,c,d);
make24(a,b,d,c);
make24(a,c,b,d);
make24(a,c,d,b);
make24(a,d,b,c);
make24(a,d,c,b);
;
make24(b,c,d,a);
make24(b,c,a,d);
make24(b,d,c,a);
make24(b,d,a,c);
make24(b,a,c,d);
make24(b,a,d,c);
;
make24(c,b,a,d);
make24(c,b,d,a);
make24(c,d,b,a);
make24(c,d,a,b);
make24(c,a,d,b);
make24(c,a,b,d);
;
make24(d,c,a,b);
make24(d,c,b,a);
make24(d,b,c,a);
make24(d,b,a,c);
make24(d,a,c,b);
make24(d,a,b,c);
;
}
void make24(int a,int b,int c,int d)
{
if(DEBUG)if(!sum[1]&&a+b+c+d==24){sum[1]++;printf("\n%d+%d+%d+%d=24",a,b,c,d);}
if(DEBUG)if(!sum[2]&&a+b+c-d==24){sum[2]++;printf("\n%d+%d+%d-%d=24",a,b,c,d);}
/* */
if(DEBUG)if(!sum[3]&&a*b+c+d==24){sum[3]++;printf("\n%d*%d+%d+%d=24",a,b,c,d);}
if(DEBUG)if(!sum[4]&&a*b+c-d==24){sum[4]++;printf("\n%d*%d+%d-%d=24",a,b,c,d);}
if(DEBUG)if(!sum[5]&&a*b-c-d==24){sum[5]++;printf("\n%d*%d-%d-%d=24",a,b,c,d);}
if(DEBUG)if(!sum[6]&&a%b==0&&a/b+c+d==24){sum[6]++;printf("\n%d/%d+%d+%d=24",a,b,c,d);}
;
if(DEBUG)if(!sum[7]&&(a+b)*c+d==24){sum[7]++;printf("\n(%d+%d)*%d+%d=24",a,b,c,d);}
if(DEBUG)if(!sum[8]&&(a+b)*c-d==24){sum[8]++;printf("\n(%d+%d)*%d-%d=24",a,b,c,d);}
if(DEBUG)if(!sum[9]&&(a-b)*c+d==24){sum[9]++;printf("\n(%d-%d)*%d+%d=24",a,b,c,d);}
if(DEBUG)if(!sum[10]&&(a-b)*c-d==24){sum[10]++;printf("\n(%d-%d)*%d-%d=24",a,b,c,d);}
if(DEBUG)if(!sum[11]&&(a+b)%c==0&&(a+b)/c+d==24){sum[11]++;printf("\n(%d+%d)/%d+%d=24",a,b,c,d);}
;
if(DEBUG)if(!sum[12]&&(a+b+c)*d==24){sum[12]++;printf("\n(%d+%d+%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[13]&&(a+b-c)*d==24){sum[13]++;printf("\n(%d+%d-%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[14]&&(a-b-c)*d==24){sum[14]++;printf("\n(%d-%d-%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[15]&&(a+b+c)%d==0&&(a+b+c)/d==24){sum[15]++;printf("\n(%d+%d+%d)/%d=24",a,b,c,d);}
;
if(DEBUG)if(!sum[16]&&(a+b)*(c+d)==24){sum[16]++;printf("\n(%d+%d)*(%d+%d)=24",a,b,c,d);}
if(DEBUG)if(!sum[17]&&(a+b)*(c-d)==24){sum[17]++;printf("\n(%d+%d)*(%d-%d)=24",a,b,c,d);}
if(DEBUG)if(!sum[18]&&(a-b)*(c-d)==24){sum[18]++;printf("\n(%d-%d)*(%d-%d)=24",a,b,c,d);}
/* */
if(DEBUG)if(!sum[19]&&a*b*c+d==24){sum[19]++;printf("\n%d*%d*%d+%d=24",a,b,c,d);}
if(DEBUG)if(!sum[20]&&a*b*c-d==24){sum[20]++;printf("\n%d*%d*%d-%d=24",a,b,c,d);}
if(DEBUG)if(!sum[21]&&a*b%c==0&&a*b/c+d==24){sum[21]++;printf("\n%d*%d/%d+%d=24",a,b,c,d);}
if(DEBUG)if(!sum[22]&&a*b%c==0&&a*b/c-d==24){sum[22]++;printf("\n%d*%d/%d-%d=24",a,b,c,d);}
;
if(DEBUG)if(!sum[23]&&a*b+c*d==24){sum[23]++;printf("\n%d*%d+%d*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[24]&&a*b-c*d==24){sum[24]++;printf("\n%d*%d-%d*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[25]&&c%d==0&&a*b+c/d==24){sum[25]++;printf("\n%d*%d+%d/%d=24",a,b,c,d);}
if(DEBUG)if(!sum[26]&&c%d==0&&a*b-c/d==24){sum[26]++;printf("\n%d*%d-%d/%d=24",a,b,c,d);}
;
if(DEBUG)if(!sum[27]&&(a+b)*c*d==24){sum[27]++;printf("\n(%d+%d)*%d*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[28]&&(a+b)*c%d==0&&(a+b)*c/d==24){sum[28]++;printf("\n(%d+%d)*%d/%d=24",a,b,c,d);}
if(DEBUG)if(!sum[29]&&(a-b)*c*d==24){sum[29]++;printf("\n(%d-%d)*%d*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[30]&&(a-b)*c%d==0&&(a-b)*c/d==24){sum[30]++;printf("\n(%d-%d)*%d/%d=24",a,b,c,d);}
if(DEBUG)if(!sum[31]&&a*b%(c+d)==0&&a*b/(c+d)==24){sum[31]++;printf("\n%d*%d/(%d+%d)=24",a,b,c,d);}
if(DEBUG)if(!sum[32]&&c-d!=0&&a*b%(c-d)==0&&a*b/(c-d)==24){sum[32]++;printf("\n%d*%d/(%d-%d)=24",a,b,c,d);}
;
if(DEBUG)if(!sum[33]&&b*d-c!=0&&a*d/(b*d-c)==24){sum[33]++;printf("\n%d/(%d-%d/%d)=24",a,b,c,d);}
if(DEBUG)if(!sum[34]&&b-c*d!=0&&a*c/(b-c*d)==24){sum[34]++;printf("\n%d/(%d/%d-%d)=24",a,b,c,d);}
if(DEBUG)if(!sum[35]&&(a+b*c)%d==0&&(a+b*c)/d==24){sum[35]++;printf("\n(%d+%d*%d)/%d=24",a,b,c,d);}
if(DEBUG)if(!sum[36]&&(a*b-c)%d==0&&(a*b-c)/d==24){sum[36]++;printf("\n(%d*%d-%d)/%d=24",a,b,c,d);}
if(DEBUG)if(!sum[37]&&b*d%c==0&&a*d+b*d/c==24){sum[37]++;printf("\n(%d+%d/%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[38]&&(a+b*c)*d==24){sum[38]++;printf("\n(%d+%d*%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[39]&&(a-b*c)*d==24){sum[39]++;printf("\n(%d-%d*%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[40]&&b*d%c==0&&a*d-b*d/c==24){sum[40]++;printf("\n(%d-%d/%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[41]&&(a*b-c)*d==24){sum[41]++;printf("\n(%d*%d-%d)*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[42]&&a*d%b==0&&a*d/b-c*d==24){sum[42]++;printf("\n(%d/%d-%d)*%d=24",a,b,c,d);}
/* */
if(DEBUG)if(!sum[43]&&a*b*c*d==24){sum[43]++;printf("\n%d*%d*%d*%d=24",a,b,c,d);}
if(DEBUG)if(!sum[44]&&a*b*c%d==0&&a*b*c/d==24){sum[44]++;printf("\n%d*%d*%d/%d=24",a,b,c,d);}
if(DEBUG)if(!sum[45]&&a*b%(c*d)==0&&a*b/c/d==24){sum[45]++;printf("\n%d*%d/%d/%d=24",a,b,c,d);}
}

/* 2+(4+5+4+3)+(4+4+6+10)+3=2+16+24+3=45
如果设计一个算24的程序呢,呵呵,有好多方法,最通常的想法是,做一个表达式运算器,然后穷举各种

;/////////////////
a+b+c+d
a+b+c-d
;////////////////
a*b+c+d
a*b+c-d
a*b-c-d
a/b+c+d
;
(a+b)*c+d
(a+b)*c-d
(a-b)*c+d
(a-b)*c-d
(a+b)/c+d
;
(a+b+c)*d
(a+b-c)*d
(a-b-c)*d
(a+b+c)/d
;
(a+b)*(c+d)
(a+b)*(c-d)
(a-b)*(c-d)
;////////////////
a*b*c+d
a*b*c-d
a*b/c+d
a*b/c-d
;
a*b+c*d
a*b-c*d
a*b+c/d
a*b-c/d
;
(a+b)*c*d
(a+b)*c/d
(a-b)*c*d
(a-b)*c/d
a*b/(c+d)
a*b/(c-d)
;
a/(b-c/d)
a/(b/c-d)
(a+b*c)/d
(a*b-c)/d
(a+b/c)*d
(a+b*c)*d
(a-b*c)*d
(a-b/c)*d
(a*b-c)*d
(a/b-c)*d
;//////////////
a*b*c*d
a*b*c/d
a*b/c/d
;/////////////
*/
gust 2001-10-27
  • 打赏
  • 举报
回复
真的就没有什么好方法了吗?
njhhack 2001-10-26
  • 打赏
  • 举报
回复
{
************** 一个算 24 的程序 ***********
* 作者: 倪建华 *
* 最后更新:2001.2.24 *
* 信箱: njhhack@china.com *
* 主页: http://njhhack.at.china.com *
* 欢迎使用本软件,转载此源码者请加上以上信息 *
* 请尊重作者劳动,谢谢合作! *
* HackSoft Workgroup 2001.2.24 *
**************************************************
}

#include
int g=9,d=0,p[100],u[300],debug=1;
unsigned long c=0,kkd=0;

void pp()
{
/*
kkd++;
*/
}
void can(int *a)
{
int i,g;
float gg;
if(!u[0]){g=a[0]+a[1]+a[2]+a[3];if(g==24){pp(); u[0]++;if(debug)printf("\n%d+%d+%d+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[1]){g=a[0]+a[1]+a[2]-a[3];if(g==24){pp();u[1]++;if(debug)printf("\n%d+%d+%d-%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[2]){g=a[0]*a[1]+a[2]+a[3];if(g==24){pp();u[2]++;if(debug)printf("\n%d*%d+%d+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[3]){g=a[0]*a[1]+a[2]-a[3];if(g==24){pp();u[3]++;if(debug)printf("\n%d*%d+%d-%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[4]){g=a[0]*a[1]-a[2]-a[3];if(g==24){pp();u[4]++;if(debug)printf("\n%d*%d-%d-%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[5]){g=a[0]*a[1]-a[0]*a[2]/a[3];if(a[0]*a[2]%a[3])g=0;if(g==24){pp();u[5]++;if(debug)printf("\n%d*(%d-%d/%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[6]){g=a[0]*a[1]+a[0]*a[2]/a[3];if(a[0]*a[2]%a[3])g=0;if(g==24){pp();u[6]++;if(debug)printf("\n%d*(%d+%d/%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[7]){g=-a[0]*a[3]+a[0]*a[1]/a[2];if(a[0]*a[1]%a[2])g=0;if(g==24){pp();u[7]++;if(debug)printf("\n%d*(%d/%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[8]){g=a[0]*(a[1]+a[2])+a[3];if(g==24){pp();u[8]++;if(debug)printf("\n%d*(%d+%d)+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[9]){g=a[0]*(a[1]+a[2])-a[3];if(g==24){pp();u[9]++;if(debug)printf("\n%d*(%d+%d)-%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[10]){g=a[0]*(a[1]-a[2])+a[3];if(g==24){pp();u[10]++;if(debug)printf("\n%d*(%d-%d)+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[11]){g=a[0]*(a[1]-a[2])-a[3];if(g==24){pp();u[11]++;if(debug)printf("\n%d*(%d-%d)-%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[12]){g=a[0]*(a[1]+a[2]+a[3]);if(g==24){pp();u[12]++;if(debug)printf("\n%d*(%d+%d+%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[13]){g=a[0]*(a[1]+a[2]-a[3]);if(g==24){pp();u[13]++;if(debug)printf("\n%d*(%d+%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[14]){g=a[0]*(a[1]-a[2]-a[3]);if(g==24){pp();u[14]++;if(debug)printf("\n%d*(%d-%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[15]){g=a[0]/a[1]+a[2]+a[3];if(a[0]%a[1])g=0;if(g==24){pp();u[15]++;if(debug)printf("\n%d/%d+%d+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[16]){g=(a[0]+a[1])/a[2]+a[3];if((a[0]+a[1])%a[2])g=0;if(g==24){pp();u[16]++;if(debug)printf("\n(%d+%d)/%d+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[17]){g=a[0]*a[1]*a[2]+a[3];if(g==24){pp();u[17]++;if(debug)printf("\n%d*%d*%d+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[18]){g=a[0]*a[1]*(a[2]+a[3]);if(g==24){pp();u[18]++;if(debug)printf("\n%d*%d*(%d+%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[19]){g=a[0]*a[1]*(a[2]-a[3]);if(g==24){pp();u[19]++;if(debug)printf("\n%d*%d*(%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[20]){g=a[0]*a[1]*a[2]-a[3];if(g==24){pp();u[20]++;if(debug)printf("\n%d*%d*%d-%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[21]){g=a[0]*a[1]+a[2]*a[3];if(g==24){pp();u[21]++;if(debug)printf("\n%d*%d+%d*%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[22]){g=a[0]*a[1]-a[2]*a[3];if(g==24){pp();u[22]++;if(debug)printf("\n%d*%d-%d*%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[23]){g=a[0]*(a[1]+a[2]*a[3]);if(g==24){pp();u[23]++;if(debug)printf("\n%d*(%d+%d*%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[24]){g=a[0]*(a[1]-a[2]*a[3]);if(g==24){pp();u[24]++;if(debug)printf("\n%d*(%d-%d*%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[25]){g=a[0]*(a[1]*a[2]-a[3]);if(g==24){pp();u[25]++;if(debug)printf("\n%d*(%d*%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[26]){if(.1*a[1]-.1*a[2]/a[3])gg=.1*a[0]/(.1*a[1]-.1*a[2]/a[3]);else gg=0;if(gg==24){pp();u[26]++;if(debug)printf("\n%d/(%d-%d/%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[27]){if(.1*a[1]/a[2]-.1*a[3])gg=.1*a[0]/(.1*a[1]/a[2]-.1*a[3]);else gg=0;if(gg==24){pp();u[27]++;if(debug)printf("\n%d/(%d/%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[28]){g=a[0]*a[1]/a[2]+a[3];if(a[0]*a[1]%a[2])g=0;if(g==24){pp();u[28]++;if(debug)printf("\n%d*%d/%d+%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[29]){g=a[0]*a[1]/(a[2]+a[3]);if(a[0]*a[1]%(a[2]+a[3]))g=0;if(g==24){pp();u[29]++;if(debug)printf("\n%d*%d/(%d+%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[30]){if(a[2]-a[3]){g=a[0]*a[1]/(a[2]-a[3]);if(a[0]*a[1]%(a[2]-a[3]))g=0;}else gg=0;if(g==24){pp();u[30]++;if(debug)printf("\n%d*%d/(%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[31]){g=a[0]*a[1]/a[2]-a[3];if(a[0]*a[1]%a[2])g=0;if(g==24){pp();u[31]++;if(debug)printf("\n%d*%d/%d-%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[32]){g=a[0]*a[1]-a[2]/a[3];if(a[2]%a[3])g=0;if(g==24){pp();u[32]++;if(debug)printf("\n%d*%d-%d/%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[33]){g=a[0]*a[1]+a[2]/a[3];if(a[2]%a[3])g=0;if(g==24){pp();u[33]++;if(debug)printf("\n%d*%d+%d/%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[34]){g=a[0]*a[1]*a[2]*a[3];if(g==24){pp();u[34]++;if(debug)printf("\n%d*%d*%d*%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[35]){g=a[0]*a[1]*a[2]/a[3];if(a[0]*a[1]*a[2]%a[3])g=0;if(g==24){pp();u[35]++;if(debug)printf("\n%d*%d*%d/%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[36]){g=a[0]*a[1]/a[2]/a[3];if(a[0]*a[1]/a[2]%a[3])g=0;if(g==24){pp();u[36]++;if(debug)printf("\n%d*%d/%d/%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[37]){g=(a[0]+a[1]+a[2])/a[3];if((a[0]+a[1]+a[2])%a[3])g=0;if(g==24){pp();u[37]++;if(debug)printf("\n(%d+%d+%d)/%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[38]){g=(a[0]+a[1])*(a[2]+a[3]);if(g==24){pp();u[38]++;if(debug)printf("\n(%d+%d)*(%d+%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[39]){g=(a[0]+a[1])*(a[2]-a[3]);if(g==24){pp();u[39]++;if(debug)printf("\n(%d+%d)*(%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[40]){g=(a[0]-a[1])*(a[2]-a[3]);if(g==24){pp();u[40]++;if(debug)printf("\n(%d-%d)*(%d-%d)=24",a[0],a[1],a[2],a[3]);}}
if(!u[41]){g=a[0]*(a[1]+a[2])/a[3];if(a[0]*(a[1]+a[2])%a[3])g=0;if(g==24){pp();u[41]++;if(debug)printf("\n%d*(%d+%d)/%d=24",a[0],a[1],a[2],a[3]);}}
if(!u[42]){g=a[0]*(a[1]-a[2])/a[3];if(a[0]*(a[1]-a[2])%a[3])g=0;if(g==24){pp();u[42]++;if(debug)printf("\n%d*(%d-%d)/%d=24",a[0],a[1],a[2],a[3]);}}
}
void fun(int *a,int k)
{
int b[100],t,i,j;
if(k<1)
{
can(p);
return;
}
for(i=0;i<=k-1;i++)
{
for(j=0;j<=k-1;j++)b[j]=a[j];
b[k-1]=p[k-1]=a[i];
b[i]=p[i]=a[k-1];
fun(b,k-1);
}
}
main(int argc,char *argv[])
{
int j,df,ad[5]={7,1,5,1};
int d1,d2,d3,d4;
if(argc<=4)
{
printf("\nError Use of 24 point\nUse AS:\n24 2 4 6 8\n");
exit(1);
}
ad[0]=atoi(argv[1]);
ad[1]=atoi(argv[2]);
ad[2]=atoi(argv[3]);
ad[3]=atoi(argv[4]);

for(j=0;j<=41;j++)u[j]=0;

fun(ad,4);
}

gust 2001-10-26
  • 打赏
  • 举报
回复
to: starfish(海星)
例如 (1+2)*(3+5) 12+35+*
(3+5)*(2+1) 35+21+*
这按通常24点规则应该算是一种方法,可逆波兰式并不相同(好久没看了,不知化的对不对)。
我觉得似乎还是需要一些特别的判定情况,就象你的网站上一篇《全面的考虑问题中》针对一些特定问题所罗列的规则一样,另外看了这篇文章,我先写了一个脱去多余括号的函数,化去了不少重复项。
我到现在想到的规则只有,若三个运算符都为+或*,表达式相同。
gust 2001-10-26
  • 打赏
  • 举报
回复
输入 1 2 3 4 的 212种答案总算精简到39种了

to njhhack(剑影)
你的程序非常不错,代码和输出都很精简,但我看不太懂,也是一种穷举法吗?

不过在测试中 若输入 8 4 2 2 四个数
你的程序输出为
4*(2+2)+8=24
4*2*2+8=24
4*2+2*8=24
2*(2*8-4)=24
4*(2+8/2)=24
8*(2+4)/2=24
8*(4-2/2)=24
七种答案

我的代码输出还不能去除过多的冗余,有44种答案,但其中有两种是你的程序所没有的
若你的代码再能优化一下一定是最佳的了
8/2*(4+2)
(8+2)*2+4

把所有输出也一并列出吧,大伙一起看看还能使用哪些规则去除冗余
1 8+4*(2+2)
2 8+4*2*2
3 8*(4+2)/2
4 8*(4-2/2)
5 8+2*4*2
6 8*2+4*2
7 8*(2+4)/2
8 (8*2-4)*2
9 8/2*(4+2)
10 8+(2+2)*4
11 (8+2)*2+4
12 8+2*2*4
13 8*2+2*4
14 (8/2+2)*4
15 8/2*(2+4)
16 4+(8+2)*2
17 4*(8/2+2)
18 4+(2+8)*2
19 4+2*(8+2)
20 (4+2)*8/2
21 4*2+8*2
22 4*(2+8/2)
23 4+2*(2+8)
24 (4+2)/2*8
25 (4-2/2)*8
26 4*(2+2)+8
27 4*2+2*8
28 4*2*2+8
29 (2+4)*8/2
30 2*4+8*2
31 (2+4)/2*8
32 2*4+2*8
33 2*4*2+8
34 2*8+4*2
35 (2*8-4)*2
36 (2+8)*2+4
37 (2+8/2)*4
38 2*(8+2)+4
39 2*8+2*4
40 2*(8*2-4)
41 2*(2+8)+4
42 2*(2*8-4)
43 (2+2)*4+8
44 2*2*4+8
starfish 2001-10-25
  • 打赏
  • 举报
回复
最好的办法就是化为逆波兰,而且这个方法也不复杂
人通过几条规则来判断并不十分准确,有很多情况一下子判断不出来。所以还是化逆波兰比较好
CNer 2001-10-25
  • 打赏
  • 举报
回复
I see too....
xiaodaoren 2001-10-25
  • 打赏
  • 举报
回复
关注!
njhhack 2001-10-25
  • 打赏
  • 举报
回复
到hotsky.363.net上看看

33,008

社区成员

发帖
与我相关
我的任务
社区描述
数据结构与算法相关内容讨论专区
社区管理员
  • 数据结构与算法社区
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧