双色球1至33每6个数字相加等于94的和值有多少_百度作业帮
双色球1至33每6个数字相加等于94的和值有多少
双色球1至33每6个数字相加等于94的和值有多少有一个两位数。甲说：我知道这个两位数的两个数字之和。乙说：我知道这个两位数约数的个数。甲说：我不知道这个两位数。乙说：我也不知道，但我知道它的奇偶。甲说：我知道了。乙说：我也知道了。求这个两位数。
两个可能吧 30和96？
本人原创，原文见：&a href=&/devymex/p/3329635.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&甲乙两人互猜数字（鬼谷子问题）的逻辑推理与算法建模&i class=&icon-external&&&/i&&/a&&br&一、问题&br&&p&这是一道历史悠久，又很困难的逻辑推理题，有的公司还会将其作为面试题。有人将其称为“鬼谷子问题”，但笔者至今没有找到任何可靠来源。先给出问题。&/p&&blockquote&&p&你在旁观主持人和甲、乙两个天才数学家玩猜数字游戏。主持人准备了两个数，告知甲乙：这两个数不同，且大于等于1，小于等于30。然后主持人将两数之积告诉甲，把两数之和告诉乙。甲知道乙拿到两数之和，乙也知道甲拿到两数之积。主持人让甲乙猜这两个数字，让甲先发言。&/p&&p&甲：“我不知道这两个数是什么”&/p&&p&乙：“我也不知道”&/p&&p&甲：“那我知道了”&/p&&p&乙：“那我也知道了”&/p&&p&请问你，这两个数是什么？&/p&&/blockquote&&p&另一种等价表述（即所谓的鬼谷子问题）：&/p&&blockquote&&p&一天，鬼谷子随意从2-99中选取了两个数。他把这两个数的和告诉了庞涓，把这两个数的乘积告诉了孙膑。但孙膑和庞涓彼此不知到对方得到的数。第二天，庞涓很有自信的对孙膑说：虽然我不知到这两个数是什麽，但我知道你一定也不知道。随后，孙膑说：那我知道了。庞涓说：那我也知道了。&/p&&/blockquote&&p&网上有不少对这道题的讨论和答案，但几乎都没有准确的推理过程，有些甚至是错误的。本文用尽量清晰的语言给出详细的推理过程，然后给出了计算机建模和程序实现，以及进一步的发散思考。但建议在参阅下面的答案前，先自行认真思考。&/p&&br&&br&二、分析与推理&br& 1. 约定&br&&p&由于推断的逻辑很复杂，所以必须用约定的语言来描述。本文所用的推断名称格式如下：&/p&&p&“1甲n”表示若甲拿到的两数之积为n，第1次发言时做的推断。&/p&&p&“1乙m”表示若乙拿到的两数之和为m，根据甲的第1次发言，乙做出的推断。&/p&&p&“2甲n”表示若甲拿到的两数之积为n，根据乙的第1次发言，甲做出的推断。&/p&&p&“2乙m”表示若乙拿到的两数之和为m，根据甲的第2次发言，乙做出的推断。&/p&&p&前提是甲乙都是天才数学家，因此一定会先假设两个数，然后将自己做为对方进行推断。如果可以推断出，则一定不会失误。&/p&&p&推断的书写格式为：&/p&&p&推断名：可能拆分1，结论1；可能拆分2，结论2；……&/p&&p&推断名为红色表示可知推断，即可推断出确切的两个数；绿色表示未知推断，即有多种可能。&/p&&br&&br&2. 推理过程&br&甲说：“我不知道”&br&&p&下面列出甲拿到的积为2到12的全部情况。(A)若两数之积只有一种拆分的情况下甲会做出已知推断，与甲这次未知的事实不符；(B)若至少有两种可能，则甲做出未知推断，符合甲这次未知的事实。&/p&&p&1甲2：1*2，可知1和2。(A)&/p&&p&1甲3：1*3，可知1和3。(A)&/p&&p&1甲4：1*4，可知1和4。(A)&/p&&p&1甲5：1*5，可知1和5。(A)&/p&&p&1甲6：1*6，2*3。(B)&/p&&p&1甲7：1*7，可知1和7。(A)&/p&&p&1甲8：1*8，2*4。(B)&/p&&p&1甲9：1*9，可知1和9。(A)&/p&&p&1甲10：1*10，2*5。(B)&/p&&p&1甲11：1*11，可知1和11。(A)&/p&&p&1甲12：1*12，2*6，3*4。(B)&/p&&p&以下略，易证得两数之积为素数或素数的平方时为已知推断，否则为未知推断。&/p&&br&乙说：“我也不知道”&br&&p&1. 对于乙，若两数之和只有一种拆分可能，则乙会做出已知推断，与乙第一次未知的事实不符。&/p&&br&&p&2. &br&若至少有两种拆分可能，则乙可在假设某一种拆分的情况下，算得两数之积，然后假设自己为甲做出推断，并得到相应的结论：(A)若在假设的某一种拆分的情况&br&下甲会做出已知推断，则该情况与甲第一次未知的事实矛盾；(B)若有且只有一种拆分的情况下甲会做出未知推断，则乙可做出已知推断（就是这种拆分），与乙这次未知的事实矛盾；(C)若有至少两种拆分的情况下甲都会做出未知推断，则乙做出未知推断，符合乙这次未知的事实。&/p&&p&1乙3：1+2，可知1和2。(A)&/p&&p&1乙4：1+3，可知1和3。(A)&/p&&p&1乙5：1+4，则1甲4；2+3，则1甲6。(B)&/p&&p&1乙6：1+5，则1甲5；2+4，则1甲8。(B)&/p&&p&1乙7：1+6，则1甲6；2+5，则1甲10；3+4，则1甲12。(C)&/p&&p&1乙8：1+7，则1甲7；2+6，则1甲12；3+5，则1甲15。(C)&/p&&p&1乙9：1+8，则1甲8；2+7，则1甲14；3+6，则1甲18。(C)&/p&&p&1乙10：1+9，则1甲9；2+8，则1甲16；3+7，则1甲21；4+6，则1甲24。(C)&/p&&p&以下略，可算得皆为未知推断。&/p&&br&甲说：“那我知道了”&br&&p&对于甲，在排除第一次的已知推断后，在剩下的推断中两数之积必有两个或以上的拆分可能。那么甲可在假设某一种拆分的情况下，算得两数之和，然后假设自己为乙做出推断，并得到相应的结论：(A)若至少有两种拆分的情况下乙都会做出未知推断，则甲只能做出未知推断，与甲这次已知的事实矛盾；(B)若有一种拆分的情况下乙会做出未知推断，符合乙第一次未知的事实，则甲可做出已知推断，符合甲这次已知的事实。&/p&&p&2甲6：1*6，则1乙7；2*3，则1乙5。(B)&/p&&p&2甲8：1*8，则1乙9；2*4，则1乙6。(B)&/p&&p&2甲10：1*10，则1乙11；2*5，则1乙7。(A)&/p&&p&2甲12：1*12，则1乙12； 2*6，则1乙8；3*4，则1乙7。(A)&/p&&p&以下略，可算得皆为未知推断。&/p&&br&乙说：“那我也知道了”&br&&p&对于乙，在排除上次的已知推断后，在剩下的推断中两数之和必有两个或以上的拆分可能。那么乙可在假设某一种拆分的情况下，算得两数之积，然后假设自己为甲做出推断，并得到相应的结论：(A)若假设的所有拆分情况下甲都会在第二次做出未知推断，则该情况与甲第二次已知的事实矛盾；(B)若有一种拆分的情况下甲会在第二次做出已知推断，符合甲第二次已知的事实，则乙可做出已知推断，符合乙这次已知的事实。&/p&&p&2乙7：1+6，则2甲6；2+5，则2甲10；3+4，则2甲12。(B)&/p&&p&2乙8：1+7，则2甲7；2+6，则2甲12；3+5，则2甲15。(A)&/p&&p&2乙9：1+8，则2甲8；2+7，则2甲15；3+6，则2甲18；4+5，则2甲20。(B)&/p&&p&2乙10：1+9，则2甲9；2+8，则2甲16；3+7，则2甲21；4+6，则2甲24。(A)&/p&&p&蓝色标注的情况早在第一次推断就被排除，不予考虑。以下略，可算得皆为未知推断。&/p&&br&&br&3. 结论&br&&p&当两数为1和6时或1和8时，甲乙各自的两次推断结论均满足题目所描述的事实。&/p&&br&&br&三、计算机建模与实现&br&&br&1. 模型&br&&p&下面将用计算机程序来对这一问题进行建模，并在最后给出C++代码的实现。先给出一些定义（不要怕，仔细看看会发现其实都很简单）。&/p&&ol&&li&“拆分”是由取值范围内两个不同的两个数构成二元组；&/li&&li&给定取值范围的所有拆分构成“全集”；&/li&&li&经过推导排除掉全集中的一些拆分后的集合后形成“可能解集”；&/li&&li&“拆分之积”是指拆分的两数乘积；&/li&&li&“拆分之和”是指拆分的两数加和；&/li&&li&可能解集中，所有“拆分之积”等于同一数值的所有拆分构成的子集称为“兄弟积拆分”；&/li&&li&可能解集中，所有“拆分之和”等于同一数值的所有拆分构成的子集称为“兄弟和拆分”。&/li&&/ol&&p&例如：取值范围给定为[1,4]，那么所有拆分构成的全集为：{&1 2&, &1 3&, &1 4&, &2 3&, &2 4&, &3 4&}。拆分&1 4&的拆分之和为1+4=5，拆分&2 3&的拆分之积为2*3=6。上述全集中的一个兄弟和拆分为：{&1 4&, &2 3&}，这是因为1+4=2+3=5。&/p&&p&分析前文的推导过程可知，当一种拆分在一次推导中被排除后，这种拆分的所有兄弟拆分也一同被排除。此外，由于取值范围设定的不同，拆分的数量是很难找到规律的，结果也很难通过推导直接算出。因此我们需要用计算机来模拟推导过程，不断排除不可能的解，最后剩下的可能解集就是所有解。&/p&&p&根据上面的理论，可将甲乙的推导过程建模如下。甲的第一次推导中排除的是只包含一种拆分的“兄弟积拆分”（如1甲4和1甲5）。乙的第一次推导是在甲的第一次推导中已经排除掉一些拆分（如1甲4和1甲5）后的基础上进行的，因此乙同样排除掉了只包含一种拆分的“兄弟和拆分”（如1乙6，注意，1乙6的拆分1+5之前已被1甲5排除）。甲的第二次推导仍是在之前排除掉一些拆分（如1乙6）后的基础上进行的，而这一次甲会排除掉包含多于一种拆分的“兄弟积拆分”（如2甲10和2甲12）。乙的第二次推导和甲的第二次推导类似，也会排除掉包含多一种拆分的“兄弟和拆分”。&/p&&p&进一步建模，可得到程序过程如下。&/p&&ol&&li&构造全集Q；&/li&&li&删除Q中所有成员数小于或等于1的兄弟积拆分；&/li&&li&删除Q中所有成员数小于或等于1的兄弟和拆分；&/li&&li&删除Q中所有成员数不等于1的兄弟积拆分；&/li&&li&删除Q中所有成员数不等于1的兄弟和拆分；&/li&&li&输出Q中所剩的解。&/li&&/ol&&br&2. 数据结构与算法&br&&p&为实现上述模型，需要以下几种基本操作：构造全集、求兄弟和拆分、求兄弟积拆分、推导排除。由于兄弟拆分需要满足两个条件：1) &br&运算结果相同；2) 属于可能解集。因此求兄弟拆分可用两种方法求出：1) 枚举出运算结果相同的所有拆分，逐一判断是否在可能解集内；2) &br&遍历可能解集，筛选出运算结果相同的所有拆分。由于判断属于可能解集的操作要使用查找操作，因此无论从实现复杂度还是效率上来讲都是方法2)较优。&/p&&p&排除的操作即对应于程序中的删除，对于绝大多数数据结构，删除中间元素都比添加到末尾麻烦一些。因此最高效的方法不是直接删除排除掉的拆分，而是另存不被排除的拆分，最后替换原集。但是另存会产生重复元素，且会导致无序。因此在替换原集之前做排序和去重是必要的。&/p&&p&为了避免结构体操作，可使用一个unsigned long类型的整数表示一个拆分，其中高16位和低16位分别表示拆分中的两个数。&/p&&p&综上所述，用C++语言实现，解集用stl库中的vector&unsigned &br&long&表示。推导函数可抽象为：对于一个可能解集，用一种运算（乘或加）求出所有兄弟拆分，再用一种判断（小于等于1或不等于1）来决定求出的&br&每一个兄弟拆分是否应该从解集中删除。因此推导函数可用模板实现，运算操作和判断操作可直接使用stl库中的functional的相关仿函数实现。&/p&&p&更一般的，我们可以求出每一种取值范围[1, n]，n从2变化为99。&/p&&br&&br&3. C++代码&br&&br&#include &iostream&&br&#include &algorithm&&br&#include &functional&&br&#include &vector&&br&&br&typedef&br&typedef u&br&typedef std::vector&ulong& ULONGVEC;&br&typedef ULONGVEC::iterator ULONGVEC_I;&br&&br&template&typename _Op, typename _Jd&&br&void Deduce(ULONGVEC &pairs, _Op op, _Jd jd)&br&{&br&
ULONGVEC&br&
for (ULONGVEC_I i = pairs.begin(); i != pairs.end(); ++i) {&br&
ulong cnt = 0, res = op(*i && 16, *i & 0xFFFF);&br&
//求出所有兄弟拆分，存入bros的末尾&br&
for (ULONGVEC_I j = pairs.begin(); j != pairs.end(); ++j) {&br&
if (op(*j && 16, *j & 0xFFFF) == res) {&br&
bros.push_back(*j);&br&
// 判断兄弟拆分是否满足条件，如不满足则不保留该兄弟集合&br&
if (jd(cnt, 1)) bros.erase(bros.end() - cnt, bros.end());&br&
//排序、去重、替换原集&br&
std::sort(bros.begin(), bros.end());&br&
ULONGVEC_I iEnd = std::unique(bros.begin(), bros.end());&br&
pairs.assign(bros.begin(), iEnd);&br&}&br&&br&int main()&br&{&br&
for (ushort n = 2; n & 100; ++n) {&br&
ULONGVEC&br&
for (ushort i = 1; i & ++i)&br&
for (ushort j = i + 1; j &= ++j)&br&
pairs.push_back((i && 16) | j);&br&
// 四次推导过程&br&
Deduce(pairs, std::multiplies&ulong&(), std::less_equal&ulong&());&br&
Deduce(pairs, std::plus&ulong&(), std::less_equal&ulong&());&br&
Deduce(pairs, std::multiplies&ulong&(), std::not_equal_to&ulong&());&br&
Deduce(pairs, std::plus&ulong&(), std::not_equal_to&ulong&());&br&
std::cout && &1 to & && n && &: &;&br&
for (ULONGVEC_I i = pairs.begin(); i != pairs.end(); ++i)&br&
std::cout && '(' && (*i && 16) && ',' && (*i & 0xFFFF) && &); &;&br&
std::cout && std::&br&
return 0;&br&}&br&&br&&br&4. 运行结果&br&&br&&div class=&highlight&&&pre&&code class=&language-text&&1 to 2:
1 to 9: (1,8); (3,8);
1 to 10: (3,8); (5,8);
1 to 11: (3,8); (5,8);
1 to 12: (1,6); (4,9); (8,9);
1 to 13: (1,6); (4,9); (8,9);
1 to 14: (1,6); (7,12);
1 to 15: (1,6);
1 to 16: (1,6); (1,8);
1 to 17: (1,6); (1,8);
1 to 18: (1,6); (1,8); (9,12); (9,16);
1 to 19: (1,6); (1,8); (9,12); (9,16);
1 to 20: (1,6); (1,8);
1 to 21: (1,6); (1,8); (14,18);
1 to 22: (1,6); (1,8); (11,16); (14,18);
1 to 23: (1,6); (1,8); (11,16); (14,18);
1 to 24: (1,6); (1,8);
1 to 25: (1,6); (1,8); (16,18); (18,20);
1 to 26: (1,6); (1,8); (18,20);
1 to 27: (1,6); (1,8); (18,21);
1 to 28: (1,6); (1,8); (16,27);
1 to 29: (1,6); (1,8); (16,27);
1 to 30: (1,6); (1,8);
1 to 31: (1,6); (1,8);
1 to 32: (1,6); (1,8); (20,27);
1 to 33: (1,6); (1,8); (20,27);
1 to 34: (1,6); (1,8); (22,27);
1 to 35: (1,6); (1,8); (25,28);
1 to 36: (1,6); (1,8); (24,30); (27,32);
1 to 37: (1,6); (1,8); (24,30); (27,32);
1 to 38: (1,6); (1,8); (27,32);
1 to 39: (1,6); (1,8);
1 to 40: (1,6); (1,8);
1 to 41: (1,6); (1,8);
1 to 42: (1,6); (1,8); (25,42); (26,36);
1 to 43: (1,6); (1,8); (25,42); (26,36);
1 to 44: (1,6); (1,8);
1 to 45: (1,6); (1,8); (33,40);
1 to 46: (1,6); (1,8); (33,40);
1 to 47: (1,6); (1,8); (33,40);
1 to 48: (1,6); (1,8); (36,40);
1 to 49: (1,6); (1,8); (35,42);
1 to 50: (1,6); (1,8); (35,42);
1 to 51: (1,6); (1,8); (33,48);
1 to 52: (1,6); (1,8); (33,48); (40,45);
1 to 53: (1,6); (1,8); (33,48); (40,45);
1 to 54: (1,6); (1,8); (42,45);
1 to 55: (1,6); (1,8); (44,45);
1 to 56: (1,6); (1,8); (40,54);
1 to 57: (1,6); (1,8); (36,56);
1 to 58: (1,6); (1,8); (36,56);
1 to 59: (1,6); (1,8); (36,56);
1 to 60: (1,6); (1,8); (45,52); (48,50);
1 to 61: (1,6); (1,8); (45,52); (48,50);
1 to 62: (1,6); (1,8); (45,52); (48,50);
1 to 63: (1,6); (1,8); (48,50);
1 to 64: (1,6); (1,8); (48,56);
1 to 65: (1,6); (1,8); (48,56);
1 to 66: (1,6); (1,8); (48,63);
1 to 67: (1,6); (1,8); (48,63);
1 to 68: (1,6); (1,8); (48,65);
1 to 69: (1,6); (1,8);
1 to 70: (1,6); (1,8); (55,56); (56,60);
1 to 71: (1,6); (1,8); (55,56); (56,60);
1 to 72: (1,6); (1,8); (49,72); (54,64); (60,63);
1 to 73: (1,6); (1,8); (49,72); (54,64); (60,63);
1 to 74: (1,6); (1,8); (49,72); (54,64); (60,63);
1 to 75: (1,6); (1,8); (54,64); (60,63);
1 to 76: (1,6); (1,8); (54,64);
1 to 77: (1,6); (1,8); (54,64);
1 to 78: (1,6); (1,8); (65,66);
1 to 79: (1,6); (1,8); (65,66);
1 to 80: (1,6); (1,8); (65,66); (65,72);
1 to 81: (1,6); (1,8);
1 to 82: (1,6); (1,8);
1 to 83: (1,6); (1,8);
1 to 84: (1,6); (1,8);
1 to 85: (1,6); (1,8); (64,75); (72,77);
1 to 86: (1,6); (1,8); (64,75); (72,77);
1 to 87: (1,6); (1,8); (64,75); (68,75); (72,77);
1 to 88: (1,6); (1,8); (60,88); (64,75); (72,77);
1 to 89: (1,6); (1,8); (60,88); (64,75); (72,77);
1 to 90: (1,6); (1,8); (75,78);
1 to 91: (1,6); (1,8);
1 to 92: (1,6); (1,8); (72,80);
1 to 93: (1,6); (1,8); (72,80);
1 to 94: (1,6); (1,8); (72,80);
1 to 95: (1,6); (1,8); (72,80);
1 to 96: (1,6); (1,8); (72,92); (76,90);
1 to 97: (1,6); (1,8); (72,92); (76,90);
1 to 98: (1,6); (1,8); (72,92); (76,90);
1 to 99: (1,6); (1,8); (72,92); (75,96);
&/code&&/pre&&/div&&br&&br&5. 复杂度分析&br&&p&对于每一种n的取值进行分析。取值范围为[1,n]，那么全集的元素个数为C(n, &br&2)，即n(n-1)/2，故构造全集的复杂度为O(n(n-1)/2)=O(n^2)。假设每次推导的复杂度均为O(f(m))，那么4次推导的复杂度&br&为O(4*f(m))=O(f(m))，因此4次推导的复杂度以其中最大的一次为准。又因为推导函数的执行过程相同，算杂度只和输入的集合元素个数相关，&br&故甲的第一次推导起决定作用。设输入的集合元素个数为m，在推导过程中并没有删除元素，两种循环的执行次数相同，且在bros末尾添加元素的复杂度为&br&O(1)，因此复杂度为O(m^2)；后面的排序去重操作的复杂度为O(m*logm)。综上，推导函数的复杂度为O(m^2)。将m=n^2代入，得到&br&算法整体复杂度为O(n^4)。&/p&&br&&br&四、扩展&br& 1. 进一步发散&br&&p&对于两个数不相同的设定，这道题只有在取值范围是[1, &br&16]的前题下有唯一解：1和8。如果我们更改推导的过程，是否可以增加能推导出唯一解的取值范围的数量呢？答案是肯定的。显然两个人中只要有一个人推导&br&成功，那么这个游戏将在本轮或下一轮结束（取决于是乙先推导出还是甲先推导出），也就是说在某个人推导出一对确定的拆分后，再让他推导发言是没有意义的。&br&因此只能够给甲乙增加“不知道”的推导，才符合事实和逻辑。那我们尝试给甲增加一次“不知道”的推导，看看结果如何。这样两人对话就变成了：&/p&&blockquote&&p&甲：“我不知道这两个数是什么”，乙：“我也不知道”，甲：“我还是不知道”，乙：“那我就知道了”，甲：“那我也知道了”。&/p&&/blockquote&&p&对应于算法就是将甲的第二次推导判定条件更改为：“std::less_equal&ulong&()”，这样就得到了一组解，其中具有唯一解的取值范围列举如下：&/p&&div class=&highlight&&&pre&&code class=&language-text&&1 to 14: (5,14);
1 to 18: (7,18);
1 to 19: (7,18);
1 to 21: (12,20);
1 to 24: (10,24);
1 to 25: (14,24);
1 to 27: (15,24);
1 to 28: (15,28);
1 to 29: (15,28);
1 to 32: (15,32);
1 to 33: (16,33);
1 to 38: (24,35);
1 to 45: (28,45);
1 to 46: (28,45);
1 to 47: (28,45);
1 to 48: (28,48);
1 to 49: (32,45);
&/code&&/pre&&/div&&p&其中最小的唯一解取值范围是[1,14]，这两个数是5和14。这里要注意的是：[1, 49]的取值范围内有唯一解32和45，不代表[1, 50]的范围内有唯一解。事实上若取值范围设定为[1, 50]是无解的。&/p&&br&&br&2. 练习&br&&p&请读者思考以下3道练习题，其中第3道题尚未被解决。&/p&&ol&&li&如果两个数可以相同，那这道题是否有唯一解？如果有，解是什么？请用程序实现。&/li&&li&若取值范围的设定不超过[1, 100]，即从[1,2]到[1,100]，存在唯一解的推导过程最多有几轮？&/li&&li&要算出1到50000取值范围内的解，上述程序算法将遇到性能瓶颈，请问有什么办法解决？&/li&&/ol&
本人原创，原文见：一、问题这是一道历史悠久，又很困难的逻辑推理题，有的公司还会将其作为面试题。有人将其称为“鬼谷子问题”，但笔者至今没有找到任何可靠来源。先给出问题。你在旁观主持人和甲、乙…从1到33每6个数相加等于101有几组要全部列出来_百度知道
从1到33每6个数相加等于101有几组要全部列出来
全部列出来。LZ是在糊弄人吧。。。还是用程序列吧。。。一共有20068组，把&--&内的代码复制到记事本中，另存为bat格式，比如1.bat双击会跳出个黑色窗口，别管它，可以最小化，穷举完了会自动关闭。然后在与bat相同的目录下会出现个1.txt的文件，就是所有数组了，由于bat一直在运行，txt内容是不断再更新的，期间打开看的话注意不要修改数据。我机子比较破，花了半个小时。代码比较长，for的用法忘记了，用的印象中的汇编的思路，见笑了。:------------------------------------------------------------------------------------echo offset /a i=0set /a a=1set /a b=2set /a c=3set /a d=4set /a e=5set /a f=6goto com:abgset /a a+=1set /a b=%a%+1set /a c=%b%+1set /a d=%c%+1set /a e=%d%+1set /a f=%e%+1if %a% equ 15 goto endgoto com:bbgset /a b+=1set /a c=%b%+1set /a d=%c%+1set /a e=%d%+1set /a f=%e%+1if %b% equ 30 goto abggoto com:cbgset /a c+=1set /a d=%c%+1set /a e=%d%+1set /a f=%e%+1if %c% equ 31 goto bbggoto com:dbgset /a d+=1set /a e=%d%+1set /a f=%e%+1if %d% equ 32 goto cbggoto com:ebgset /a e+=1set /a f=%e%+1if %e% equ 33 goto dbg:comif %f% equ 34 goto ebgset /a n=%a%+%b%+%c%+%d%+%e%+%f%if %n% equ 101 goto priset /a f+=1goto com:priset /a i+=1echo %i%、%a% %b% %c% %d% %e% %f% && 1.txtset /a f+=1goto com:end:------------------------------------------------------------------------------------
其他类似问题
为您推荐：
其他1条回答
你有数据吗
可以发给我吧
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁怎么算1到35中5个数不重复相加等于70到130之间_百度作业帮
怎么算1到35中5个数不重复相加等于70到130之间
怎么算1到35中5个数不重复相加等于70到130之间
1,2,18,34,353,4,19,31,335,6,17,30,327,8,20,27,289.10.16.26.2912,14,15,24.2511,13,21,22,23每组相加都等于90一至三十三个数，取六个数相加等于一百二十一共这里面有几组_百度作业帮
一至三十三个数，取六个数相加等于一百二十一共这里面有几组
一至三十三个数，取六个数相加等于一百二十一共这里面有几组
24354组。 例如 1+2+3+21+34+35 1+2+3+22+33+35 1+2+3+23+32+35 1+2+3+23+33+34 1+2+3+24+31+35 1+2+3+24+32+34 1+2+3+25+30+35 1+2+3+25+31+34 1+2+3+25+32+33 1+2+3+26+29+35 …… …… 12+13+15+17+19+20 12+13+16+17+18+20 12+14+15+16+17+22 12+14+15+16+18+21 12+14+15+16+19+20 12+14+15+17+18+20 12+14+16+17+18+19