黑马程序员技术交流社区

标题: 入学测试题，写出你的代码； [打印本页]

作者: 曾翀 时间: 2014-7-30 21:09
标题: 入学测试题，写出你的代码；
28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
class lianxi
{
public static void main(String[] args)
{
PingZinum(28);
}
  public static void PingZinum(int x)
{
int y; // x是喝水人数，y是瓶子数；
y=(2*x+2)/3;
   System.out.print(y);
}
}
物理有能量守恒，动量守恒
这个题。。。却是瓶盖数量守恒。。。
因为一个瓶子三个瓶盖所以瓶盖是3y；因为n个人喝水人数最后有n瓶没有瓶盖的瓶子和n个人中手上最多2个瓶盖。。。。所以得不等式3y<=2n+2  化简的y<=(2*x+2)/3;

小伙伴写出你们的代码:lol

作者: yesecongcong 时间: 2014-7-30 22:31
不明觉厉

作者: yesecongcong 时间: 2014-7-30 22:55
楼主逻辑很犀利

作者: 357016138 时间: 2014-7-31 01:34

/*10、 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？
* 假如是50人，又需要买多少瓶可乐？（需写出分析思路）
*
*分析：每买一瓶可乐产生一个瓶盖和一个瓶子，
*
* 三个瓶盖可以换一个瓶盖和一个瓶子，
*
* 当瓶子数等于人数时，终止购买，返回此时买的可乐数。
*
*/
package com.itheima;
public class Test10 {
public static void main(String[] args) {
System.out.println(getBottle(28)); //28人时需要购买的可乐数
System.out.println(getBottle(6)); //50人时需要购买的可乐数
}
public static int getBottle(int person)
{
int bottlecap = 0; //设置开始瓶盖数
int bottle = 0; //设置开始瓶子数
int buycoco = 0; //设置买可乐数
while(bottle < person) //设置循环条件
{
buycoco++; //开始买可乐
bottlecap= bottlecap+1; //一瓶可乐增加一个瓶盖
bottle = bottle +1; //一瓶可乐增加一个瓶子
if(bottlecap==3) //三个瓶盖兑换一瓶可乐
{
bottlecap = 1; //瓶盖变成一个
bottle = bottle +1; //瓶子增加一个
}
}
return buycoco; //返回买的可乐数
}
}

复制代码

作者: 357016138 时间: 2014-7-31 01:41
还是楼主代码简单佩服佩服！！

作者: hejinzhong 时间: 2014-7-31 06:15
本帖最后由 hejinzhong 于 2014-7-31 18:56 编辑

（1）如果只要有盖子就可以换，那就是这样来写
2个人先买2瓶，将盖子给第3人，第三人即可免费喝一瓶了（先拿一瓶，他就有3盖子，不用付钱了）
(50/3)*2+50%3
即3人抱团，落单自理

class XXX
{
public static void main(String[] args)
{
func(50);
}
public static void func(int num)
{
System.out.println((num/3)*2+num%3);
}
}

复制代码

(2)这个我想的是一次买完，当场兑换一次，若考虑综合利用就不行。
只要在人数中，4人抱团买3瓶即可解决，没有团队的自己买，所以结果是：(50/4)x3+50%4
50/4是能最多组成的队伍个数，一个队伍买3瓶
50%4 就是没队伍的，自己解决。

作者: hejinzhong 时间: 2014-7-31 06:20
求告知，插入代码能保证我的格式呢？

作者: 乐此不疲 时间: 2014-7-31 08:31
算法的力量!

作者: 月影箫风起k 时间: 2014-7-31 08:54
这题我记得后来一般都可以借的吧，然后还一个。。。。还有一般来说不是三个瓶子换一个吗。。。

作者: 地狱天堂 时间: 2014-7-31 14:03

hejinzhong 发表于 2014-7-31 06:15
只要在人数中，4人抱团买3瓶即可解决，没有团队的自己买，所以结果是：(50/4)x3+50%4
50/4是能最多组成的 ...

简单明了

作者: @for 时间: 2014-7-31 14:09

hejinzhong 发表于 2014-7-31 06:15
只要在人数中，4人抱团买3瓶即可解决，没有团队的自己买，所以结果是：(50/4)x3+50%4
50/4是能最多组成的 ...

这个思路有点问题，。。

作者: @for 时间: 2014-7-31 14:13
不得不赞一个。。。。。。。。。。。。。。。。。。

作者: liubea 时间: 2014-7-31 14:17
同意楼上，买3瓶换来的那只可乐也还有个瓶盖，在这上面思路中，换来的那个瓶盖没使用...

作者: icris 时间: 2014-7-31 14:17
写程序跟做数学题是不一样的…他让打印从 1 加到 100 的结果难道你就打印（1 + 100）*50 = 5050 吗…

作者: yesecongcong 时间: 2014-7-31 15:21

yesecongcong 发表于 2014-7-30 22:31
不明觉厉

我看不懂怎么办，逻辑思维能力很差，学不好编程怎么办

作者: jthanyu 时间: 2014-7-31 15:33
逻辑能力都很强呀…

作者: dispensable 时间: 2014-7-31 16:04

liubea 发表于 2014-7-31 14:17
同意楼上，买3瓶换来的那只可乐也还有个瓶盖，在这上面思路中，换来的那个瓶盖没使用... ...

……4个人买3瓶，剩下组不到团的每人都得买一瓶……哪里有问题……逻辑很好的好吗？………………:L

作者: libo1989329 时间: 2014-7-31 16:13
开始玩数学题了，你的算法是对的，就是表达的欠缺点。比如一个瓶子三个瓶盖，这句话不是一看就能懂的。你得说三个瓶盖换一瓶可乐，那么也就是三个瓶盖换一个瓶身和一个瓶盖，因此一个瓶身也就抵两个瓶盖，因此一瓶可乐包括一个瓶身和一个瓶盖。也就相当于一个瓶子三个瓶盖。

作者: LFW 时间: 2014-7-31 16:14

hejinzhong 发表于 2014-7-31 06:15
只要在人数中，4人抱团买3瓶即可解决，没有团队的自己买，所以结果是：(50/4)x3+50%4
50/4是能最多组成的 ...

支持这个想法的跟我一起喊：V5。搞复杂了就没意义了

作者: LFW 时间: 2014-7-31 16:20

LFW 发表于 2014-7-31 16:14
支持这个想法的跟我一起喊：V5。搞复杂了就没意义了

我又想了一下，不对，，4人成团买3支没有错，但是每12个人分成三组，买了9瓶，分别各组兑换一次刚好喝完，然后3组合并，用兑换的可乐又还能兑换一支。。。。:(不靠谱

作者: fantacyleo 时间: 2014-7-31 16:24

hejinzhong 发表于 2014-7-31 06:15
只要在人数中，4人抱团买3瓶即可解决，没有团队的自己买，所以结果是：(50/4)x3+50%4
50/4是能最多组成的 ...

7个人只要5瓶即可，你的答案是6瓶。。。问题在于，没队伍的人只要达到3个，就可以继续累积瓶盖换可乐，而你的算法就让他们直接每个人买一瓶了。

作者: 思维 时间: 2014-7-31 16:44
假设最少需要购买x瓶可乐就够28人或50人喝！
那么只要满足以下公式就可以：
x/3+x≥28或x/3+x≥50

作者: 思维 时间: 2014-7-31 16:45

357016138 发表于 2014-7-31 01:34

你的算法好麻烦的说！:funk:

作者: libo1989329 时间: 2014-7-31 16:53

libo1989329 发表于 2014-7-31 16:13
开始玩数学题了，你的算法是对的，就是表达的欠缺点。比如一个瓶子三个瓶盖，这句话不是一看就能懂的。你得 ...

确实啊，剩余瓶盖数为1、2、3、1、2、3。。。。。因此他的等式应该改为y<=(2x+3)/3,x不等于0，y不等于0.

作者: blz01003hm 时间: 2014-7-31 17:38
本帖最后由 blz01003hm 于 2014-7-31 18:46 编辑

楼主好强大。。前面我搞错了，28人买19瓶就够了。

class Ls
{
      public static void main(String[] args)
      {
            int count=1;//计数
            for(int i=1;i<=50;++i)
            {
                     if(i%3==0) ++i;//买3送一
                     count++;
            }
            System.out.println(count-1);
      }
}

作者: hejinzhong 时间: 2014-7-31 18:06

fantacyleo 发表于 2014-7-31 16:24
7个人只要5瓶即可，你的答案是6瓶。。。问题在于，没队伍的人只要达到3个，就可以继续累积瓶盖换可乐，而 ...

如果只要有盖子就可以换，那就是这样来写
2个人先买2瓶，将盖子给第3人，第三人即可免费喝一瓶了（先拿一瓶，他就有3盖子，不用付钱了）
(50/3)*2+50%3

作者: hejinzhong 时间: 2014-7-31 18:07
本帖最后由 hejinzhong 于 2014-7-31 18:49 编辑

blz01003hm 发表于 2014-7-31 17:38
楼主好强大。。。28人买21瓶就够了吧

19瓶，不是21

作者: hejinzhong 时间: 2014-7-31 18:12

@for 发表于 2014-7-31 14:09
这个思路有点问题，。。

如果只要有盖子就可以换，那就是这样来写
2个人先买2瓶，将盖子给第3人，第三人即可免费喝一瓶了（先拿一瓶，他就有3盖子，不用付钱了）
(50/3)*2+50%3
即3人抱团，落单自理

作者: fantacyleo 时间: 2014-7-31 18:13

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

还是不对，如果是3个人，必须要买3瓶才行。只买2瓶，只有2个盖子，不够换

作者: hejinzhong 时间: 2014-7-31 18:14

LFW 发表于 2014-7-31 16:20
我又想了一下，不对，，4人成团买3支没有错，但是每12个人分成三组，买了9瓶，分别各组兑换一次刚好喝完 ...

作者: hejinzhong 时间: 2014-7-31 18:20

fantacyleo 发表于 2014-7-31 18:13
还是不对，如果是3个人，必须要买3瓶才行。只买2瓶，只有2个盖子，不够换 ...

你想下，当2个人买了之后，第3个人就手握2盖子，当他喝完一瓶，不就3盖子了，还用付钱吗！可以说是先消费后还钱。

作者: LFW 时间: 2014-7-31 18:36

357016138 发表于 2014-7-31 01:34

最好理解最好敲的是你的代码。

作者: LFW 时间: 2014-7-31 18:37

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

这是可以借的想法，但是题目没说可以借

作者: hejinzhong 时间: 2014-7-31 18:39
本帖最后由 hejinzhong 于 2014-7-31 18:41 编辑

LFW 发表于 2014-7-31 18:37
这是可以借的想法，但是题目没说可以借

这个就是瓶盖守恒定理，不信你试试楼主结果。人这么多，我可以借用没队伍的人，完成我的小组功能，不一定去借

作者: blz01003hm 时间: 2014-7-31 18:40

hejinzhong 发表于 2014-7-31 18:07
17瓶，不是21

17瓶送5瓶才22瓶啊，不够28人喝啊？

作者: hejinzhong 时间: 2014-7-31 18:42
本帖最后由 hejinzhong 于 2014-7-31 18:49 编辑

blz01003hm 发表于 2014-7-31 18:40
17瓶送5瓶才22瓶啊，不够28人喝啊？

送完之后，还有盖子，可以继续循环的换

作者: LFW 时间: 2014-7-31 18:43

hejinzhong 发表于 2014-7-31 18:07
17瓶，不是21

19瓶吧，你算个17去看看够不够

作者: LFW 时间: 2014-7-31 18:46

hejinzhong 发表于 2014-7-31 18:42
送完之后，还有盖子7个，可以继续循环的换

19可乐=19（瓶+盖），18盖+1盖=6（瓶+盖）+1盖；6盖+1盖=2（瓶+盖）+1盖；3盖=1（瓶+1盖）。19+6+2+1=28.》》》有问题你就说。楼主的式子我总觉得有点问题、、、好像分析时大于还是小于号放反了

作者: hejinzhong 时间: 2014-7-31 18:48
本帖最后由 hejinzhong 于 2014-7-31 18:50 编辑

LFW 发表于 2014-7-31 18:43
19瓶吧，你算个17去看看够不够

对对对，我算错了 (28/3)*2+28%3 =19 （9x2+1）

作者: blz01003hm 时间: 2014-7-31 18:50

hejinzhong 发表于 2014-7-31 18:42
送完之后，还有盖子7个，可以继续循环的换

你这不够了的，17换得5瓶余2个瓶盖，5瓶换得1瓶余2个瓶盖，2+2还得1瓶余2个瓶盖，17+5+1+1=24

作者: LFW 时间: 2014-7-31 18:50

hejinzhong 发表于 2014-7-31 18:48
对对对，我算错了 (28/3)*2+28%3 =19

我觉得板凳的代码最好理解，最容易被接受。

作者: hejinzhong 时间: 2014-7-31 18:51

blz01003hm 发表于 2014-7-31 18:50
你这不够了的，17换得5瓶余2个瓶盖，5瓶换得1瓶余2个瓶盖，2+2还得1瓶余2个瓶盖，17+5+1+1=24 ...

开始的17，我算错了，
应该是 (28/3)*2+28%3 =19 （9x2+1）
你试试19

作者: 刘小印 时间: 2014-7-31 18:51

yesecongcong 发表于 2014-7-30 22:55
楼主逻辑很犀利

好屌的样子，逻辑不错啊

作者: blz01003hm 时间: 2014-7-31 18:56

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

我抽到的题目是有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
很坑啊

作者: hejinzhong 时间: 2014-7-31 18:58

blz01003hm 发表于 2014-7-31 18:56
我抽到的题目是有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1 ...

这个我论坛有个，我在他代码上改了下，就昨天的。
结果是，原来序号为1的人

作者: blz01003hm 时间: 2014-7-31 18:59

hejinzhong 发表于 2014-7-31 18:58
这个我论坛有个，我在他代码上改了下，就昨天的。
结果是，原来序号为1的人 ...

啊，我的是 92列
public static void main(String[] args) {
      // TODO Auto-generated method stub

      int p = 100;//有100人
      /**** 初始化人员 ***/
      boolean[] per = new boolean[p];// boolean数组表示站成一圈的人，false表示退出
      for (int i = 0; i < per.length; i++) {
         per = true;
      }

      /**** 报号 ***/
   int t = 0, len = per.length;
   while (len > 1) {
         for (int i = 0; i < per.length; i++) {

            if (per) {
                  t++;
                  if (t == 14) {
                     t = 0;
                     per = false;
                     len--;
                  }
            }
         }
   }
      /***** 结果 *****/
   for (int i = 0; i < per.length; i++) {
         if (per) {
            System.out.println("剩下的人：" + (i+1));
      }
   }
   //System.out.println("最后的情况：" + Arrays.toString(per));

}
作者: hejinzhong 时间: 2014-7-31 19:01

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

先出去买菜了，一会回来看下你的代码
作者: hht_xiaohe 时间: 2014-7-31 19:16
赞一个写得很简洁。
作者: 于龙超123 时间: 2014-7-31 19:28
学习了~
作者: 王凯路路 时间: 2014-7-31 22:04
可不可以告诉我这个2*x+2  是什么意思 ?
作者: dreamseekerkun 时间: 2014-8-1 00:08
没有思路，入学测试好难这个题
作者: chulangren2 时间: 2014-8-1 00:37
这题目挺简单的，以前做过很多类似的智力题。
作者: 郑飞 时间: 2014-8-1 01:23
本帖最后由郑飞于 2014-8-1 01:30 编辑

/*思路:
1:正向思维,从0开始买可乐,28和50作为控制条件;
2:每买一瓶进入一次for循环,记得每次盖子数和可乐数都增加1;
3:进入for循环后,换可乐是个问题,所以我用了while循环把盖子全部换成可乐;
      每次换到的可乐数=盖子/3 +盖子%3(这个理解了其他就好办了);
*/
class HeiMa{

      public static void main(String[] args){
      hekele(28);
      hekele(50);
      }
            public static void hekele(int man){

                     int kele;//买的可乐数
                     int gaizi ;//盖子数
                     int people = 0;//喝到可乐的人数
                     int change = 0;//换到的可乐数//

                     for(kele=0,gaizi=0;people<man;kele++,gaizi++){
                              while(gaizi>2){
                              change = change + gaizi/3; //更新换到的可乐数（这里把当前盖子都换成可乐了）
                              gaizi =gaizi/3+ gaizi%3;  // 更新剩余盖子数（现在盖子数=上一步换可乐剩下的盖子数+换来的可乐所带的盖子数）
                              }
                              people = kele + change ;//喝到可乐的人数=买的可乐+换的可乐
                              if(people==man){
                              System.out.println("kele="+kele);
                              }
                     }
            }
}

作者: M单色调 时间: 2014-8-1 03:21
我觉得是个数列问题！1.2.3.3.4.5.5.6.7.7.8.9.9.10.11.11....然后求出第n项和总项数就ok可了！
作者: 赵顺超 时间: 2014-8-1 09:56
本帖最后由赵顺超于 2014-8-1 10:00 编辑

28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？

*       假如是50人，又需要买多少瓶可乐？

*

*

*                               28个人需要买19瓶可乐

*                               50个人需要买34瓶可乐

*

*

* 思路：

* 1，因为买了可乐后，3个瓶盖可以换新的可乐喝，所以当手中有两个瓶盖时，

*          就需要考虑能否先向卖可乐的老板借一瓶可乐的问题了，即最后一瓶是由手里的2个瓶盖跟向老板借的可乐瓶盖换的。

*          这样就可以多一个人喝可乐。

* 2，经分析得出以下一张表格

* ---------------------------------------------------------

*                                                          若不能借一瓶

* 买了几瓶       1       2       3       4       5       6       7       8       9       10 ...

*  喝可乐人数       1       2       4       5       7       8       10       11       13       14 ...

*  剩余瓶盖数       1       2       1       2       1       2       1       2       1       2  ...

* ---------------------------------------------------------

*                                                       若能借一瓶

*    买了几瓶       1       2       3       4       5       6       7       8       9       10 ...

*    喝可乐人数       1       3       4       6       7       9       10       12       13       15 ...

*    剩余瓶盖数       1       0       1       0       1       0       1       0       1       0  ...

* ---------------------------------------------------------

* 3，查看上表，可以得出，买的可乐瓶数是从1开始递增的，

*          在不能借一瓶的情况中，当买奇数瓶时，喝可乐人数比少买1瓶时的喝可乐人数多2人，

*          当买偶数瓶时，喝可乐人数比少买1瓶时的喝可乐人数多1人。

*          在能借一瓶的情况中，当买奇数瓶时，喝可乐人数比少买1瓶时的喝可乐人数多1人，

*          当买偶数瓶时，喝可乐人数比少买1瓶时的喝可乐人数多2人。

* 4，这种情况，可以使用数组，来模拟计算。

*

*

* 步骤：

* 1，定义getKeko方法，在方法中，定义int数组，设置0角标数为1，并将喝可乐人数y作为参数。

* 2，当y=1时，返回1，使用%来判断x是奇数还是偶数，因为存在0号角标，当x%1=1时为偶数，当x%2=0时为奇数。

* 3，使用for循环，让买可乐瓶数x递增，数组中的奇数项（x%2=0）+2偶数项+1，并判断数组的值在是否大于或等于y。

* 4，当数组中的数值满足条件时，返回x+1。

* 5，定义getKeko2方法，模拟能借一瓶的情况，与getKeko方法相反，奇数时+1，偶数时+2。

* 6，在主函数中调用两个方法，发现无论能否借一瓶，28人需要买19瓶可乐，50人需要买34瓶可乐。

*

*

*

*/

public class Test10 {

      public static void main(String[] args) {



            //28人喝可乐的情况

            int y = 28;



            System.out.println("如果不能向老板借一瓶可乐，那么"+y+"个人需要买"+getKeko(y)+"瓶可乐");

            System.out.println("如果能向老板借一瓶可乐，那么"+y+"个人需要买"+getKeko2(y)+"瓶可乐");



            //打印结果的分隔符

            System.out.println("---------------------");



            //50人和可乐的情况

            int y2 = 50;

            System.out.println("如果不能向老板借一瓶可乐，那么"+y2+"个人需要买"+getKeko(y2)+"瓶可乐");

            System.out.println("如果能向老板借一瓶可乐，那么"+y2+"个人需要买"+getKeko2(y2)+"瓶可乐");



      }



      public static int getKeko(int y){

            //定义数组

            int[] arr = new int [y];



            //数组的0号元素为1

            arr[0] = 1;



            //当1人喝可乐时，返回1

            if(y==1){

                     return 1;

            }



            //for循环模拟买可乐瓶数的增加

            for(int x=1;x<y;x++){



                     //偶数瓶，当前数组元素等于前一元素+1

                     if(x%2 == 1){

                              arr[x] = arr[x-1] + 1;

                              if(arr[x] >= y){

                                    return x+1;

                              }

                     }



                     //奇数瓶，当前数组元素等于前一元素+2

                     if(x%2 == 0){

                              arr[x] = arr[x-1] +2;

                              if(arr[x]>=y){

                                    return x+1;

                              }

                     }

            }

            return -1;

      }



      public static int getKeko2(int y){

            //定义数组

            int[] arr = new int [y];



            //数组的0号元素为1

            arr[0] = 1;



            //当1人喝可乐时，返回1

            if(y==1){

                     return 1;

            }

            //for循环模拟买可乐瓶数的增加

            for(int x=1;x<y;x++){



                     //偶数瓶，当前数组元素等于前一元素+2

                     if(x%2 == 1){

                              arr[x] = arr[x-1] + 2;

                              if(arr[x] >= y){

                                    return x+1;

                              }

                     }

                     //奇数瓶，当前数组元素等于前一元素+1

                     if(x%2 == 0){

                              arr[x] = arr[x-1] +1;

                              if(arr[x]>=y){

                                    return x+1;

                              }

                     }

            }

            return -1;

      }

}
复制代码

作者: 裤裆里的温柔、 时间: 2014-8-1 14:51
本帖最后由裤裆里的温柔、于 2014-8-1 15:15 编辑

不用搞这么麻烦，10行代码足矣，只测试了28和50通过，其他没试
public class TestCoCo {

public static void main(String[] args) {

int man =50;

int count = 0 ,again = 0 ,buy = 0,bottle=0;

while (man > bottle) {

buy++;

bottle++;

again++;

if (buy == 3) {

bottle++;

buy = 1;

}

}

System.out.println(again);

}

}

复制代码

作者: 申航航 时间: 2014-8-1 14:55
不明知了
作者: 曾翀 时间: 2014-8-1 15:14
拿50个人喝水来说，最后结果就是 50个人都喝了水， 50个人手中一定有50个没有瓶盖的瓶子（也就等于100个瓶盖），但是50个人手中也许有0个1个或者2个瓶盖所以50个人手中有小于等于102个瓶盖，大于等于100个瓶盖！  所以  100<=3*y<=102；  但是人要够喝水就只能看3*y<=102  并且  y只能取最大值；
作者: F@C 时间: 2014-8-1 17:21
进来学习
作者: vaqh 时间: 2014-8-1 17:36

LFW 发表于 2014-7-31 16:14
支持这个想法的跟我一起喊：V5。搞复杂了就没意义了

都是，，这个才叫简单明了，而且有逻辑
作者: LFW 时间: 2014-8-1 17:45

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

哥们、、、那个不对、、、、我后来我发现错误了。那每考虑兑换后的可乐仍有瓶盖的情况
作者: vaqh 时间: 2014-8-1 18:28

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

是哦，，，
作者: dispensable 时间: 2014-8-2 01:59

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个瓶盖又换出来的最后一瓶退给老板，所以遵循现实世界的逻辑才符合题目要求，而不是遵循算法，编程的目的也是为了解决现实生活中的问题，帖子里也很多朋友贴出逻辑的代码了，当然这只是个人见解，详细注释并且复贴一下：
class BuyWater

{

public static void main(String[] args)

{

person(51);

}

public static void person(int person)

{

   int bottle = 0; //瓶子数目

   int cap = 0; //瓶盖数目

   int count = 0;  // 购买次数，代表每增加一，就买了一瓶水，也是最终

                     //也就是最终需要购买的瓶数

while (bottle<person) //瓶数比人数少就买水

{

      count++;       //买了一瓶

cap++;          //多了个瓶盖

bottle++;       // 瓶子数增加

if (cap==3)    //大优惠，三换一（不能2换一哦，想得美）

{

cap = 0;    //瓶盖没了

bottle++; //换到了一瓶

cap = 1;    //得了个瓶盖

}

}

System.out.println(count); //最终买了count 瓶

}

}

复制代码
作者: 想做开发 时间: 2014-8-2 02:18

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

实际中会么
作者: hejinzhong 时间: 2014-8-2 06:02

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

我试了下，是92
作者: lijiang 时间: 2014-8-2 07:27
楼主的方法很刁。。。。。
作者: blz01003hm 时间: 2014-8-2 08:16

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

自己想的时候，就是没想到用布尔型数组。
作者: 微微微笑 时间: 2014-8-2 08:45
这个好像也是蓝桥杯的考试题
作者: 小孔 时间: 2014-8-2 09:03

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

好想法！
作者: pray 时间: 2014-8-2 15:32
还是楼主代码简单佩服佩服！！
作者: LFW 时间: 2014-8-2 16:36

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

if (cap==3)    //大优惠，三换一（不能2换一哦，想得美）
            {
                     cap = 0;    //瓶盖没了
                     bottle++; //换到了一瓶
                     cap = 1;    //得了个瓶盖

            }》》》》3盖换一瓶时，那瓶可乐直接就有了盖了，我个人觉得cap=0那一句话可以不写，感觉赘余
作者: LFW 时间: 2014-8-2 16:48

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

是你英文太好还是我英语太菜，我看不懂你写的。。。
作者: sunshine9091 时间: 2014-8-2 16:57
厉害啊！
作者: sunshine9091 时间: 2014-8-2 17:23

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

有问题！
作者: sunshine9091 时间: 2014-8-2 17:44
楼主你只是从宏观上考虑到瓶盖守恒，但是必须是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;
}
}
作者: 裤裆里的温柔、 时间: 2014-8-2 18:02

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

again是再买的次数，buy是买的次数，bottle是瓶数，buy=1就是换了一瓶，。每次换完1瓶只需要再买2瓶就可以换一瓶，就是不停的+2,最后求出刚开始买的3瓶+每次再买的2瓶，是这个思路
作者: 安茹黑马 时间: 2014-8-2 18:06
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;
      }
}
作者: 地狱天堂 时间: 2014-8-2 18:48
本帖最后由地狱天堂于 2014-8-2 19:55 编辑

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

class BuyWater {

      public static void main(String[] args) {

            getBottle(51);

      }

/*

* 以16人为例，其它人数的结构是一样的。

* 人数：    1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16

* 买是1： 1  1  1  0  1  1  0  1  1  0 1 1 0 1 1 0

* 0处表示送了一瓶，并且多了一个盖子。

*

* 思路：

* 按上图规律即除去第一个人，每3人可抱团。除去第1个人，每3个人需要买2瓶，不满3人自己买。

* 那么p=人数,bottle= 需要购买的瓶数

* bottle=((p-1)/3)*2+(p-1)%3+1

*

* 相比较dispensable的代码简化了一些，但是阅读可能差一点。

* */

      public static void getBottle(int p)

      {

            int bottle;

            bottle=((p-1)/3)*2+(p-1)%3+1;

            System.out.println(bottle);

      }

}

复制代码

作者: ★零→_→度♥ 时间: 2014-8-5 20:24
OH NO................................................................................................。。。。。。。。。。。。。
作者: ★零→_→度♥ 时间: 2014-8-5 21:22
OH NO................................................................................................。。。。。。。。。。。。。
作者: 寐海流风 时间: 2014-8-5 21:29
public class Test10 {

public static void main(String[] args) {

System.out.println("#####################方法一检测#####################");
System.out.println(buyCoke1(28));
System.out.println(buyCoke1(50));
//检测当人数能被3整除的情况
System.out.println(buyCoke1(99));

System.out.println("#####################方法二检测#####################");
System.out.println(buyCoke2(28));
System.out.println(buyCoke2(50));
System.out.println(buyCoke3(99));

System.out.println("#####################方法三检测#####################");
System.out.println(buyCoke3(28));
System.out.println(buyCoke3(50));
System.out.println(buyCoke3(99));

System.out.println("#####################健壮方法检测#####################");
System.out.println(buyCoke(28,1,3));
System.out.println(buyCoke(50,1,3));
System.out.println(buyCoke(99,1,3));
System.out.println(buyCoke(2014,7,9));
}
/*
   * 思路：最后剩下的瓶盖，加上每个人喝掉的可乐，等于购买的可乐。
   *
   * 1、最后余下的瓶盖数capLeft，capLeft取值只可能是1、2、3（为什么会出现3呢？请见下面第3条分析。）;计算式capLeft=28%3
   * 2、一瓶可乐相当于3个瓶盖，每个人假如喝掉一瓶可乐（喝完可乐剩下一个瓶盖），则相当于每个人消费了2个瓶盖换取的可乐；
   * 那么28个人喝掉的可乐转换成瓶盖总量，计算式28*2
   * 3、总共瓶盖等于capLeft+28*2，即等于购买的可乐转换成的瓶盖数：bottleAll*3=capLeft+28*2
   * 4、为什么会出现最后剩余瓶盖数为3呢？
   * a、当总人数除3的余数是1的情况时，就会出现这种情况；
   * b、先举例理解，如27个人时：当26个人都喝到了可乐，这时剩下2个瓶盖，有一种办法是去借一个瓶盖，然后凑足3个瓶盖换了一瓶可乐给第27个喝了，
   * 然后产生的那个瓶盖再还给别人；但是我们找不到人借瓶盖，只能再买一瓶可乐，给第27个人，剩下一个瓶盖加上前面的2个，就剩下了3个；
   * c、所以，用上面3步分析出来的结果：27个人应该是需要买18瓶，但是就会产生举例分析时的尴尬境地；所以27个人时应该是买27瓶，最后余3个瓶盖；
   * 即：当人数除3余0时，结果是前3步的计算结果再加1；
   * d、此分析也要加入到下面2个方法的分析中。
   */
//方法一：
public static int buyCoke1(int num){

//最后余下的瓶盖数capLeft
int capLeft = num%3;

//根据等式bottleAll*3=capLeft+28*2，总瓶盖数除3则是需要买的可乐瓶数
int bottleAll = (num*2+capLeft)/3;

//如果人数能被3整除，则返回bottleAll+1
if(capLeft == 0)
return bottleAll+1;

//否则返回bottleAll
return bottleAll;
}

/*
   * 思路：假设每个人手上现在购买了两个瓶盖，则再需要加入1个瓶盖，就能使这个瓶盖循环利用，使大家都喝到可乐。
   *
   * 1、每个人手上有2个瓶盖，则有capUse = 28*2个瓶盖；
   * 2、考虑到方法一的第4条分析，再额外添加1-3个瓶盖，就能让所有人喝到可乐；
   * 3、capUse除3则是实际喝掉的可乐，考虑到不能整除情况下的类型自动提升为int，
   * 则计算出的需要买的可乐瓶数为capUse/3 + 1;此时也满足了当人数是3的倍数的分析。
   */
//方法二：
public static int buyCoke2(int num){

//每个人手上有2个瓶盖，则有capUse = 28*2个瓶盖
int capUse = num*2;

//需要买的可乐瓶数为capUse/3 + 1
return capUse/3+1;
}

/*
   * 思路：一瓶可乐相当于3个瓶盖，每个人假如喝掉一瓶可乐（喝完可乐剩下一个瓶盖），则相当于每个人实际喝掉了2/3瓶可乐。
   *
   * 1、总共喝掉的可乐瓶数为2/3*num，考虑到这个计算结果是浮点型，其中2/3对应的浮点数会被类型提升，则强制转型double bottleUse = (double)2/3*num；
   * 2、参考方法一的第4条分析；由于最后会剩下1-3个瓶盖，则总共买的可乐瓶数是刚好大于bottleUse的整数；
   * 3、所以采用Math.ceil方法，并且把返回的double数强转为int型；
   * 4、加入判断，满足了当人数是3的倍数的分析；
   * 5、参考方法二的第3条分析，则可将第3、4步简化为int bottleAll = bottleUse + 1，且不再做判断。
   */
//方法三：
public static int buyCoke3(int num){

//由于每个人实际相当于喝掉了2/3瓶可乐，则实际喝掉的可乐为bottleUse
double bottleUse = (double)2/3*num;

return (int)(bottleUse + 1);
}

//健壮函数，封装方法(采用方法二)：
//分别传入参数：假设人数为num，每人要喝numBottle瓶可乐，每numCap个瓶盖可以换一瓶可乐，则需要买多少瓶可乐呢？
//使用JDK1.5新特性，可变参数
public static int buyCoke(int ... args){

//每个人手上的瓶盖数为args[1]*2，所有人手上瓶盖数int capUse = args[0]*args[1]*2
int capUse = args[0]*args[1]*2;

//需要购买的可乐瓶数为capUse/args[2]+1
return capUse/args[2]+1;
}
}

作者: 日光加蓝 时间: 2014-8-5 22:33
看看~~~~~~~~~~
作者: 郭旭辉 时间: 2014-8-5 22:42
都是大神。。。。
作者: 轩辕苍穹 时间: 2014-8-5 22:43
看的头晕啊！！！！！！！！！！！
作者: 亨利大帝 时间: 2014-8-5 22:56
大神都在
作者: 胥亮 时间: 2014-8-5 23:00
这题涉及到动态规划问题瓶盖换过来的可乐也是有瓶盖的  这需要考虑进去
作者: conglin1991 时间: 2014-8-5 23:51

357016138 发表于 2014-7-31 01:34

学习了。。。
作者: lancerjs 时间: 2014-8-6 05:03
我的算法
cola = (person - 1) / 3 * 2 + (person - 1) % 3 + 1

按照现实生活的话,不可以佘饮料,所以从第二个人开始分组,3人一组,每组买两瓶,不够3人的组每人买一瓶,第一个人买一瓶
作者: 明2012 时间: 2014-8-6 07:50

LFW 发表于 2014-7-31 16:20
我又想了一下，不对，，4人成团买3支没有错，但是每12个人分成三组，买了9瓶，分别各组兑换一次刚好喝完 ...

28人的一共买多少??我算得是19瓶!  4人一组先买3*6=18瓶，28人中有24个人喝到，剩余6个瓶盖，换两瓶，26个人喝到，剩余2个瓶盖，买1瓶，27人喝到，三个瓶盖，换一瓶，28人全喝到！！
作者: 唕 时间: 2014-8-6 08:06
五个人你买几瓶，六个人你买几瓶
作者: 到处玩的 时间: 2014-8-6 08:16

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

不对，买来的瓶子盖拿去换新的了，但是换来的瓶子（上面有盖），也是可以换的，所以你说的方法肯定不是买的最少的
作者: 到处玩的 时间: 2014-8-6 08:20

357016138 发表于 2014-7-31 01:34

这个思路利用了换来的瓶子盖，应该是正确的思路。
作者: rolling-stone 时间: 2014-8-6 08:20
很简单，买三瓶可乐够四个人喝，然后(28/4)*3+(28%4)
作者: huanglyhf 时间: 2014-8-6 08:52

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

跟我想的一样！
这个写法最简单了！
作者: qzqanlhy 时间: 2014-8-6 09:00
楼上威武
作者: xbz1986 时间: 2014-8-6 09:16
有问题  换的那瓶也有个瓶盖  算在下一个三瓶里面吧
作者: 菜鸟一号 时间: 2014-8-6 09:29

357016138 发表于 2014-7-31 01:34

这位兄台的分析太好了。感谢分享:handshake
作者: 周峰峰 时间: 2014-8-6 11:45
很厉害！！！！！！！
作者: a191170796 时间: 2014-8-6 12:28

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

如果num=3，你这个就不对了啊！
作者: chulangren2 时间: 2014-8-6 23:23

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

4个人抱团后会多一个盖子。光这12盖子就可以再换5瓶还剩下两个盖子，然后再借一瓶，还回去3个盖子。
所以说你的思想是错的。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2