黑马程序员技术交流社区

标题: 周末答题有奖之一------答题贴 [打印本页]

作者: 刘胜寒 时间: 2013-5-10 18:03
标题: 周末答题有奖之一------答题贴
本帖最后由刘胜寒于 2013-5-24 20:56 编辑

写在别处不给分哦！！！

题目链接：http://bbs.itheima.com/thread-49418-1-1.html

不要使用压缩包。。。
你们要累死版主也不是这个玩法啊。。。

结贴时间为下午六点。。。
六点之后的所有回答一律不予考虑。。。

作者: 殇_心。 时间: 2013-5-10 18:04
hhhhhhhhhhhhhhhhhhhhhhh

作者: lipingan0520 时间: 2013-5-10 18:44
学习学习{:soso_e100:}

作者: 陈圳 时间: 2013-5-10 19:04
题呢，怎么没题？

作者: 葛杨杨 时间: 2013-5-10 20:10
看不到啊

作者: 王靖远 时间: 2013-5-10 20:34
我还不会输入函数。我只能想明白这中间关系。 M<=（2^n）-1就可以了啊。每天分的金子的分母上是M, 分子上需要是1 2 4 8这样的2的n-1次幂数才能满足。这样只要1+2+4+。。。。+2^(n-1)>=M不就可以了吗==>M<=(2^n)-1

作者: long 时间: 2013-5-10 21:24
本帖最后由 long 于 2013-5-10 21:26 编辑

怎么隐藏帖子啊？

作者: long 时间: 2013-5-10 21:44
/*
分析问题：仔细观察可知输入下面这些整数均可满足要求。
输入1和1时，可分成1份：1
输入2和2时，可分成两份：1/2和1/2
输入3和2时，可分成两份：1/3和1/3
输入4和3时，可分成3份：1/4、1/4和2/4
输入5和3时，可分成3份：1/5、2/5和2/5
输入6和3时，可分成3份：1/6、2/6和3/6
输入7和3时，可分成3份：1/7、2/7和4/7
输入8和4时，可分成4份：1/8、2/8、2/8和3/8
........
用sum、n分别代表输入的两个数。它们满足：sum>=2^(n-1)且sum<2^n。
故代码如下：
*/

public class Gold{
//getInt()函数的功能是从键盘中读入一个整数
public static int getInt(){
int i = 0;
try{
byte[] buf = new byte[20];
System.in.read(buf); //从键盘输入的字符存储到byte数组buf中
String s = new String(buf);
i = Integer.parseInt(s.trim()); //将String型变量s转换为相应的int型变量i
}
catch(Exception e){
System.out.println("程序遇到异常，即将终止");
System.exit(0);
}
finally{
return i;
}
}

//judge(int sum, int num)判断输入的整数是否满足条件
public static boolean judge(int sum, int n){
int small = 1, big = 1;//small表示下界，big表示上界
for(int i = 0; i < n-1; i++)
small *= 2;
big = small * 2;
if(sum >= small && sum < big)
return true; //满足条件函数自然返回true，否则返回false
return false;
}
public static void main(String[] args){
System.out.println("请输入两个整数（每输完一个整数按一次回车键）：");
int sum = getInt();
int n = getInt();

if(judge(sum, n))
System.out.println("YES");
else
System.out.println("NO");
}
}

作者: 刘健 时间: 2013-5-10 21:50

import java.io.BufferedReader;
import java.io.InputStreamReader;
public class giveTom {
public static void main(String[] args) {
System.out.print("请输入M和N：");
int m = 1;
int n = 1;
// 接收M
BufferedReader strM = new BufferedReader(new InputStreamReader(
System.in));
// 接收N
BufferedReader strN = new BufferedReader(new InputStreamReader(
System.in));
try {
m = Integer.parseInt(strM.readLine());
n = Integer.parseInt(strN.readLine());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 份数和能分数一致
if (m == n) {
System.out.println("yes");
}
if (2 * n - 1 <= m) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
}

复制代码

作者: 刘胜寒 时间: 2013-5-10 21:54

陈圳发表于 2013-5-10 19:04
题呢，怎么没题？

这个是答题贴来...

作者: 刘胜寒 时间: 2013-5-10 21:55

葛杨杨发表于 2013-5-10 20:10
看不到啊

你再看看。。。有人做出来了。。。就在7#

作者: 丘凤光 时间: 2013-5-10 22:15
package day2;

public class FenJinTiao {

/**
  * @param args
  * 题目：有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求？
  * 解决方案是这样的：只要我们将金条分成1/7、2/7，另一块4/7即可。
  * 这样的话，，第一天给tom七分之一的金条，第二天让tom归还七分之一的金条然后给tom七分之二的金条，
  * 第三天给tom七分之一的金条，第四天让tom归还所有的金条然后给他七分之四的金条，由此类推就可以满足要求了。
  *
  * 本题是上面故事的加强版：假设现在每天分给tom的金条为m，但是只能将金条分成n份，请问能满足要求吗？
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  //调用分金块函数
  int m=15;//m为分母，即表示m分之一
  int n=4;
  boolean flag=divide(m, n);
  if(flag){
System.out.println("能满足要求。");
//打印每段的大小
for(int x=0;x<n;x++){
System.out.println((int)Math.pow(2, x)+"/"+((int)Math.pow(2, n)-1));
}
  }
  else
System.out.println("不能满足要求。");
}

/**
  * 思路：
  * 1、由题1/7、2/7、4/7可将金块长度设为7，每天给tom一块，方便处理，m同样；
  * 2、分情况讨论：m和n为负数时报错，最大范围暂时只考虑int范围内；
  * 3、考虑n满足的临界点，因为每天给的分量一样，所以有
  * f(1)=1=Math.pow(2, 1-1)、1段
  * f(2)=2=Math.pow(2, 2-1)、2段
  * f(3)=f(2)+f(1)、
  * f(4)=f(3)+f(1)=f(2)+2f(1)=4=Math.pow(2, 3-1)、3段
  * f(5)=f(4)+f(1)、
  * f(6)=f(5)+f(1)=f(4)+f(2)、
  * f(7)=f(6)+f(1)=f(4)+f(2)+f(1)、
  * f(8)=f(7)+f(1)=f(4)+f(2)+2f(1)=8=Math.pow(2, 4-1)、4段
  * … … … …
  * f(m)=f(m-1)+f(1)=Math.pow(2, n) n段
  * 可以得出结论：m=Math.pow(2, n)为临界点，分n段最少要给m-1即Math.pow(2, n)-1
  * 4、n大于临界点的永远满足。
  *
  * @return
  */

//分金条的方法：需要外部未知元素m、n参与，返回是否满足要求
public static boolean divide(int m,int n){
  boolean flag=false;
  if(m<=0||n<0){
System.out.println("不可能给tom非正数块金条，或者不可能将金条分成负数份");
return flag;
  }

  //int p=0;
  //如果传入的p是几分之几，需要将金条长度置为整数以方便处理
  //while(m*p!=1){p++;}

  //根据临界点进行判断，m不大于n段能表示的数拾能满足要求，否则不满足
  if(m<=Math.pow(2, n)-1)
flag=true;
  return flag;
}
}

作者: 傻瓜一点红 时间: 2013-5-10 22:40

/*
题目：相信很多人都看过这个经典的数学故事:
有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求?
解决方案是这样的: 只要我们把金条分成一块1/7，一块2/7，另一块4/7即可。
这样的话,第一天给tom七分之一的金条，第二天，让tom归还七分之一的金条，然后给他七分之二的金条，第三天给他七分之一和七分之二两块金条，
第四天让他归还所有的金条并给他七分之四的那块金条，依此类推就能满足要求了。
本题是上面故事的加强版:
假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？
样例输入
7
3
样例输出
YES
分析：仔细分析就不难看出，其实这道题并不难，基本上纯属属于一到数学逻辑推理题，不难看出在M>=N的情况下，
只要N满足最基本的条件就可以了，最基本的条件就是：先计算出M能被2除多少次（意思就是用2一直除下去，直到
出现小数为止），然后就是N大于这个数就可以了；
例如：若M为7时，7能被2除2次，则N只要大于2就能满足；最基本的分法就是N为3时，分成1/7、2/7、4/7；如果N连
基本的分法都满足了，其它的就更不用说了；若M为10时，10能被2除3次，则N只要大于3就能满足；最基本的分法就
是N为4时，分成1/10、2/10、4/10、5/10；再仔细看，就会发现分子是1、2、4、8、16......是以2的次幂增上去的，
最后剩下的分子就是用分母减去这些相应的2的次幂所加起来余下的值，如M为10时，最后的分子就是10-1-2-4=5，因
为你不可能再减8了，再减就变成负数了，所以最基本的分法规律就显而易见了，只要N满足最基本的要求，其它的就
都满足了。
思路：1、先判断M是否大于等于N;
2、满足1条件后，计算出M能被2除多少次；
3、再判断N是否大于那个次数就可以了。
步骤：1、先用if条件判断M是否大于等于N，如果大于等于满足就继续，如果不满足就就结束；
2、用while循环计算出M能被2除多少次；
3、再用if条件判断N是否大于那个次数。
*/
import java.util.Scanner;
public class Demo
{
public static void panDuan(int M,int N)//定义一个计算函数，计算M能被2除多少次，并且判断N是否满足要求
{
int number=0;//此变量用于统计M能被2除多少次的次数
if(M>=N)//判断两个数值是否符合题目要求
{
while(M/2!=0)
{
M=M/2;
number++;
}
if(N>number)//判断N满足要求
System.out.println("YES,满足要求");
else//判断N不满足要求
System.out.println("No,不满足要求");
}
else
System.out.println("此组数据无意义");
}
public static void main(String[] args)//主函数
{
Scanner in=new Scanner(System.in);//创建一个对象接收输入的数值
System.out.println("请输入M的值：");
int M=in.nextInt();
System.out.println("请输入N的值：");
int N=in.nextInt();
System.out.println("你输入的M值为："+M+"；"+"你输入的N值为："+N);
panDuan(M,N);
}
}

复制代码

作者: 孙金鑫 时间: 2013-5-10 22:50
本帖最后由孙金鑫于 2013-5-10 22:51 编辑

/*
把金条分成一块1/7，一块2/7，另一块4/7即可。
思路：分成三份之后分别是：1/7，一块2/7，另一块4/7。
之后的每一天得到的数值，跟他的第几天是一样的，
如第一天1，第二天2，第三天3，以此类推。。。。。
也就是说分完之后，一个数或者两两相加，或者所有的书相加，可以表示每一天。
通过这个规律，我没可以看出，7=2^3-1,然后2的0次方，2的1次方，2的2次方。
如果是8天，每天得到八分之一呢？
就会大于7天，但是小于16天，这样就必须分成4分了，
即：7<8天<2^4-1
*/
import java.util.*;
class Test
{
public static void main(String[] args)
{
//这里可以输入数字的M和N
Scanner sn = new Scanner(System.in);
System.out.println("需要的天数M：");
int M = sn.nextInt();
System.out.println("需要把金条分成几份：");
int N = sn.nextInt();
//判断M与N对应的是否正确
if(M<=Math.pow(2,N)-1 && M>=Math.pow(2,(N-1)))//如果两者在2的N方-1和2的N-1次方之间
{
System.out.println("Yes");
}
else
System.out.println("注意：这种金条分配方式是错误的!");
}
}

复制代码

作者: 钟林杰 时间: 2013-5-11 00:13
在网上找的思路：
解析这类题
首先要明白
  2＾0＋2＾1＋2＾2＋。。。2＾A＝〔2＾（A＋1）〕－1
   如： 2的0次一直加到2的9次就等于2的10次方减1
为什么要用2的几次方？
因为在二进制中
0、1两个数字能够组成任意一个数。

在解题时，把总量看成M  要分成的分数看成N
则2＾N＞＝M  N取最小值
（可做为公式解决此类型运算题）
代码如下：
class Exam
{
public static void main(String args[])
{
int m =7;
int n = 3;

int num = 0; //记录分子的总数

if(Math.pow(2,n)>=m) //判断是否可以这样分
{
for(int i=0;i<n;i++) //利用for循环累加每份的分子
{
num = num + (int)Math.pow(2,i);
}
if(num==m) //判断分子是否等于分母，也就是判断总数是否等于1
{
System.out.println("YES");
}
else
(
System.out.println("NO");
)
}
else
{
System.out.println("NO");
}
}
}

作者: zn123_4 时间: 2013-5-11 00:45
楼主看看{:soso_e100:}

/*
有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求?
解决方案是这样的: 只要我们把金条分成一块1/7，一块2/7，另一块4/7即可。
这样的话,第一天给tom七分之一的金条，第二天，让tom归还七分之一的金条，然后给他七分之二的金条，第三天给他七分之一和七分之二两块金条，第四天让他归还所有的金条并给他七分之四的那块金条，依此类推就能满足要求了。
本题是上面故事的加强版:
假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？
可以知道分出的分数刚好事 1 2 4 8 即是2的n-1次方
并且总数刚好是前n-1次方的和
可知只要满足前 n-1次方和等于输入的sum就输出YES
2^0 2^1 2^2 1+2+4=7
1/7 2/7 4/7 2^(N-1)
样例输入
7
3
样例输出
YES
*/
import java.util.Scanner;
class Gold
{
//输入两个参数
public void goldFun(int m,int n)
{
//初始化sum
int sum = 1;
//定义i变量，小于分的分数 1/7 2/7 4/7
for(int i = 1;i < n;i++)
{
sum += 2*i; //1+2+4
}
//前n-1次的和等于m时，打印yes
if(sum == m)
{
System.out.println("YES");
}
else
{
System.out.println("NO");
}
}
}
class GoldenDemo
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
//每天给多少分之一
int M = in.nextInt();
//分成几份
int N = in.nextInt();
//new Gold对象
Gold gd = new Gold();
//对象调用goldFun()函数
gd.goldFun(M,N);
}
}

复制代码

作者: Leejuen 时间: 2013-5-11 01:06

package com.leejuen.org;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class test {
/**
* 我的理解是
7 3
同题目
可以知道分出的分数刚好事 1 2 4 8 2的n-1次方
总数刚好是前n-1次方的和
可知只要满足前 n-1次方和等于输入的sum就输出YES
故代码如下
*/
public static void main(String[] args) throws Exception{
// TODO 自动生成的方法存根
int cc;
long m,n;
BufferedReader strin=new BufferedReader(new InputStreamReader(System.in));
m=Integer.parseInt(strin.readLine());
n=Integer.parseInt(strin.readLine());
if(Judge(m,n))
System.out.println("YES");
else
System.out.println("no");
}
public static boolean Judge(long sum,long num)
{
int i;
long a = 1,s = 1;
if(sum == num) return true; //如果输入的俩数据相等返回是
for(i = 1;i<num;i++) //求2的num-1次方
{
a = a*2;
s = s + a; //将1 - 2的num-1次方依次加起来
}
if(sum == s) //2的次方和等于sum
{
return true;
}
return false;
}
}

复制代码

作者: JinnyZh 时间: 2013-5-11 01:19
第一次做这个版题目不知道这样写行么

getMarks.zip

5.09 KB, 阅读权限: 100, 下载次数: 0

Judge是封装好的,Judge是主函数的类

作者: 付银攀 时间: 2013-5-11 08:47

Gold.zip (1010 Bytes, 下载次数: 0)

还望版主指教

作者: 王浩骅 时间: 2013-5-11 10:34
import java.util.*;

public class TestF {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入每天给予M分之一的M值：");
int m = sc.nextInt();
System.out.println("输入分成的份数N（N>=2）的值：");
int n = sc.nextInt();
int a1 = 1 ;
int a2 = 2 ;
int a3 = 0 ;
int sum = 0 ;
/*对于分子而言，从第三项开始每一项都应该是前两项和加1，这类似于Fibonacci数列，只是每一项都等于前两项和+1
   * 这里运用简单的for循环来运行
   */
if(n==2){
sum=3;
}else{
for(int i=3;i<=n;i++){ //对分子求和，得到分母的最大值，即每天给予的最小分数
a3 = a1+a2+1;
sum = a1+a2+a3;
a1 = a2;
a2 = a3;
}
}
if(m<=sum){                   //当每天分给对方的量大于能够分给对方最小量的时候为可行输出YES
System.out.println("YES");
}
else{
System.out.println("NO");
}

}

}

作者: 孙浩 时间: 2013-5-11 10:44
本帖最后由孙浩于 2013-5-11 15:18 编辑

import java.util.Scanner;
/*
* 相信很多人都看过这个经典的数学故事:
有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求?
解决方案是这样的: 只要我们把金条分成一块1/7，一块2/7，另一块4/7即可。
这样的话,第一天给tom七分之一的金条，第二天，让tom归还七分之一的金条，然后给他七分之二的金条，第三天给他七分之一和七分之二两块金条，
第四天让他归还所有的金条并给他七分之四的那块金条，依此类推就能满足要求了。
本题是上面故事的加强版:
假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？
样例输入
7
3
样例输出
YES
分析：
M与N的关系
M=7 N=3时：每份分子为1 2 4 正好是 2的0次方 2的1次方 2的2次方正好是：2的0到N-1次方的累加和等于M
M=3 N=2时：每份分子为1 2 正好是 2的0次方 2的1次方正好是：2的0到N-1次方的累加和等于M
……
所以：
只需要判断：2的0到N-1次方的累加和是否等于M即可
*/
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入M值");
int M = scanner.nextInt();
System.out.println("请输入N值");
int N = scanner.nextInt();
System.out.println(isConform(M, N));
}
// 定义方法判断是否满足要求
private static String isConform(int M , int N) {
int sum= 0;//定义变量sum存储2的0到N-1次方的累加和
//计算2的0到N-1次方的累加和
for (int i = 0; i < N; i++) {
sum+=1<<i;//1<<i 相当于2的i次方
}
// System.out.println(sum);
if (M == sum) {
return "Yes";
}
return "No";
}
}

复制代码

作者: 胡帅冰 时间: 2013-5-11 11:27

/**
*
*/
package WeekTest;
/**
* 相信很多人都看过这个经典的数学故事:
有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求?
解决方案是这样的: 只要我们把金条分成一块1/7，一块2/7，另一块4/7即可。
这样的话,第一天给tom七分之一的金条，第二天，让tom归还七分之一的金条，然后给他七分之二的金条，第三天给他七分之一和七分之二两块金条，第四天让他归还所有的金条并给他七分之四的那块金条，依此类推就能满足要求了。
本题是上面故事的加强版:
假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？
样例输入
7
3
样例输出
YES
* @author bin
*
*/
public class Test_1 {
public static void main(String []args) {
getGold(8,4);
}
static void getGold(int M,int N){
String can;
if(Math.pow(2,N)>M)
can="YES";
else
can="NO";
System.out.println(can);
}
}

复制代码

作者: 刘胜寒 时间: 2013-5-11 14:45

刘健发表于 2013-5-10 21:50

代码有个漏洞。。。你自己找吧。。。
找不出我扣分了啊。。。

作者: 傻瓜一点红 时间: 2013-5-11 16:09

傻瓜一点红发表于 2013-5-10 22:40

木事，谢谢版主:D

作者: xuluheng718 时间: 2013-5-11 17:48
本帖最后由 xuluheng718 于 2013-5-11 17:53 编辑

import java.io.*;
public class SliceGold
{
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入每天要分的份数：");
int m =0;
int n =0;
try
{
String s1=br.readLine();
m = Integer.parseInt(s1);
}
catch(Exception e)
{
System.out.println("非法输入!!!!!");
return;
}
System.out.print("请输入要切的份数：");
try{
String s2=br.readLine();
n = Integer.parseInt(s2);
}
catch(Exception e)
{
System.out.println("非法输入!!!!!");
return;
}
int n1 = slice(m);
if(n==n1)
System.out.println("YES");
else
System.out.println("NO");
}
/*规律：
* 2＾0＋2＾1＋2＾2＋。。。2＾n＝(2＾(n＋1))－1
* 转成公式：
* 2^n>=m
*
* 通过位移的方法求出要切割的次数
*
* 返回需要切割的次数然后+1得出切成的份数
*
* */
public static int slice(int m)
{
int n = 0;
while(true)
{
n++;
if((2<<n)>=m)
{
break;
}
}
return n+1;
}
}

复制代码

时间匆忙，没优化！！！！

作者: 飞鸟青崖 时间: 2013-5-11 19:04
本帖最后由飞鸟青崖于 2013-5-11 20:38 编辑

/*
分析：
1，当第一天可以完成时，第m-1天也一样可以完成。第二天可以完成时，第m-2天也可以完成。
所以只需要判断分法中能不能满足前（m/2）天的需求，如果满足了，那么后面的天数也一样可以满足。
因此当n>m/2时一定会成功。
2.下面来考虑n<=m/2的情况，在此种情况下，可以单独留一个数使它为m - m/2.
然后验证剩余的n -1天能否满足前m/2天的需要。依次进行，便得到一次递归。
3，对于特殊情况：所给的天数为1.这个时候肯定也可以满足，所以这就需要在进行判断。
但是它只能判断初始的天数是不是等于1。
修改一下，将分法也加进去了。如果所给的天数过多，就将多余的天数分为0.
*/
import java.io.*;
import java.util.*;
class MyTest
{
public static void main(String[] args) throws IOException//异常就不处理了。
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] a = new int[2];
for(int x = 0;x<2;x++)
{
a[x]=Integer.parseInt(br.readLine());
}
String s = ti1(a[0],a[1],a[1]);
System.out.println(s);

}
private static String ti1(int m,int n,int suo)
{
if(suo == n )//判断初始的天数是不是1.
{
if(n == 1)
{
return "YES";
}
}
String flag = null;
if(n > m/2)
{

while(m != 0)
{
System.out.println("分法："+(m-m/2));
m = m/2;
n--;
}
for(int x = m/2;x<n;x++)
System.out.println("分法："+0);
return "YES";
}
if(n>0)
{
flag = ti1(m/2,--n,suo);
if(flag.equals("YES"))
System.out.println("分法："+(m-m/2));
}
else
{
return "NO";
}
return flag;
}
}

作者: 蔡汉康 时间: 2013-5-11 19:48
本帖最后由蔡汉康于 2013-5-11 19:51 编辑

import java.util.Scanner;
public class DanGao {
public static void main(String[] args) {
System.out.println("题目：假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？");
//键盘录入，获取M
System.out.println("请输入 M：");
Scanner s =new Scanner(System.in);
int m=s.nextInt();
//键盘录入，获取N
System.out.println("请输入 N：");
int n=s.nextInt();
//算法判断依据
boolean flag=(Math.pow(2,n)-1)>=m;
//输出结果
if(flag)
System.out.println("True");
else
System.out.println("False");
}
}

复制代码

作者: 蔡汉康 时间: 2013-5-11 19:48
本帖最后由蔡汉康于 2013-5-11 19:50 编辑

import java.util.Scanner;
public class DanGao {
public static void main(String[] args) {
System.out.println("题目：假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？");
//键盘录入，获取M
System.out.println("请输入 M：");
Scanner s =new Scanner(System.in);
int m=s.nextInt();
//键盘录入，获取N
System.out.println("请输入 N：");
int n=s.nextInt();
//算法判断依据
boolean flag=(Math.pow(2,n)-1)>=m;
//输出结果
if(flag)
System.out.println("True");
else
System.out.println("False");
}
}

复制代码

作者: 仲伟 时间: 2013-5-11 20:16
没有全是回复可见

作者: 仲伟 时间: 2013-5-11 21:58
import java.util.Scanner;

public class Test7 {
/*有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求
解决方案是这样的: 只要我们把金条分成一块1/7，一块2/7，另一块4/7即可。
这样的话,第一天给tom七分之一的金条，第二天，让tom归还七分之一的金条，
然后给他七分之二的金条，
第三天给他七分之一和七分之二两块金条，
第四天让他归还所有的金条并给他七分之四的那块金条，
依此类推就能满足要求了。
本题是上面故事的加强版:
假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？
样例输入
7
3
样例输出
YES*/
/*
   * 第一个天 M分一
   * 第二天M分2
   * 第m天m分m
2的n次幂减一
1 3 7 15  31
1 2 4 8 16
1
   */
public static void main(String[] args) {
//输入一个数字做判断
Scanner sc =new Scanner(System.in);
System.out.println("输入整数");
//接受一个数字
int  n=sc.nextInt();

//w为了下面好计算
int n1=n+1;
//计算器为了产生份数
   int i = 0;
   //标示
   boolean falg =false;
//判断出2的N幂
   while(n1%2==0)
{
i++;
n1=n1/2;
if(n1==1){
falg = true;
}
}
   //判断是否可以出去符合数字
   if(falg){
   for (int j = 0; j < i; j++) {
System.out.println((int)Math.pow(2, j));
}
   }else {
System.out.println("no");
}
}

}

作者: lipingan0520 时间: 2013-5-12 10:04
本帖最后由 lipingan0520 于 2013-5-12 14:15 编辑

/**
可以实现此功能，大家慢慢欣赏。
*/
class Test113
{
public static void main(String[] args)
{
xiaoMing(7,3);
}
public static void xiaoMing(int m,int n)
{
int sum = 0;
int conut = n;
if(n <= m)
{
for(int i = 1 ; i <= n;i++)
{
sum = sum + mathPow(2,i-1);
if(sum >= m)
{
show(i,m,n,conut);
break;
}
}
}
if(!(sum >= m))
{
System.out.print("\n答案NO!\n\n");
System.out.println("不能分成"+n+"份");
}
}
public static void show(int num , int m , int n , int conut) //把所用的可能性都算出来
{
int[][] arr = new int[m-num+1][m];//定义个2维数组，存储所有可以的组合
for(int i = 0 ; i < m-num+1 ; i++)
{
for(int j = 0 ; j < num+i ; j++)
{
if(i == 0) //将第一行的数进行赋值，这样就能算出第二行来
{
if(j < num) arr[i][j] = mathPow(2,j);
if(j == num-1)
{
int k = 0 , sum = k;
for(k = 0; k < num-1 ; k++)
{
sum = sum + arr[i][k];
}
arr[i][k] = m - sum;
}
}
else //算第一行后面的n行数
{
if(j == 0) arr[i][j] = 1;
else
{
if(j == num+i-1)
{
int k = 0 , sum = 0;
for(k = 0 ; k < num+i-1 ; k++)
{
sum = sum + arr[i][k];
}
arr[i][k] = m - sum ;
}
else if(arr[i-1][j] == arr[i][j-1])
{
arr[i][j] = arr[i-1][j];
}
else if(arr[i-1][j] != arr[i][j-1])
{
if(arr[i-1][j] < arr[i][j-1])
arr[i][j] = arr[i-1][j];
else
arr[i][j] = arr[i-1][j] - arr[i][j-1];
}
}
}
}
}
print(arr,num,conut,m);// 算好后的数组，最小分成金条数，要输出的金条数
}
public static void print(int[][] arr , int num , int conut , int m)//最后按格式输出
{
System.out.print("\n答案YES!\n\n可以分成"+conut+"份，最佳分法: ");
for(int i = 0 ; i < conut ; i++)
System.out.print(arr[conut - num][i]+"/"+m+"、");
System.out.println();
}
public static int mathPow(int a,int b)//求幕
{
if(b == 0) return 1;
for(int i = a ; i <= b ; i++)
{
a=a*2;
}
return a;
}
}

复制代码

作者: xuemeng 时间: 2013-5-12 10:05

<IMG border=0 alt="" src="http://bbs.itheima.com/forum.php?mod=image&aid=18975&size=300x300&key=c6139be8609061d321578e969410b53e&nocache=yes&type=fixnone" aid="attachimg_18975">public class Test {
/**
* 题目:
* 有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求?
解决方案是这样的: 只要我们把金条分成一块1/7，一块2/7，另一块4/7即可。
这样的话,第一天给tom七分之一的金条，第二天，让tom归还七分之一的金条，然后给他七分之二的金条，第三天给他七分之一和七分
之二两块金条，第四天让他归还所有的金条并给他七分之四的那块金条，依此类推就能满足要求了。
本题是上面故事的加强版:
假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？
我做的是加强版和普通版都OK的. 测试了N遍.没问题.
思路:
1.建立函数.把参数传递进去
2.以每天给tom几份作为循环条件遍历
3.在遍历过成中判断.
4.获取判断结果.跳出循环.
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//将参数传递给函数
goldDistribution(2,7);
}
//定义一个函数.分别穿进去的是,分成几分之几的金条,和要给的次数
public static void goldDistribution(int gold,int Distribution){
//为三个属性定义临时变量
int timpgold = Distribution;
int timp= gold;
int tom = 0;
if(timpgold<=0)
{
System.out.println("输入数字有误");
}
//遍历.
for(int x=0;x<=timpgold;x++){
//假如分成3分.到第三次的之前都是一天给一块的.
tom++;
//判断给的块数是否小于分的块数.如果小于.肯定能都给完
if(timpgold-timp<=timp){
System.out.println("yes");
break;
}
//如果是最后一块,并且加一起总数对的,然后在剩的块数和tom手中的块数+1之后相等证明就可以分配成功
if(tom==timp && Distribution ==(Distribution-timp)+tom && Distribution-timp==tom+1){
tom=Distribution-timp;
//throw new RuntimeException("yes!!!");
System.out.println("yes");
break;
}
//如果到了最后一分并且tom手里的金条和要给他的金条相家并等与总数的话
//就把最大的那块金条就给他,然后在判断tom的金条数+1 是否和总数想起匹配.如果条件不相等的
//话就证明,不能满足题目的需求
if(tom==timp && Distribution ==(Distribution-timp)+tom && Distribution-timp!=tom+1) {
System.out.println("no");
break;
}
}
}
}

复制代码

无标题.png (14.37 KB, 下载次数: 0)

这是我

作者: 黑马-王双 时间: 2013-5-12 17:02
标题: 周末答题版主可见
本帖最后由黑马-王双于 2013-5-12 17:50 编辑

y.jpg (60.17 KB, 下载次数: 0)

作者: kaka小明 时间: 2013-5-12 17:59
附件是我的工程，请查收！多谢！

GoldAllocation.rar

4.1 KB, 下载次数: 15

作者: JinnyZh 时间: 2013-5-12 22:43
..我以为那样比较正式点,能加多分,下次不会了~版主辛苦了

作者: 刘学明　　　 时间: 2013-5-16 12:17
。。。。。。好题不

作者: 翟宝海 时间: 2013-5-17 22:30

/*通过观察1/7，2/7，4/7；发现1+2+4=7，1=2-1,1+2=4-1,1+2+4=8-1；
而1、2、4之间成等比关系，可以得出如下表达式：
（2^0）=（2^1）-1;
（2^0）+（2^1）=（2^2）-1;
（2^0）+（2^1）+（2^2）=8-1=7;
可得出如下结论：
当（2^0）+（2^1）+（2^2）+（2^3）+……+[2^（n-1）]=（2^n）-1=M时，
即当（2^n）>M时要求能够得到满足；
注意：^为次方符号，而非异或。
*/
import java.util.Scanner;
class FenJin
{
public static void main(String[] args)
{
while(true)
{
System.out.println("请输入两个整数：");
Scanner scan=new Scanner(System.in);//接收输入的数据
int m=scan.nextInt();
if(m==0)
{
System.out.println("输入的数据有误，请重新输入");
continue;
}
int n=scan.nextInt();
Fen f=new Fen();
f.fen(m,n);
}
}
}
class Fen
{
void fen(int m,int n)
{
int result=1;
for(;n>0;n--)
{
result*=2;
}
if(result>m)
System.out.println("YES");
else
System.out.println("NO");
}
}

复制代码

作者: 黑马-许鹏 时间: 2013-5-18 14:21

/*
题目描述
相信很多人都看过这个经典的数学故事:
有一个金条，你每天需要给tom七分之一，但是你只能将其分成三份，问怎么分才能满足要求?
解决方案是这样的: 只要我们把金条分成一块1/7，一块2/7，另一块4/7即可。
这样的话,第一天给tom七分之一的金条，第二天，让tom归还七分之一的金条，然后给他七分之二的金条，第三天给他七分之一和七分之二两块金条，第四天让他归还所有的金条并给他七分之四的那块金条，依此类推就能满足要求了。
本题是上面故事的加强版:
假设现在每天要给tom M分之一的金条，但是只能将其分成N份，请问能满足要求吗？
样例输入
7
3
样例输出
YES
*/
/*
分析：第一块分1/m也就是分子是2的0次幂,第二块2/m是2的1次幂，第三块4/m,也就是
2的2次幂，以此类推。因为二进制用0和1能组合遍历出不同的数字。
因此，分n次即2的次幂的累加值能大于等于m，就能成功。
*/
class Slipt
{
public static void main(String[] args)
{
show(7,3);
}
public static void show(int m,int n)
{
int count=0;
//其实for循环也可以用一个语句代替:count=Math.pow(2,n)-1；
for(int i=0;i<n;i++)
count+=Math.pow(2,i);
if (count>=m)
System.out.print("YES");
else
System.out.print("NO");
}
}

复制代码

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

黑马程序员IT技术论坛 X3.2