//我很菜，做错后又从新思考了个方法，但是还有问题，源草稿就不写了，整理了下草稿
public class houzi2 {
        public static void main(String[] args)
        {
                for(int x=1;x<999;x++)
                {
                        double sum=5*x+1;
/*
第五个猴子拿走了x+1，剩下4x个，算作第四个猴子拿剩下的第五个猴子醒来看到的所有桃子数量sum就是5x+1
那么第四个猴子醒来看到多少呢？依次类推，第一个醒来看到的是多少呢？
*/
                        for(int i=4;i>=1;i--)
                        {
                                sum=sum/4*5+1;
                        }
                        if(sum==(int)(sum))
                        System.out.println(sum);
                }
        }
}
//个人疑惑，怎样找出最小的就立即结束循环，break；貌似结束的不对

新代码解惑
public class houzi2 {
public static void main(String[] args)
{
  a:for(int x=1;x<999;x++)
  {
   double sum=5*x+1;
   b:for(int i=4;i>=1;i--)
   {
    sum=sum/4*5+1;
   }
   if(sum==(int)(sum))
   {
   System.out.println(sum);
   break a;//给for标记，用break跳出相应的标记
   }
  }
}
}

刚好回答了那个问题，改一改就是你这个了...恩。。。

补充：：：哎哟 。刚没细看你的程序内容，。。。看完后你的思路方法比我下面这个好。。我也以为你那个break就可以，恩，我再思考思考。。。。

1. package com.ggstudy.ddup;
   
2. 
   
3. class Hello2014 {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                   //定义一个变量sum，来记录桃子的总数（假定桃子数量在10000以内）；
   
7.                   int temp;//要定义一个临时变量赋值。
   
8.                   for (int sum = 0;sum <= 10000 ;sum++ )
   
9.                   {
   
10.                      temp=sum;//这一步是关键
    
11.                      if ((temp - 1) % 5 == 0) {
    
12.                            temp= (temp - 1) / 5*4;
    
13.                            if ((temp - 1) % 5 == 0) {
    
14.                                    temp= (temp - 1) / 5*4;
    
15.                                            if ((temp - 1) % 5 == 0) {
    
16.                                                    temp= (temp - 1) / 5*4;
    
17.                                                    if ((temp - 1) % 5 == 0) {
    
18.                                                            temp= (temp - 1) / 5*4;
    
19.                                                            if ((temp - 1) % 5 == 0) {
    
20.                                                                    temp= (temp - 1) / 5*4;
    
21.                                                                    System.out.println("sum = "+sum);
    
22.                                                                    break;//只要找到就跳出！
    
23.                                                            }
    
24.                                                    }
    
25.                                            }
    
26.                            }
    
27.                      }
    
28.                   }
    
29. 
    
30.                 }
    
31. }
    
32. 
    

复制代码

你是不是说错了呢，应该是第一个猴子看到最多，第五个猴子最少，第一个猴子是5X+1，第二个猴子4X，第三个猴子(4X-1)*4/5，第四个猴子（(4X-1)*4/5-1）4/5，第五个猴子((（(4X-1)*4/5-1）4/5)-1)*4/5

先用上面的2楼的方法算出总数，然后for(int i=1;i<=5;i++)
                         {
                                 sum=(sum-1)*4/5
                         } i的大小就是第几个猴子，sum多少就是猴子看到的多少

可以结束了？

布鲁Go 发表于 2013-12-30 22:24
刚好回答了那个问题，改一改就是你这个了...恩。。。

补充：：：哎哟 。刚没细看你的程序内容，。。。看完 ...

恩 ，其实是一样的。。代码如下。忘了if的作用范围。。。实话实说，你的这个代码思路比较好，比原来的思路简练，原来的是惯性思维，你这个把int 强转，我觉得很牛逼。我那下想了很久都没想到，还一直往复杂的递归去想。

1. class Hello2014 {        
   
2.                   public static void main(String[] args)
   
3.                 {
   
4.                         for(int x=1;x<999;x++)
   
5.                         {
   
6.                               
   
7.         /*
   
8.         第五个猴子拿走了x+1，剩下4x个，算作第四个猴子拿剩下的第五个猴子醒来看到的所有桃子数量sum就是5x+1
   
9.         那么第四个猴子醒来看到多少呢？依次类推，第一个醒来看到的是多少呢？
   
10.         */                                                double sum=5*x+1;
    
11.                                 for(int i=4;i>=1;i--)
    
12.                                 {
    
13.                                         sum=sum/4*5+1;
    
14.                                 }
    
15.                                 if(sum==(int)(sum))
    
16.                                 {
    
17.                                         System.out.println(sum);
    
18.                                         break;//就是这里了。。
    
19.                                 }
    
20.                                 
    
21.                                 
    
22.                               
    
23.                         }
    
24.                 }
    
25.         }

复制代码

问桃子总数最少有多少个？

没看清题意？
第五个猴子就是6个 哪里还用什么x    费那个脑子  

往前推就行了

//个人疑惑，怎样找出最小的就立即结束循环，break；貌似结束的不对

针对这个问题还是不难的，就是把获取满足条件的桃子封装成一个int返回值类型的方法就可以了，参考代码如下：

1. //循环算法:
   
2.     public static int getNumber(int num)
   
3.     {
   
4.             int tem;
   
5.              int count = 0;
   
6.                 for (int sum=0;sum <num ;sum++) {
   
7.                         tem=sum;
   
8.                            if ((tem - 1) % 5 == 0) {
   
9.                             tem = (tem - 1) / 5*4;
   
10.                             if ((tem - 1) % 5 == 0) {
    
11.                              tem = (tem - 1) / 5*4;
    
12.                              if ((tem - 1) % 5 == 0) {
    
13.                               tem = (tem - 1) / 5*4;
    
14.                               if ((tem - 1) % 5 == 0) {
    
15.                                tem = (tem - 1) / 5*4;
    
16.                                if ((tem - 1) % 5 == 0) {
    
17.                                 tem = (tem - 1) / 5*4;
    
18.                                
    
19.                                        return sum;
    
20.                                }
    
21.                               }
    
22.                              }
    
23.                             }
    
24.                            }
    
25.                           }
    
26.                 return Integer.parseInt("1");
    
27.     }

复制代码

然后再主函数中调用即可。
此题也可采用递归的方法，求出最少分桃数，桃子总数减一刚好够分给5个猴子和分配次数小于等于猴子数
同时满足则可获取最少分配的桃子数。

1. //递归算法i:
   
2.             static int ts=0;//桃子总数
   
3.     int fs=1;//记录分的次数
   
4.     static int hs=5;//猴子数...
   
5.     int tsscope=5000;//桃子数的取值范围.太大容易溢出.
   
6.     public int fT(int t){
   
7.     if(t==tsscope){
   
8.     //设置递归边界条件，即当桃子数到了最大的取值范围时取消递归
   
9.     System.out.println("结束");
   
10.     return 0;
    
11.     }
    
12.     else{
    
13.     if((t-1)%hs==0 && fs <=hs){
    
14.     if(fs==hs)
    
15.     {
    
16.     System.out.println("桃子数 = "+ts +" 时满足分桃条件");
    
17.     }
    
18.        fs+=1;
    
19.        return fT((t-1)/5*4);// 返回猴子拿走一份后的剩下的总数
    
20.     }
    
21.     else
    
22.     {
    
23.     //没满足条件
    
24.     fs=1;//分的次数重置为1
    
25.     ts++;
    
26.     return fT(ts);//桃子数加+1
    
27.     }
    
28.     }
    
29.     }

复制代码

75100313 发表于 2013-12-30 22:52
问桃子总数最少有多少个？

没看清题意？

每个猴子拿到的桃子必须是整数，第五个猴子醒来后看到6个桃子那么前面猴子分不了整形的桃子了。

布鲁Go 发表于 2013-12-30 22:47
恩 ，其实是一样的。。代码如下。忘了if的作用范围。。。实话实说，你的这个代码思路比较好，比原来的思路 ...

哈哈，我只是觉得他那么做太麻烦，写数学类代码不是先考虑最优算法再编程么-。-，其实是昨天晚上写了好多代码做这个题，包括每个猴子分多少个，我写个个6元素数组，然后打算把数组每个元素都是整数也判断的，最后精简到很少的代码。最后头晕眼花的去给他回复发现别人先给他解决问题了，我顺手把我的小疑惑也贴上睡觉去了

daoyua 发表于 2013-12-30 22:36
你是不是说错了呢，应该是第一个猴子看到最多，第五个猴子最少，第一个猴子是5X+1，第二个猴子4X，第三个猴 ...

这个思路要保证的是每个猴子都分到的是整数个数的桃子，当然是从最小的数量就是整形来考虑的了。