vaqh 发表于 2014-8-1 17:36
都是，，这个才叫简单明了，而且有逻辑

哥们、、、那个不对、、、、我后来我发现错误了。那每考虑兑换后的可乐仍有瓶盖的情况

LFW 发表于 2014-8-1 17:45
哥们、、、那个不对、、、、我后来我发现错误了。那每考虑兑换后的可乐仍有瓶盖的情况 ...

是哦，，，

hejinzhong 发表于 2014-7-31 18:51
开始的17，我算错了，
应该是 (28/3)*2+28%3 =19        （9x2+1）
你试试19

我来总结一下吧，撇开楼主的代码，因为太长不看，综合帖子里出现的其他两种算法
1.     (50/4)*3+50%4    这算法有失误，我之前也被迷住了，因为没考虑到当换了3次之后又可以换的问题
2.     （50/3）*2+50%3  这算法……表面上是对的，但是，某些情况下，就不符合现实世界的逻辑，现假设12个人喝水，这个算法算出来是需要8瓶，3+3+2 ,可以再换3瓶，然后剩两个瓶盖，所以最终结果是11瓶余两个瓶盖，但是 现实世界里，你能拿剩下的两个瓶盖去换一瓶水吗？能的话刚刚好够喝，但是不能！规则是必须3瓶才能换，对你来说可能没差别，因为你再买了一瓶够3瓶，又可以换一瓶，但是对老板来说不一样，差别是他多卖出了一瓶，而你也不能说这瓶是免费的，因为你不能把3个瓶盖又换出来的最后一瓶退给老板，所以遵循现实世界的逻辑才符合题目要求，而不是遵循算法，编程的目的也是为了解决现实生活中的问题，帖子里也很多朋友贴出逻辑的代码了，当然这只是个人见解，详细注释并且复贴一下：

1. class BuyWater
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 person(51);
   
6.         }
   
7. 
   
8.    public static void person(int person)
   
9.     {
   
10.    
    
11.        int bottle = 0; //瓶子数目
    
12.            int cap = 0;    //瓶盖数目
    
13.        int count = 0;  // 购买次数，代表每增加一，就买了一瓶水，也是最终
    
14.                            //也就是最终需要购买的瓶数
    
15. 
    
16.     while (bottle<person) //瓶数比人数少就买水
    
17.     {  
    
18.             count++;          //买了一瓶
    
19.                 cap++;            //多了个瓶盖
    
20.                 bottle++;         // 瓶子数增加
    
21.                 if (cap==3)       //大优惠，三换一（不能2换一哦，想得美）
    
22.                 {   
    
23.                         cap = 0;     //瓶盖没了
    
24.                         bottle++;    //换到了一瓶
    
25.                         cap = 1;     //得了个瓶盖
    
26.                        
    
27.                 }
    
28.     }
    
29.         System.out.println(count); //最终买了count 瓶
    
30. 
    
31.    }
    
32. 
    
33. }
    

复制代码

hejinzhong 发表于 2014-7-31 18:20
你想下，当2个人买了之后，第3个人就手握2盖子，当他喝完一瓶，不就3盖子了，还用付钱吗！可以说是先消费 ...

实际中会么

blz01003hm 发表于 2014-7-31 18:59
啊，我的是 92列
public static void main(String[] args) {
        // TODO Auto-generated method stu ...

我试了下，是92

楼主的方法很刁。。。。。

hejinzhong 发表于 2014-8-2 06:02
我试了下，是92

自己想的时候，就是没想到用布尔型数组。

这个好像也是蓝桥杯的考试题

hejinzhong 发表于 2014-7-31 06:15
（1）如果只要有盖子就可以换，那就是这样来写
2个人先买2瓶，将盖子给第3人，第三人即可免费喝一瓶了（先 ...

好想法！

还是楼主代码简单 佩服佩服！！

dispensable 发表于 2014-8-2 01:59
我来总结一下吧，撇开楼主的代码，因为太长不看，综合帖子里出现的其他两种算法
1.     (50/4)*3+50%4    ...

if (cap==3)       //大优惠，三换一（不能2换一哦，想得美）
                {   
                        cap = 0;     //瓶盖没了
                        bottle++;    //换到了一瓶
                        cap = 1;     //得了个瓶盖
                        
                }》》》》3盖换一瓶时，那瓶可乐直接就有了盖了，我个人觉得cap=0那一句话可以不写，感觉赘余

裤裆里的温柔、 发表于 2014-8-1 14:51
不用搞这么麻烦，10行代码足矣，只测试了28和50通过，其他没试

是你英文太好还是我英语太菜，我看不懂你写的。。。

厉害啊！

357016138 发表于 2014-7-31 01:41
还是楼主代码简单 佩服佩服！！

有问题！

楼主你只是从宏观上考虑到瓶盖守恒，但是必须是3个瓶盖才能换一瓶可乐的，还有一种说法：一个瓶身等于2个瓶盖也是错的，假如我有10个瓶盖，难道可以换5瓶？？？？？


int sum = 0; //需要的可乐数
int i =  0; //手中的盖子数
int j = 0;  //买的可乐数
while (sum<28)
{
        sum++;
        i++;
        j++;
        if (i%3==0)  //3个瓶盖换一瓶可乐，可乐数加1，剩下一个瓶盖
        {
                sum++;
                i=1;
        }
}

LFW 发表于 2014-8-2 16:48
是你英文太好还是我英语太菜，我看不懂你写的。。。

again是再买的次数，buy是买的次数，bottle是瓶数，buy=1就是换了一瓶，。每次换完1瓶只需要再买2瓶就可以换一瓶，就是不停的+2,最后求出刚开始买的3瓶+每次再买的2瓶，是这个思路

class Test
{
        public static void main(String[] args)
        {
                System.out.println(getNum(28));
                System.out.println(getNum(50));
        }
        public static int getNum(int num)
        {
                int cola=0,gai=0,mai=0;//cola为可乐总数，gai为瓶盖数，mai为买的可乐数
                while(cola<num)
                {
                        if(gai==3) 如果瓶盖是3，则换成一个可乐，还剩一个瓶盖，因此可乐数加一，瓶盖变成1
                        {
                                cola++;
                                gai=1;
                        }
                        else
                        {
                                ++mai;
                                ++gai;
                                ++cola;
                        }
                }
                return mai;
        }
}

开始也认为 (50/4)*3+50%4这个简单明了，细想确实忽略了赠送的瓶盖子。
但是按照这个思路，更改了一下代码。
比较dispensable的代码简化了一些，但是阅读可能差一点。结果都是一致的。

1. class BuyWater {
   
2. 
   
3.         public static void main(String[] args) {
   
4. 
   
5.                 getBottle(51);
   
6. 
   
7.         }
   
8. /*
   
9. * 以16人为例，其它人数的结构是一样的。
   
10. * 人数：     1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16
    
11. * 买是1：    1  1  1  0  1  1  0  1  1  0   1   1   0   1   1   0
    
12. * 0处表示送了一瓶，并且多了一个盖子。
    
13. *
    
14. * 思路：
    
15. * 按上图规律即除去第一个人，每3人可抱团。除去第1个人，每3个人需要买2瓶，不满3人自己买。
    
16. * 那么p=人数,bottle= 需要购买的瓶数
    
17. * bottle=((p-1)/3)*2+(p-1)%3+1
    
18. *
    
19. * 相比较dispensable的代码简化了一些，但是阅读可能差一点。
    
20. * */
    
21.         public static void getBottle(int p)
    
22.         {
    
23.                 int bottle;
    
24.                 bottle=((p-1)/3)*2+(p-1)%3+1;
    
25.                 System.out.println(bottle);
    
26.         }
    
27. 
    
28. }
    

复制代码

OH NO................................................................................................。。。。。。。。。。。。。

OH NO................................................................................................。。。。。。。。。。。。。