鬼谷子的问题（我的解）

[Allen]

前段时间有同学在班级录上说这个答案是1和6，我觉得不可能是1和6，否则的话，和就是7，从和来看1和6，2和5，3和4都有可能鬼谷子选择的数，那么对应的积就是6、10、12，如果鬼谷子选择的数是2和5，那么积就是10，从乘积来看就只能是2和5了，那么庞涓怎么能肯定孙膑不知道这两个数呢？我觉得这两个数可能是这样的：从它的和推出来各种数对，每个数对有一个积，得到这个积的方法一定要至少大于两种，比如说2和9，它们的和是11，11是庞涓知道的，那么庞涓推测这个和可以从2+9，3+8， 4+7， 5+6得到，相应的积就是18，24，28，30。无论其中任何是孙膑知道的，那么都有至少两种数对得到这个积，也就是说，庞涓可以确认，无论鬼谷子把18，24，28还是30告诉孙膑，孙膑都没法确定这两个数。如果从满足这个条件来看，符合的数对之和只要满足它们的和等于11，17，23，27，29，35，36，41，47，53就可以了。答案有许多，呵呵！ ；） 大家新年快乐

[matongyu]

楼主说的对，我要分

[Allen]

呵呵，我以为大家都知道这个问题了呢，前段时间我在这里的论坛上看到这个问题的，莫非是我记错了？？ ；） 原题如下：

“一日，鬼谷子在2--100这99个数字中选了2个数字，然后把它们的和告诉了庞涓(和=c)，把积告诉了孙膑(积=s)。当然，庞涓不知道积是多少，孙膑不知道和是多少。
第二日，庞涓遇见孙膑，很傲慢的对孙膑说：“虽然我不知道这两个数是多少但是我肯定你也不知道。孙膑立刻还击道：“本来我不知道的，但是现在我知道这两个数是多少了。”庞涓想了一 会，说道：“现在我也知道这两个数是多少了。”问这两个数是多少？

我觉得我的解也可能不对，题目毕竟是要一个答案的呀！让我选的话，我就猜是20和9吧。

[smuwcwt]

顶一下

[mahongxi]

KAO,啥年代啦，早就解出来啦。 4-13

[spiketang]

我觉得什么都可以，你的C和Ｓ是什么呀！什么都没有！那就什么都可以啦！

[mahongxi]

/*

* Created on 2003-11-23

*

* 一日，鬼谷子在2--100这99个数字中选了2个数字，然后把它们的和告诉了庞涓，

* 把积告诉了孙膑。当然，庞涓不知道积是多少，孙膑不知道和是多少。 第二日，

* 庞涓遇见孙膑很傲慢的对孙膑说："虽然我不知道这两个数是多少但是我肯定你

* 也不知道。"孙膑立刻还击道："本来我不知道的，但是现在我知道这两个数是多

* 少了。"庞涓想了一 会，说道："现在我也知道这两个数是多少了。" 　　

* 请问这二个数各是多少?

*/

/**

* @author mhx

* @exception Exception

* To change the template for this generated type comment go to

* Window - Preferences - Java - Code Generation - Code and Comments

*/
import java.util.*;

class ETwoEqualNumber extends Exception{}

class EInvalidParam extends Exception{}



class IntPair{

public IntPair(int i1,int i2)throws ETwoEqualNumber{

if(i1 == i2)

throw new ETwoEqualNumber();

n1 = i1;

n2 = i2;

}

public String toString(){

return "{"+Integer.toString(n1) +" & " +Integer.toString(n2)+"}";

}

public int hashCode(){

return n1 + n2;

}

public boolean equals(Object o){



boolean res = (o instanceof IntPair) && (

((IntPair)o).n1 == n1 && ((IntPair)o).n2 == n2

||

((IntPair)o).n1 == n2 && ((IntPair)o).n2 == n1

);

return res;

}

public int sum(){

return n1 + n2;

}

public int mult(){

return n1 * n2;

}

int n1;

int n2;



public static void main(String [] args)throws Exception{

HashSet hs = new HashSet();

hs.add(new IntPair(2,3));

hs.add(new IntPair(3,2));

hs.add("x");

hs.add("x");



System.out.println(hs);



}

}

public class Answer {

static HashSet getIntPairsBySum(int sum)throws EInvalidParam{

if (sum < (2*smallNumber + 1)|| sum > (2*bigNumber - 1))

throw new EInvalidParam();

HashSet hs = new HashSet();

int top = Math.min(sum/2,bigNumber);

for (int i = smallNumber; i <= top;i++)

if (i != sum - i)

try{

hs.add(new IntPair(i,sum - i));

}catch(ETwoEqualNumber e){

System.err.println(e);

}

return hs;

}

static HashSet getIntPairsByMult(int mult)throws EInvalidParam{

if(mult <(smallNumber * (smallNumber + 1)) || mult > (bigNumber * (bigNumber - 1)))

throw new EInvalidParam();

HashSet hs = new HashSet();

for(int i = smallNumber;i < bigNumber;i++){

if (mult%i == 0 && i != mult/i && mult/i >= smallNumber && mult/i <= bigNumber)

try{

hs.add(new IntPair(i,mult/i));

}catch(ETwoEqualNumber e){

System.err.println(e);

}



}

return hs;

}

public static void usage(){

System.out.println("USAGE:");

System.out.println("java Answer smallNumber bigNumber");

System.out.println("such as: java Answer 2 100");

System.exit(0);

}

public static void main(String[] args) throws Exception{

//check params

if (args.length != 2)

usage();

try{

smallNumber = Integer.parseInt(args[0]);

bigNumber = Integer.parseInt(args[1]);

if (smallNumber >= bigNumber)

throw new Exception();

}catch(Exception e){

usage();

}
HashSet hs1,hs2;

HashSet sums = new HashSet();



F1:

for (int i = (2*smallNumber + 1);i <= (2*bigNumber - 1);i++){

hs1 = getIntPairsBySum(i);

Iterator it1 = hs1.iterator();



while(it1.hasNext()){

IntPair ip = (IntPair)it1.next();

hs2 = getIntPairsByMult(ip.mult());



if (hs2.size() <= 1)

continue F1;

}

sums.add(new Integer(i));

}



System.out.print("possible sums :" + sums);

System.out.println(" count = "+sums.size());

HashSet mults = new HashSet();

F2:

for (int i = (smallNumber * (smallNumber + 1));i<=(bigNumber * (bigNumber - 1));i++){

hs1 = getIntPairsByMult(i);

Iterator it1 = hs1.iterator();

int count = 0;

while(it1.hasNext()){

IntPair ip = (IntPair)it1.next();

if (sums.contains(new Integer(ip.sum()))){

count++;

}

if (count >=2)

continue F2;

}

if (count == 1){

mults.add(new Integer(i));

}

}

System.out.print("possible multiplies :" +mults);

System.out.println(" count = "+mults.size());



HashSet result = new HashSet();

Iterator it = sums.iterator();

W:

while(it.hasNext()){

int val = ((Integer)it.next()).intValue();

HashSet hs = getIntPairsBySum(val);

Iterator it1 = hs.iterator();

int count = 0;

IntPair ip = null;

IntPair ip2 = null;

while(it1.hasNext()){

ip = (IntPair)it1.next();

if (mults.contains(new Integer(ip.mult()))){

count++;

ip2 = ip;

}

if (count >= 2)

continue W;

}

if (count == 1){

if (ip == null)

throw new Exception("impossible! count is 1,but ip is null!");

result.add(ip2);

}

}

System.out.println("===================================");

if (result.size() != 1){

System.out.println("sorry,i can\'t find out the answer!");

}else{

System.out.println("the Answer is:" + result.iterator().next());

}

}

private static int smallNumber = 0;

private static int bigNumber = 1;

}

[Allen]

好象有人说过答案是4和13的

[jolinoyd]

好深奥哦
偶不懂，偶只是来接分的

[ljky1998]

明白一个题好难!

[Allen]

小弟才疏，实在不知道为什么答案一定是4和13，还望哪位大侠指点一二。上面的程序，看起来许多不明白，能不能概要的说说原理啊，谢了

[hame2599]

upupupupupupupuupuuuupupup

[taolei]

如果只有规定范围内的一组数可以满足它们的乘积等于孙膑知道的那个数，那么孙膑就可以直接知道这两个数了。比如，如果乘积是35，那么这两个数肯定是5和7。也许有人想到了素数，其实不尽然，比如4x53，也是唯一的，因为有2-100的限制，不可能分解为2x106

庞涓知道的合为sum,孙膑知道的积为product
***规则A: 对于一个乘积p,如果在2-100内只有唯一的两个数满足它们的积是p，那么从p就可以确定这两个数。

显然，孙膑知道的乘积并不满足A.

第二日，庞涓遇见孙膑，很傲慢的对孙膑说：“虽然我不知道这两个数是多少但是我肯定你也不知道。"
这句话的意思是： 对于庞涓知道的合s,所有满足和是s的2-100的两个数，都不能通过他们的乘积来直接确定那两个数，所以庞涓才这么说。

***规则B:所有满足2-100内，合是sum的两个数，它们的积都不满足规则A


孙膑立刻还击道：“本来我不知道的，但是现在我知道这两个数是多少了。”

孙膑真的很聪明，他也许早就考虑到庞涓说的这种情况，那么如果只有一组满足2-100内，乘积是product的两个数，它们的合满足庞涓说的这种情况，孙膑就可以知道这两个数了。

***规则C:只有一组满足2-100内，乘积是product的两个数，它们的合(sum)满足规则B

庞涓想了一 会，说道：“现在我也知道这两个数是多少了。”
我该说庞涓比孙膑聪明，因为最后一步的计算量实在不小了，分析规则ABC的计算量也许还可以，最后一步要是不用计算机，恐怕一时半会儿是算不出来的。
道理跟规则C一样：
***规则D:只有一组满足2-100内，合是sum的两个数，它们的积(product)满足规则C

判断规则都有了，总结一下：那么鬼谷子的两个数x,y，必需满足：
2<=x<=100
2<=y<=100
x*y 不满足规则A
x+y 满足规则B
x*y 满足规则C
x+y 满足规则D
答案是4，13

附程序:
#define MIN_N 2
#define MAX_N 100

bool ruleA(int s)
{
int c = 0;
for(int i=MIN_N;i<=MAX_N;i++)
{
int j = s / i;
if (j < i)
break;
if (i*j == s && j<=MAX_N)
{
c++;
if (c > 1)
return false;
}
}
return c == 1;
}
bool ruleB(int p)
{
for(int i=MIN_N;i<=p/2;i++)
{
int j = p-i;
if (j<=MAX_N && ruleA(i*j))
return false;
}
return true;
}
bool ruleC(int s)
{
int c = 0;
for(int i=MIN_N;i<=MAX_N;i++)
{
int j = s/i;
if (j < i)
break;
if (i*j == s && j<=MAX_N)
{
if (ruleB(i+j))
{
c++;
if (c>1)
return false;
}
}
}
return c == 1;
}
bool ruleD(int p)
{
int c = 0;
for(int i=MIN_N;i<=p/2;i++)
{
int j = p-i;
if (j<=MAX_N && ruleC(i*j))
{
c ++ ;
if (c > 1)
return false;
}
}
return c == 1;
}
int main(int argc, char* argv[])
{
for(int i=MIN_N;i<=MAX_N;i++)
{
for(int j=i;j<=MAX_N;j++)
{
if (!ruleA(i*j) && ruleB(i+j) && ruleC(i*j) && ruleD(i+j))
{
printf("%d,%d\n",i,j);
}
}
}
return 0;
}

[Allen]

借用taolei(实在无聊)的贴补充一下，满足和是11、17、23、27、29、35、37、41、47、53的数对仅仅满足ruleA和ruleB，孙膑如果利用他知道的乘积（product）就可以得到这两个数的话，它们的和至多满足一次开始的情况，比如下面：
sum=11
2+ 9*= 18
2* 9
3* 6
3+ 8*= 24
2*12
3* 8
4* 6
4+ 7*= 28
2*14
4* 7
5+ 6*= 30
2*15
3*10
5* 6
##################################
sum=17
2+15*= 30
2*15
3*10
5* 6
3+14*= 42
2*21
3*14
6* 7
4+13*= 52
2*26
4*13
5+12*= 60
2*30
3*20
4*15
5*12
6*10
6+11*= 66
2*33
3*22
6*11
7+10*= 70
2*35
5*14
7*10
8+ 9*= 72
2*36
3*24
4*18
6*12
8* 9
##################################
孙膑知道的积不可能是30，否则就不能确定数对是(2,15)还是(5,6)，ruleC可以过滤这样的情况（加号两边的数对之积如果在其他段中出现，这样的数对就不满足要求），上面的结果就会是这样：
sum=11
2+ 9*= 18
2* 9
3* 6
3+ 8*= 24
2*12
3* 8
4* 6
4+ 7*= 28
2*14
4* 7
##################################
sum=17
4+13*= 52
2*26
4*13
##################################
到这里，庞涓就知道这两个数的积只能是18、24、28、52…………，（仿照上面列表，将方向颠倒）
product=18
2* 9+=11
3* 6+=9
product=24
2*12+=14
3* 8+=11
4* 6+=10
product=28
2*14+=16
4* 7+=11
product=52
2*26+=28
4*13+=17
…………
…………
由于和必须满足是11、17、23、27、29、35、37、41、47、53：
product=18
2* 9+=11
product=24
3* 8+=11
product=28
4* 7+=11
product=52
4*13+=17
…………
…………
再去除乘号两边数对之和在其他段中出现的情况，就能得到最后的答案4和13，（ruleD）

taolei的程序实在很棒，已经收藏先了！ ；）

[QSmile]

下来再看看！

[zalyer]

以前讨论过。

[goooogle]

up

[Damachli]

没有题面，大家却讨论的津津有味的，嘻嘻 :>

[niuzhenjun]

我倒

[程勉超]

1 首先这两个数字不会同时为质数，否则孙膑很容易算出来

2 庞涓说：你肯定也不知道
这表明，庞涓得到的这个和S，分解成的n+m中，每一对nm中肯定至少有一个不是质数
由此可以得出从5-199的这样的S。
这样的S有：11， 17， 23， 27， … 198, 199。一共82个
如果两个数中有一个是大于50的质数，也可以直接推断出这两个数。
超过50的最小的质数是53，所以，排除S > 57的所有可能，还剩下11，17 … 51, 53一共11组

3 孙膑说：现在我知道了
参考“组合数”这个表单，一共有169个组合数。
孙膑说知道了，就说明这样的组合数的积在表中只出现过一次：times = 1
这样的数有100个

4 庞涓说：那我也知道了
表明庞涓知道的这个和数，在所有的nm组合中，只能有1对的积出现过一次
就是对于一个S，只能有一个times = 1

这个和数是17，两个数分别是4 和 13

[程勉超]

S n m A Times
11 2 9 18 1
11 3 8 24 1
11 4 7 28 1
11 5 6 30 2
17 2 15 30 2
17 3 14 42 2
17 4 13 52 1 *
17 5 12 60 2
17 6 11 66 2
17 7 10 70 2
17 8 9 72 2
23 2 21 42 2
23 3 20 60 2
23 4 19 76 1
23 5 18 90 2
23 6 17 102 3
23 7 16 112 1
23 8 15 120 2
23 9 14 126 2
23 10 13 130 1
23 11 12 132 3
27 2 25 50 1
27 3 24 72 2
27 4 23 92 1
27 5 22 110 2
27 6 21 126 2
27 7 20 140 1
27 8 19 152 1
27 9 18 162 1
27 10 17 170 1
27 11 16 176 1
27 12 15 180 3
27 13 14 182 1
29 2 27 54 1
29 3 26 78 2
29 4 25 100 1
29 5 24 120 2
29 6 23 138 1
29 7 22 154 1
29 8 21 168 1
29 9 20 180 3
29 10 19 190 1
29 11 18 198 1
29 12 17 204 1
29 13 16 208 1
29 14 15 210 4
35 2 33 66 2
35 3 32 96 1
35 4 31 124 1
35 5 30 150 2
35 6 29 174 1
35 7 28 196 2
35 8 27 216 1
35 9 26 234 1
35 10 25 250 1
35 11 24 264 2
35 12 23 276 1
35 13 22 286 2
35 14 21 294 1
35 15 20 300 2
35 16 19 304 1
35 17 18 306 1
37 2 35 70 2
37 3 34 102 3
37 4 33 132 3
37 5 32 160 1
37 6 31 186 1
37 7 30 210 4
37 8 29 232 1
37 9 28 252 1
37 10 27 270 2
37 11 26 286 2
37 12 25 300 2
37 13 24 312 2
37 14 23 322 2
37 15 22 330 2
37 16 21 336 1
37 17 20 340 1
37 18 19 342 2
41 2 39 78 2
41 3 38 114 2
41 4 37 148 1
41 5 36 180 3
41 6 35 210 4
41 7 34 238 1
41 8 33 264 2
41 9 32 288 1
41 10 31 310 1
41 11 30 330 2
41 12 29 348 1
41 13 28 364 1
41 14 27 378 2
41 15 26 390 1
41 16 25 400 1
41 17 24 408 1
41 18 23 414 1
41 19 22 418 1
41 20 21 420 2
47 2 45 90 2
47 3 44 132 3
47 4 43 172 1
47 5 42 210 4
47 6 41 246 1
47 7 40 280 1
47 8 39 312 2
47 9 38 342 2
47 10 37 370 1
47 11 36 396 2
47 12 35 420 2
47 13 34 442 1
47 14 33 462 2
47 15 32 480 1
47 16 31 496 1
47 17 30 510 1
47 18 29 522 1
47 19 28 532 1
47 20 27 540 2
47 21 26 546 2
47 22 25 550 1
47 23 24 552 1
51 2 49 98 1
51 3 48 144 1
51 4 47 188 1
51 5 46 230 1
51 6 45 270 2
51 7 44 308 1
51 8 43 344 1
51 9 42 378 2
51 10 41 410 1
51 11 40 440 1
51 12 39 468 1
51 13 38 494 1
51 14 37 518 1
51 15 36 540 2
51 16 35 560 1
51 17 34 578 1
51 18 33 594 1
51 19 32 608 1
51 20 31 620 1
51 21 30 630 2
51 22 29 638 1
51 23 28 644 1
51 24 27 648 1
51 25 26 650 1
53 2 51 102 3
53 3 50 150 2
53 4 49 196 2
53 5 48 240 1
53 6 47 282 1
53 7 46 322 2
53 8 45 360 1
53 9 44 396 2
53 10 43 430 1
53 11 42 462 2
53 12 41 492 1
53 13 40 520 1
53 14 39 546 2
53 15 38 570 1
53 16 37 592 1
53 17 36 612 1
53 18 35 630 2
53 19 34 646 1
53 20 33 660 1
53 21 32 672 1
53 22 31 682 1
53 23 30 690 1
53 24 29 696 1
53 25 28 700 1
53 26 27 702 1