28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写
出分析思路）
入学测试领到的题，2种解题思路分享！

1. <p><p>public class Test10 {</p><p> public static void main(String[] args) {
   
2.   int person=28;
   
3.   int person2=50;
   
4.   
   
5.   getBottleOne(person);
   
6.   getBottleOne(person2);
   
7.   getBottleTwo(person);
   
8.   getBottleTwo(person2);
   
9. }
   
10. /*
    
11.   * 方法二：
    
12.   * 思路2：
    
13.   * 先将瓶盖初始为0
    
14.   * 每增加1人，判断有几个瓶盖，不满3个就买一瓶，然后瓶盖设为自己手上的一个瓶盖
    
15.   * 有3个瓶盖则不用买，换一瓶，再加一个瓶盖。
    
16.   *
    
17.   * */
    
18. private static void getBottleTwo(int person) {
    
19.   int buyBottle=0;//瓶
    
20.   int cap=0;//瓶盖
    
21.   for (int i = 1; i <=person; i++) {
    
22.    //每增加1人判断一次瓶盖的数量，如果瓶盖少于3个，则需要买一瓶,buyBottle++;
    
23.    if(cap<3){
    
24.     //买一瓶，多一瓶盖
    
25.     buyBottle++;
    
26.     cap++;        
    
27.     continue;   
    
28.    }
    
29.    //如果有3个瓶盖则不用买，换到一瓶，还多一个瓶盖
    
30.    if(cap==3){
    
31.     cap=1;
    
32.    }  
    
33.   }
    
34.   System.out.println("方法二:"+person+"个人需要买"+buyBottle+"瓶可乐");
    
35. }</p><p></p><p> </p><p> /*方法一：
    
36. * 以16人为例，增加人数的结构也是一样的。
    
37. * 人数：     1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16
    
38. * 买是1：    1  1  1  0  1  1  0  1  1  0   1   1   0   1   1   0
    
39. * 0是表示3个瓶盖换了一瓶，并且多了一个盖子。
    
40. *
    
41. * 思路1：
    
42. * 按上图规律即除去第一个人，后面都是每3人只需买2瓶，即3个人为一组，不满3人自己买。
    
43. * 那么person=人数,buyBottle= 需要购买的瓶数
    
44. * bottle=((person-1)/3)*2+(p-1)%3+1
    
45. */
    
46. public static void getBottleOne(int person)
    
47.     {
    
48.             int buyBottle;
    
49.             buyBottle=((person-1)/3)*2+(person-1)%3+1;
    
50.             System.out.println("方法一:"+person+"个人需要买"+buyBottle+"瓶可乐");
    
51.     }
    
52. }
    
53. 
    
54. </p><p> </p></p>

复制代码

不错哦！:D

多谢分享。。。

多谢分享。

多谢，学习了

谢谢分享呀

楼主不错！

1. package entrenceTest;
   
2. /*
   
3. * 一瓶可乐可以包含一个瓶盖
   
4. */
   
5. public class Coke {
   
6. 
   
7.         CokeCap cap=new CokeCap();//1瓶可乐产生一个瓶盖               
   
8. }
   
9. package entrenceTest;
   
10. 
    
11. import java.util.ArrayList;
    
12. import java.util.List;
    
13. 
    
14. public class CokeCap {
    
15. 
    
16.         List<Integer> capTotal=new ArrayList<Integer>();
    
17. 
    
18.         public boolean changeCap(){
    
19.                 //每3瓶可乐可收集到3个瓶盖，可以换1瓶可乐，得到1个瓶盖
    
20.                 if(capTotal.size()==3)
    
21.                 {
    
22.                         System.out.println("哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！");
    
23.                         capTotal.clear();//3个瓶盖换了一瓶可乐后，3个瓶盖就没有了
    
24.                         System.out.println("-----换来的可乐又得到了一个瓶盖，真棒！------");
    
25.                         capTotal.add(1);//3个瓶盖换完后可以得到1个瓶盖                       
    
26.                         return true;
    
27.                 }
    
28.                 return false;       
    
29.         }
    
30.        
    
31.         public int receiveCap(){       
    
32.                 capTotal.add(1);       
    
33.                 return capTotal.size();//返回已有的瓶盖数量
    
34.         }       
    
35. }
    
36. package entrenceTest;
    
37. 
    
38. public class Person {
    
39. 
    
40.         private int personNum;
    
41.         Coke coke=new Coke();
    
42.        
    
43.         //设置需要可乐的人数
    
44.         public void setNum(int personNum){
    
45.                 this.personNum=personNum;
    
46.                 System.out.println("人数="+personNum);
    
47.         }
    
48.        
    
49.         //获取需要可乐的人数
    
50.         public int getNum(){
    
51.                 return personNum;
    
52.         }
    
53.        
    
54.         /*
    
55.          * 开始买可乐，
    
56.          */
    
57.         public void buyCoke(){
    
58. 
    
59.                 int buyCokeNum=0;        //表示买可乐的数量
    
60.                 int i=1;
    
61.                 int changeNum=0;         //表示用瓶盖换到的可乐的数量
    
62.                 for(i=1;i<=this.getNum();i++){
    
63.                         buyCokeNum++;
    
64.                         System.out.println("第"+i+"个人买了1瓶可乐，现共有"+(buyCokeNum+changeNum)+"瓶可乐");
    
65.                        
    
66.                         coke.cap.receiveCap();
    
67.                         //如果兑换了一瓶可乐，则下个人不用买可乐了
    
68.                         if(coke.cap.changeCap())
    
69.                         {
    
70.                                 i++;        //如果换了一次可乐，下一个人就不用买可乐了，跳过他
    
71.                                 System.out.println("-----第"+i+"个人拿到换来的可乐，不用买了-----");
    
72.                                 changeNum++;  
    
73.                         }
    
74. 
    
75.                 }
    
76.                
    
77.                 System.out.println("综上，需要买"+buyCokeNum+"瓶可乐，"+"需要换"+changeNum+"瓶可乐，剩"+coke.cap.capTotal.size()+"个瓶盖");
    
78.                
    
79.                
    
80.         }
    
81. }
    
82. package entrenceTest;
    
83. /*
    
84. * 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写 出分析思路）
    
85. */
    
86. public class MainClass {
    
87. 
    
88.         public static void main(String[] args) {
    
89.                 // TODO Auto-generated method stub
    
90.                 Person p=new Person();
    
91.                 p.setNum(50);//设置需要可乐的人数
    
92. //                System.out.println(p.getNum());
    
93.                 p.buyCoke();//调用buyCoke()方法，将得出需买几瓶可乐，需换几瓶可乐，还剩几个瓶盖的结果
    
94.         }
    
95. }

复制代码

shuimu_88 发表于 2014-9-10 13:31

输出结果为：
人数=50
第1个人买了1瓶可乐，现共有1瓶可乐
第2个人买了1瓶可乐，现共有2瓶可乐
第3个人买了1瓶可乐，现共有3瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第4个人拿到换来的可乐，不用买了-----
第5个人买了1瓶可乐，现共有5瓶可乐
第6个人买了1瓶可乐，现共有6瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第7个人拿到换来的可乐，不用买了-----
第8个人买了1瓶可乐，现共有8瓶可乐
第9个人买了1瓶可乐，现共有9瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第10个人拿到换来的可乐，不用买了-----
第11个人买了1瓶可乐，现共有11瓶可乐
第12个人买了1瓶可乐，现共有12瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第13个人拿到换来的可乐，不用买了-----
第14个人买了1瓶可乐，现共有14瓶可乐
第15个人买了1瓶可乐，现共有15瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第16个人拿到换来的可乐，不用买了-----
第17个人买了1瓶可乐，现共有17瓶可乐
第18个人买了1瓶可乐，现共有18瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第19个人拿到换来的可乐，不用买了-----
第20个人买了1瓶可乐，现共有20瓶可乐
第21个人买了1瓶可乐，现共有21瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第22个人拿到换来的可乐，不用买了-----
第23个人买了1瓶可乐，现共有23瓶可乐
第24个人买了1瓶可乐，现共有24瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第25个人拿到换来的可乐，不用买了-----
第26个人买了1瓶可乐，现共有26瓶可乐
第27个人买了1瓶可乐，现共有27瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第28个人拿到换来的可乐，不用买了-----
第29个人买了1瓶可乐，现共有29瓶可乐
第30个人买了1瓶可乐，现共有30瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第31个人拿到换来的可乐，不用买了-----
第32个人买了1瓶可乐，现共有32瓶可乐
第33个人买了1瓶可乐，现共有33瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第34个人拿到换来的可乐，不用买了-----
第35个人买了1瓶可乐，现共有35瓶可乐
第36个人买了1瓶可乐，现共有36瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第37个人拿到换来的可乐，不用买了-----
第38个人买了1瓶可乐，现共有38瓶可乐
第39个人买了1瓶可乐，现共有39瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第40个人拿到换来的可乐，不用买了-----
第41个人买了1瓶可乐，现共有41瓶可乐
第42个人买了1瓶可乐，现共有42瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第43个人拿到换来的可乐，不用买了-----
第44个人买了1瓶可乐，现共有44瓶可乐
第45个人买了1瓶可乐，现共有45瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第46个人拿到换来的可乐，不用买了-----
第47个人买了1瓶可乐，现共有47瓶可乐
第48个人买了1瓶可乐，现共有48瓶可乐
哦也，收集到3个瓶盖了，我拿3个瓶盖去换一瓶可乐！下个人不用买了，真高兴！
-----换来的可乐又得到了一个瓶盖，真棒！------
-----第49个人拿到换来的可乐，不用买了-----
第50个人买了1瓶可乐，现共有50瓶可乐
综上，需要买34瓶可乐，需要换16瓶可乐，剩2个瓶盖

第一种思路找规律挺难想的吧。厉害。

高手，加油！

大家觉得这样怎么样，其实用对象编程的方法，很简单的

1. package nuddlew.itheima;
   
2. 
   
3. public class CokeTest {
   
4. 
   
5.          * @param args
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 int result = bottleCount(28);
   
9.                 System.out.println(result);
   
10.         }
    
11.         public static int bottleCount(int quantity){
    
12. //                quantity为人数
    
13.                 int bottle = 0;
    
14. //                买的可乐的瓶数
    
15.                 int index = 0;
    
16. //                index为手上瓶盖的数量
    
17.                 while(quantity!=0){
    
18.                         bottle++;index++;quantity--;
    
19. //                        只要瓶盖不够3，就按这个数量执行
    
20.                         if(index==3){
    
21. //                                如果有三个，则换一瓶可能，瓶盖变为一
    
22.                                 quantity--;
    
23.                                 index=1;
    
24.                         }
    
25.                 }
    
26.                 return bottle;
    
27.         }
    
28. }
    
29. 
    

复制代码

第一种思路比较简洁，感谢分享

nuddlesW 发表于 2014-12-18 22:39
大家觉得这样怎么样，其实用对象编程的方法，很简单的

这个不错

把自己写的也贴上。

1. /*
   
2. * 需求： 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？
   
3. * 假如是50人，又需要买多少瓶可乐？（需写出分析思路）
   
4. * 思路：1，这个程序最重要的是分清可乐的瓶数和人数的关系，要求可乐的瓶数与人数的关系是相等的。
   
5. *                 2，可乐的瓶数来自于购买的可乐，和喝下可乐留下的盖子3换1获得的。
   
6. * 步骤：1，从键盘输入要喝可乐的人数。
   
7. *                 2，设置一个While循环里面有三个变量gouMai代表买的可乐数，pingGai代表瓶盖数，keLe代表可乐的总数。
   
8. *       当购买一瓶，gouMai++，pingGai++，keLe++。
   
9. *      3，当pingGai的个数达到3的倍数的时候换取一个可乐，keLe++，把瓶盖数置为1
   
10. *      4，需要注意一点，因为在进行一次循环的过程中，keLe++可能进行两次所以我们在进行每次keLe++的时候判断它是否和人数相等。
    
11. */
    
12. 
    
13. package com.itheima;
    
14. import java.util.Scanner;
    
15. 
    
16. public class Test10 {
    
17.         public static void main(String[] args) {
    
18.                  Scanner input = null; //键盘录入
    
19.                  
    
20.                  try{
    
21.                          input = new Scanner(System.in);
    
22.                          System.out.println("请输入有多少个人喝可乐:");
    
23.                          
    
24.                         int renShu = input.nextInt();
    
25.                         int num =keleNum(renShu);
    
26.                          System.out.println("需要"+num+"瓶可乐才够"+renShu+"个人喝");
    
27.                  }catch(Exception e) {
    
28.                          System.out.println("输入非法,请输入数字");
    
29.                  }
    
30.                  finally
    
31.          {
    
32.                  try
    
33.                  {
    
34.                          if (input != null)
    
35.                                  input.close();
    
36.                  } catch (Exception e2)
    
37.                  {
    
38.                          System.out.println("关闭流失败");  
    
39.                  }
    
40.          }
    
41.         }
    
42.        
    
43.         private static int keleNum(int i) {
    
44.                 // TODO Auto-generated method stub
    
45.                  
    
46.                  int keLe = 0,pingGai = 0,gouMai = 0;
    
47.                  while (keLe!= i) {
    
48.                        
    
49.                        
    
50.                         gouMai ++;
    
51.                         keLe++;
    
52.                         if(keLe == i)
    
53.                                 break;
    
54.                         pingGai++;
    
55.                         if(pingGai%3==0){
    
56.                                 pingGai = 1;
    
57.                                 keLe++;
    
58.                                 if(keLe == i)
    
59.                                         break;
    
60.                         }
    
61.                 }
    
62.                  
    
63.                 return gouMai;
    
64.         }
    
65. 
    
66. }
    

复制代码

思路真不错，学习了

一堆大牛，尼玛

1. /*
   
2. 9 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，
   
3. 够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
   
4. */
   
5. public class Test9 {
   
6.         public static void main(String[] args) {
   
7.                 System.out.println("----------------------------------------------");
   
8.                 System.out.println("请输入要喝可乐的人数:");
   
9.                 Scanner sc = new Scanner(System.in);
   
10.                 int pep = sc.nextInt();
    
11.                 System.out.print(pep+"人需要买");
    
12.                 cola(pep);
    
13.         }
    
14.        
    
15.         private static void cola(int pep){   //明确喝可乐的人数=输入的人数
    
16.                 int cap = 0;  //瓶盖数量
    
17.                 int buy = 0;  //买可乐的人数
    
18.                
    
19.                 while(pep!=0){  //每有一个人喝到可乐，需要喝的人就自动减一，直至全体都喝到为止
    
20.        
    
21.                         if (cap<3) {        //判断瓶盖满不满足3个，不满足，则买一瓶,买了就喝了
    
22.                                 buy++;
    
23.                                 cap++;
    
24.                                 pep--;
    
25.                         }
    
26.                        
    
27.                         if (cap==3) {        //当瓶盖为3时，换到一瓶（瓶盖为1），给后面的逗比喝了
    
28.                                 cap=1;
    
29.                                 pep--;
    
30.                         }
    
31.                 }
    
32.                 System.out.print(buy+"瓶可乐");
    
33.         }
    
34. }

复制代码

本宝宝也来凑热闹

超简单公式

public class test9 {
        public static void main(String[] args) {
               
                //假设刚开始买了一瓶可乐，有了一个瓶盖。
                int PinGai= 1;
                int buyNumber = 1;
               
                /*这个循环过程中，每经一次就会多一个空瓶盖，如果出现了三个瓶盖就
                不需要再买了，但是还会产生瓶盖，所以每次瓶盖要加1。*/
               
                for (;PinGai <28;PinGai++){
                       
                        //当瓶盖不是三的倍数时，就需要再买一瓶可乐。相当于每买两瓶可乐，就不需要买可乐了。
                        if ((PinGai%3)!=0){
                                buyNumber++;
                        }
                }
                System.out.println("28人喝可乐需要买"+buyNumber+"瓶");
               
                //同理，当50个人喝可乐时：
                int PinGai2= 1;
                int buyNumber2 = 1;
               
                for (;PinGai2 <50;PinGai2++){
                        if ((PinGai2%3)!=0){
                                buyNumber2++;
                        }
                }
                System.out.println("50人喝可乐需要买"+buyNumber2+"瓶");
        }
}

package com.itheima;

import java.util.Scanner;

public class Test9 {

        /**
         * 第9题：28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？
         *   假如是50人，又需要买多少瓶可乐？（需写出分析思路）
         * @param args
         * 分析：
         * 1.为了思路清晰，我们引入3个因变量，buy（购买的可乐数）、lid（瓶盖数）、server（买的可乐和用瓶盖兑换的可乐一共可以服务的人数）
         * 2.引入一共给定的自变量person（需要喝可乐的人数）；创建键盘录入对象，录入不同的数据（也就是人数），会得到不同的购买可乐数量
         * 3.每当购买一瓶可乐就增加一个瓶盖，被服务的人数也自增一个，当瓶盖集齐3个时，就能换一瓶可乐，
         *   也就是增加一个可服务人数，此时瓶盖数变为1，服务人数增加1个，当server小于person时，一直购买和兑换，也就是继续循环
         * 4.最后打印出需要购买的可乐数
         */
        public static void main(String[] args) {
                int a = getMan();
                getNum(a);
                
        }

        private static int getMan() {
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入需要喝可乐的人数");
                int man = sc.nextInt();
                if(man < 0 ){
                        System.out.println("您输入的数据有误，请重新输入");
                }
                return man;
        }

        private static void getNum(int a) {
                 int person = a;   //需要喝可乐的人数
         int buy = 0;       //购买可乐的数量
         int server = 0 ;   //购买和兑换后的可乐所能服务的人数
         int lid = 0;              //可乐的瓶盖数量
         while(server < person){
                  buy++;
                  server ++ ;
                  lid++;
                          if(lid == 3){
                                   server += 1;
                                   lid = 1;
                           }
         }
       System.out.println("您需要够买"+buy+"瓶，满足"+server+"人的需求；最后会剩下"+lid+"瓶盖");
        }

}