第1次上论坛，也是第一次发帖。如果发帖有什么不对、违反规则的地方，请大家尽管指正。
原题是这样：每3个瓶盖可以换一瓶可乐，要喝到28瓶可乐，需要购买多少瓶可乐？要喝50瓶呢？写出思考过程。
下面是我写的代码：
/*
需求：编写一个函数，使之计算出3个瓶盖可以换一瓶可乐的情况下，要喝m瓶可乐需要购买的可乐数。
实现：将瓶盖与可乐拆分，那么买一瓶可乐实际上是一瓶可乐加一个瓶盖，那么一个瓶盖即相当于1/2瓶可乐。使用while循环
          控制买的可乐瓶数进行遍历，使用if语句判断是否达到总共喝的瓶数；
          返回值为购买的瓶数，int型，参数类型为瓶盖数和喝的瓶数；
*/

public class Cola
{
        public static int getNum(int m)
        {
                //初始化购买数为0
                int x=0;
                while(x<m)
                {
                        //判断购买的可乐及瓶盖是否达到要喝的数量
                        if(x+x/2>=m)
                                break;
                        else
                                x++;
                }
                //返回购买的可乐瓶数
                return x;
        }
        public static void main(String[] args)
        {
                //验证代码是否正确，遍历下1-50
                for(int x=1;x<=50;x++)
                {
                        System.out.println("要喝"+x+"瓶,"+"需要买"+getNum(x)+"瓶");
                }
        }
}


上述代码可能有点问题就是假设要喝3瓶可乐的话，只需要购买2瓶就够了（就是跟老板再借一瓶可乐，凑齐三个瓶盖，换取一瓶可乐，再还给老板），想问问大家，这题允许跟老板借可乐吗？{:2_33:}

DD_vincent 发表于 2015-9-25 23:47
其实你这个问题挺没劲的。因为这本来就是考察你如何用代码来实现的问题。
而不论是那种情况，都可以用代 ...

你说的是真理 {:2_35:}，多谢提醒

1. class Cola
   
2. {
   
3.         //练习单例设计模式，不用管
   
4.         private Cola(){}
   
5.         //非静态成员变量，表示想要喝到的可乐数
   
6.         private int colanum;
   
7.         //非静态成员变量，表示该商店的老板是否愿意借可乐
   
8.         private boolean boss;
   
9.         //静态成员变量，需要购买的可乐数
   
10.         private static int buynum=0;
    
11.         //静态成员变量，表示瓶盖数
    
12.         private static int capnum=0;
    
13.         //静态成员变量，表示购买的可乐数相对应能喝到的可乐数
    
14.         private static int truenum=0;
    
15.         //练习单例设计模式，不用管
    
16.         private static Cola cola=new Cola();
    
17.         //练习单例设计模式，不用管
    
18.         public static Cola getInstance()
    
19.         {
    
20.                 return cola;
    
21.         }
    
22.         //获取想要喝的可乐数
    
23.         public int getColanum()
    
24.         {
    
25.                 return colanum;
    
26.         }
    
27.         //设置想要喝的可乐数
    
28.         public void setColanum(int colanum)
    
29.         {
    
30.                 this.colanum=colanum;
    
31.         }
    
32.         //设置老板人品，true表示老板人品好，愿意借可乐，false表示老板小气，不愿意借可乐
    
33.         public void setBoss(boolean boss)
    
34.         {
    
35.                 this.boss=boss;
    
36.         }
    
37.         public String getBuynum()
    
38.         {
    
39.                 //1瓶一瓶地买，直到达到想要喝的数量为止
    
40.                 while(truenum<colanum)
    
41.                 {       
    
42.                         //买可乐
    
43.                         buynum++;
    
44.                         //每买一瓶，能喝的可乐就多一瓶
    
45.                         truenum++;
    
46.                         //买一瓶就多一个盖
    
47.                         capnum++;
    
48.                         //老板不肯借可乐，事实上，如果老板答应可以退可乐的话，答案与能借是一样的，喝3瓶得买3瓶，换1瓶，总共4瓶，退货1瓶，结果就相当于买2瓶可以喝3瓶
    
49.                         if(boss==false)
    
50.                         {
    
51.                                 //判断盖子数是否达到可以换到1瓶，并且如果之前买了后还没达到要喝的数目，就换可乐
    
52.                                 if(capnum%3==0 && truenum<colanum)
    
53.                                 {
    
54.                                         //换可乐
    
55.                                         truenum++;
    
56.                                         //盖子换可乐了就没了，但是换过来的一瓶可乐也有1个盖，因此又有一个盖子了
    
57.                                         capnum=1;
    
58.                                 }
    
59.                         }
    
60.                         //老板肯借可乐
    
61.                         else
    
62.                         {
    
63.                                 //判断盖子数是否达到借一瓶可乐就能再换一瓶，并且如果之前买了后还没达到要喝的数目，就借可乐
    
64.                                 if(capnum%2==0 && truenum<colanum)
    
65.                                 {
    
66.                                         //借了老板1瓶可乐，因此多了一瓶可乐
    
67.                                         truenum++;
    
68.                                         //多的1瓶又产生了1个盖
    
69.                                         capnum++;
    
70.                                         //3个盖子又换来一瓶可乐
    
71.                                         truenum++;
    
72.                                         //换了可乐盖子就没了
    
73.                                         capnum=0;
    
74.                                         //还给老板一瓶可乐
    
75.                                         truenum--;
    
76.                                 }
    
77.                         }
    
78.                 }
    
79.                 if(colanum>=0)
    
80.                         return "想要喝到"+colanum+"瓶，"+"需要购买"+buynum+"瓶，"+"剩余"+capnum+"个瓶盖";
    
81.                 else
    
82.                         return "请检查您想要喝的可乐数，不能为负数！";
    
83.         }
    
84. 
    
85. 
    
86. }
    
87. class ColaDemo
    
88. {
    
89.         public static void main(String[] args)
    
90.         {
    
91.                 Cola cola=Cola.getInstance();
    
92.                 cola.setColanum(28);
    
93.                 cola.setBoss(false);
    
94.                 String a=cola.getBuynum();
    
95.                 System.out.println(a);
    
96. 
    
97.         }
    
98. }

复制代码

罗志辉 发表于 2015-9-25 21:55
请大家关注重点：如果给你两个瓶盖，能不能换回一瓶可乐？

其实你这个问题挺没劲的。因为这本来就是考察你如何用代码来实现的问题。
而不论是那种情况，都可以用代码来实现。你有空考虑这些旁枝末节的东西，不如把两种思路都写出来。

请大家关注重点：如果给你两个瓶盖，能不能换回一瓶可乐？

/*
* 28 人买可乐喝，3 个可乐瓶盖可以换一瓶可乐
* 28 人买可乐喝，3 个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够 28 人喝？假如是
* 50 人，又需要买多少瓶可乐？
*
* 分析思路：
* 要买够多少人喝，先一瓶一瓶的买，边买边换，直到可乐总数满足所有人喝为止
* 可以设可乐总数为 sum，购买的瓶数用 count 来计数
* 每购买一瓶 count 自加一，可乐总数 sum 也加一
* 可乐总数 sum 达到三的倍数时，就可以用瓶盖再换一瓶，即总数 sum 加一
* 按以上规律做一个循环，当可乐总数 sum 满足所有人需要时跳出循环，此时的
* count 值即为需要购买的瓶数
* */
/*
public class MianShi {
        public static void main(String[] args) {
                //定义人数
                int ren = 28;
                //调用方法
                System.out.println(pingShu(ren));
        }
        //定义方法
        public static int pingShu(int ren){
                //设置可乐总数
                int sum =0;
                //购买的可乐数
                int count = 0;
                //只要可乐总数小于人数
                while(sum<ren){
                        //那就购买
                        count++;
                        //总数也自增
                        sum++;
                        //如果能被3整除就赠送一瓶
                        if(sum%3==0){
                                //总数就自增
                                sum++;
                        }
                }
                //返回购买的瓶数
                return count;
        }
}


*/

罗志辉 发表于 2015-9-25 18:57
三个瓶盖换的一瓶可乐里其实包含了一个瓶盖，你可以理解为两个瓶盖可以换一瓶没有盖子的可乐，所以才有一 ...

也是啊,没想到这一点,你想的很细

舒玉琛 发表于 2015-9-25 00:14
可乐的算法，我觉得比你的算法更准确

唯一的区别是当剩下两个瓶盖时，你的代码是直接忽略。我的代码是借老板1瓶可乐，喝了凑齐3个盖子换一瓶可乐还给老板

DD_vincent 发表于 2015-9-24 18:46
楼主，我只能说你太有想法了！
如果可以借的话。那这题就太简单了，只要除以三乘二就行了！因为每次都可以 ...

怎么不允许借了，老板又没吃亏，借你1瓶，马上又还你1瓶

任振铭 发表于 2015-9-24 22:04
既然三个瓶盖可以换一瓶瓶可乐,那你怎么可以说1个瓶盖相当于1/2瓶可乐呢,应该是1/3吧,这样一来,花3瓶可乐的 ...

三个瓶盖换的一瓶可乐里其实包含了一个瓶盖，你可以理解为两个瓶盖可以换一瓶没有盖子的可乐，所以才有一个瓶盖相当于1/2瓶可乐

既然是写代码，那就必然要在机器上运行，是机器的话，那你借指定是不行了。如果m比3大，除了第一次需要买3瓶得到一个瓶盖，以后只需买2瓶就可以了，(m-3)/3*2+(m-3)%3+3,还有一个事就是当你想喝3平时，你会发现你买3瓶能喝到4瓶，但你买2瓶你只能喝到2瓶，想喝三瓶只能买三瓶，多的一瓶你可以不喝。
但是我感觉我上面这位同学说的对
他是这样写的
/*每3个瓶盖可以换一瓶可乐，要喝到28瓶可乐，需要购买多少瓶可乐？要喝50瓶呢？写出思考过程。
思路        1        设定变量bottle初始值为1，记录瓶数
                2        建立while循环
                3        每次循环bottle+1，每当循环次数i/3=0时bottle++
                4        循环到bottle=bottle0时为止*/
package exercise03;

public class CokeNum {
        public static int cokeNum(int bottle0) {
                int bottle = 1;
                int buyNum = 1;
                while (bottle < bottle0) {
                        buyNum++;
                        bottle++;
                        if (bottle % 3 == 0) {
                                bottle++;
                        }
                }
                return buyNum;

        }
}

1. /*每3个瓶盖可以换一瓶可乐，要喝到28瓶可乐，需要购买多少瓶可乐？要喝50瓶呢？写出思考过程。
   
2. 思路        1        设定变量bottle初始值为1，记录瓶数
   
3.                 2        建立while循环
   
4.                 3        每次循环bottle+1，每当循环次数i/3=0时bottle++
   
5.                 4        循环到bottle=bottle0时为止*/
   
6. package exercise03;
   
7. 
   
8. public class CokeNum {
   
9.         public static int cokeNum(int bottle0) {
   
10.                 int bottle = 1;
    
11.                 int buyNum = 1;
    
12.                 while (bottle < bottle0) {
    
13.                         buyNum++;
    
14.                         bottle++;
    
15.                         if (bottle % 3 == 0) {
    
16.                                 bottle++;
    
17.                         }
    
18.                 }
    
19.                 return buyNum;
    
20. 
    
21.         }
    
22. }
    

复制代码

可乐的算法，我觉得比你的算法更准确

学习了 。。。

肯定不可以借老板的可乐，

题收藏 了  我也想想。。。。

既然三个瓶盖可以换一瓶瓶可乐,那你怎么可以说1个瓶盖相当于1/2瓶可乐呢,应该是1/3吧,这样一来,花3瓶可乐的钱就可以得到四瓶可乐,也就是说,如果你要喝m瓶可乐,只需要花m*(3/4)的钱就行了,如果假设喝m瓶可乐需要买n瓶可乐,那么m和n的关系就是m=n*三分之四,用while循环条件语句写作while((4/3)*x)<m就可以了,

路过,顶一下

哪个的对的???

public class mianshiT {
        public static void main(String[] args) {
                int cishu=28;
                int c=kele(cishu);
                System.out.println(c);
        }
        public static int kele(int cishu) {
                int c=0;
                int huan=0;
                int counts=0;
                while(c!=cishu){
                        c++;
                        huan++;
                        counts++;
                        if(c==cishu){
                                break;
                        }
                        if(huan==3){
                                c++;
                                huan=1;
                        }
                }
                return counts;
        }
}
不知道自己写的对不对...求大神指点一二

楼主，我只能说你太有想法了！
如果可以借的话。那这题就太简单了，只要除以三乘二就行了！因为每次都可以借！这样比买三得四要实惠多了！

/**先思考一下
* 当购买超过3瓶以后  
* 每次总瓶数加3实际 只用购2瓶
* 所以
* 购买瓶数   ((sum-3)/3)*2+(sum%3)
  */


public class Color {

        public static void main(String[] args) {
                        buy(50);
                }
         static void buy(int sum){
                int buy;
                if(sum<=3)
                        buy=sum;
                else
                buy=((sum-3)/3)*2+(sum%3)+3;
                System.out.println(buy);
                        }
}
面试题有这么简单的？？

没人回，自顶