28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）

会的大神万望赐教！

1. class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int x = getBottles(28);
   
6.                 int y = getBottles(50);
   
7.                 System.out.println("28人："+x+"----50人："+y);
   
8.         }
   
9. 
   
10.         public static int getBottles(int num){ //定义一个获取瓶数的方法，接收人数
    
11.                 int caps = 0; //定义一个变量记录当前瓶盖数
    
12.                 int bots =0;  //定义一个变量记录当前的可乐数
    
13.                 if(num<=3)
    
14.                         return num;
    
15.                 for(int i=num/2; i<=num; i++){  //从人数的一半开始遍历
    
16.                         caps = i;
    
17.                         bots = i;
    
18.                         while(caps>=3){  //只要瓶盖数大于等于3就继续换
    
19.                                 bots = bots+caps/3;   //可乐数= 当前可乐数 + 瓶盖换的
    
20.                                 caps = caps/3+caps%3; //瓶盖数= 瓶盖换的可乐 + 换剩下的
    
21.                         }
    
22.                         if(bots>=num)
    
23.                                 return i;
    
24.                 }
    
25.                 return 0;
    
26.         }
    
27. }
    

复制代码

实际要买的可乐 = 总人数 - 总人数/4    (不算小数)

沙发。。。。。。

这是考递归的   while也能做，但是代码量大，而且不如递归给人的印象深.

1. public class Test {
   
2. /*
   
3. 需求:
   
4.         28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
   
5. 思路:
   
6.         一看这种题，有返回值，有尽头又不知道要循环多少次的事，除了while循环，优先想递归.
   
7.         getCola(num,cola)方法中，num是人数，cola是要买的可乐数.
   
8.         最开始，人数是28，可乐数是0.
   
9.         因为是递归，所以要写一个方法才能实现方法调用自身.
   
10.        
    
11.         当:num<=3时，也就是人数小于等3时，要买的可乐瓶数等人数，因为不能用3个瓶盖换.
    
12.         当:num>3时，就可以用瓶盖换.
    
13.                 这时考虑==>
    
14.                                 1、每3个瓶盖可以换1瓶可乐，相当于，当可乐数每+3，人数都能-4.
    
15.                                 2、可乐数就等于3加上剩余人数要买的可乐数.这句话用代码表示就是
    
16.                                 num = num-4;
    
17.                                 cola = 3+getCola(num,cola);
    
18.         将上述思路整合，即得出代码.
    
19.         50人同理.
    
20. */
    
21.         public static void main(String[] args) {
    
22.                 int num = 4;
    
23.                 int cola = getCola(num, 0);
    
24.                 System.out.println(num+"人要至少买"+cola+"瓶可乐");
    
25.         }
    
26. 
    
27.         private static int getCola(int num, int cola) {
    
28.                 if (num <= 3) {
    
29.                         cola = cola + num;
    
30.                         return cola;//这一句在num大于3的时候，每次递归都会调用到.
    
31.                 } else {
    
32.                         cola = 3 + getCola(num-4, cola);
    
33.                         return cola;//这一句return才是程序最后返回结果的那一句.
    
34.                 }
    
35.         }
    
36. }

复制代码

呃...num最开始应该是28，不是4    4是我测试时候用的..没改过来...

if语句里的return的注释写得有点问题，应该说，如果把整个cola=... 这个表达式展开，if里的return应该出现在最后 的位置;else里的return返回各项相加的和，也就是最终结果。
当然　　你按ｃｏｌａ　＝　ｃｏｌａ＋ｃｏｌａ／４；算也行　　但是这个不是计算机里的算法，是人脑的算法了

递归用的不错...

楼主，看我用while秒杀各位大神，哈哈......

1. package 入学测试;
   
2. /*
   
3. * 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，
   
4. * 那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
   
5. */
   
6. import java.util.*;
   
7. public class test_02Anvanced {
   
8. 
   
9.         public static void main(String[] args) {
   
10.                 // TODO Auto-generated method stub
    
11.                 List<String> list=new ArrayList<String>();
    
12.                 int people=28;     //在这里自定义人数
    
13.                 int num=0;//瓶盖子
    
14.                 int count=0;//我自己花钱买的可乐
    
15.                 int extra_coca = 0;//用瓶盖子换的可乐
    
16.                 while(list.size()<people)
    
17.                 {
    
18.                        
    
19.                         list.add("coca");
    
20.                        
    
21.                         count++;  //只要我花钱买了可乐，可乐+1，瓶盖子+1
    
22.                         num++;
    
23.                         System.out.print("买第"+count+"瓶可乐！");
    
24.                         if(num==3)//当瓶盖子达到三个是，集合中的可乐+1,但此时count并不+1,因为不是自己买的，是换的
    
25.                         {
    
26.                                 list.add("coca");
    
27.                                 num=1; //因为3个瓶盖子换了一瓶可乐后，立马会有一个盖子
    
28.                                 extra_coca++;
    
29.                                 System.out.println("哇!用三个盖子换了一瓶可乐，一共有"+list.size()+"瓶可乐了");
    
30.                         }
    
31.                         System.out.println("现在手上有"+num+"个盖子！");
    
32.                                
    
33.                 }
    
34.                 System.out.println("自己花钱买了"+count+"瓶可乐，用瓶盖子换了"+extra_coca+"瓶可乐！");
    
35.         }
    
36. 
    
37. }
    

复制代码

昨天也发了这道题给我.
我一开分析呢, 是从数据结构上来分析, 这是一棵完全三叉树.
但说实话, 二叉树的东西我都忘了不少, 所以也懒得去琢磨三叉树, 所以我换了个思路.
我喜欢用递归(递归本质是一个栈), 所以简单地用以下的几行代码简单解决:

1. public static int buyBeverageNum(int numPerson){
   
2.         if (numPerson<=3){
   
3.                 return numPerson;
   
4.         } else {
   
5.                 return 2 + buyBeverageNum(numPerson-3);
   
6.         }
   
7. }

复制代码

呵呵, 里头只有一个if--else--判断, 其它都没有. 代码量超少.:lol

其思路是:
如果是3个人或3个以下的人买, 那么有多少人就买多少瓶;
即使如果有3个人, 还会再奖一瓶, 但是这一瓶退不回也没人要, 这3个人仍然还是要消费3瓶.

如果是超过3个人买, 我们把人分成多个3人组;
那么最前买的那3个人, 买了3瓶, 但会奖一瓶, 他们可以把这一瓶卖给后面的人.
即, 实际上, 这3个人, 只花了2瓶的钱.
而接下来的一组, 其会向前一组买一瓶, 再向店家买两瓶, 店家会奖一瓶, 他们把这一瓶卖给后一组,
即, 这一组, 总共也只花了2瓶的钱.
这样一组一组如此进行下去, 直到最后一组.
不管最后一组有没有3个人, 总之不会超过3个人, 即, 有多少人就买多少瓶.


这是一个简单的思路. 代码还要完善下, 比如添加一些代码, 判断下参数的合法化, 比如如果参数小于0, 那抛出异常之类.

1. public static int coke(int peopleNumber) {
   
2.     int buyCoke = 0; // 定义一个变量来存储买的可乐数
   
3.     int bottle = 0; // 定义一个变量来存储已有瓶盖数
   
4. 
   
5.     for (int i = 1; i <= peopleNumber; i++) {
   
6.             if (bottle < 3) {   //当瓶盖小于3时 买的可乐和瓶盖都加1
   
7.                     buyCoke++;
   
8.                     bottle++;
   
9.             } else {
   
10.                     bottle = 1; //当瓶盖等于3时，因为兑换可乐，所以瓶盖加1
    
11.             }
    
12.     }
    
13.     return buyCoke;
    
14. }

复制代码

觉着这样比较简洁。

zz_job 发表于 2014-10-7 23:22
这是考递归的   while也能做，但是代码量大，而且不如递归给人的印象深.

很赞   

Huberry 发表于 2014-10-7 21:25

恩恩，谢谢大神！

zz_job 发表于 2014-10-7 23:22
这是考递归的   while也能做，但是代码量大，而且不如递归给人的印象深.

之前没有认真看递归，，，，谢谢！领教了！

hollywood2014 发表于 2014-10-8 01:45
楼主，看我用while秒杀各位大神，哈哈......

高手啊！哪一期的？？

只写思路吗？

杨佳名 发表于 2014-10-8 07:34
觉着这样比较简洁。

谢谢版主，明白了

caixingke 发表于 2014-10-8 01:57
昨天也发了这道题给我.
我一开分析呢, 是从数据结构上来分析, 这是一棵完全三叉树.
但说实话, 二叉树的东 ...

递归代码要简洁不少

public class ceshi {
        public static void main(String[] args) {
                int person = 3569;
                int i = 3;
                jisuan(person, i);
        }

        private static void jisuan(int person, int i) {

                if (person % (i + 1) == 0)
                        System.out.println(person / (i + 1) * 3);
                else
                        System.out.println(((int) person / (i + 1)) * 3 + person % (i + 1));
        }

}

不用递归也很简单4行代码解决，思路是：三瓶可以产生一瓶，所以把四瓶可乐看成一组，就是 人数/4 看看能否除尽， 除尽了，就用结果乘以3，就是要买的瓶数。
除不尽的话，拿商乘以3加上余数

现学现卖 4行代码解决问题