黑马程序员技术交流社区

标题: ===>送技术分闪亮登场之第二周<===结束 [打印本页]

作者: Just_Only 时间: 2013-6-29 20:26
标题: ===>送技术分闪亮登场之第二周<===结束
本帖最后由 Just_Only 于 2013-7-6 20:01 编辑

{:soso__16865118374220378461_1:}相聚即是缘分，珍惜每分每秒，为了心中梦想，我们永不言弃。

要求:
    1.题目要自己做出来，要写明思路和步骤(可以合在一起){:soso__5462389604067913156_1:}
   2.将程序写的清晰明了,注释到位.
   3.回复的时候把代码和运算后结果的图片一起贴出来，
      不会弄图片的贴出结果来，不要蒙混过关，我会检查的，不合格者不给于技术分哦
   4.需要写出完整代码，不要用几句术语草草了事。
   5.代码放到代码块中,不要压缩包(压缩包没分)
   6.要写注释，没注释的没分...
   7.对于本次活动的题目或是加分，存在异议的可以联系我。。。有奖励的哦...
加分说明:
         题目总共三题，所得技术分是所做题的个数，但是如果所做题精简并且排版较好可能会有一分的技术奖励。
         （说明:如果前期没有完全做完而后续补充上，那么将撤销前期的加分而另行给分，如果有问题请看要求7）
附加:
   题目不是很难主要是在于综合，每周日更新(持续几周不定)
不说多的啦，上题目的啦，大家踊跃参加的啊，你的支持是我们服务的最大动力哦。
题目:
   1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
      甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
   2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
      水仙数是指一个三位数，其个位数立方和等于本身，例如:153=1[sup]3[/sup]+5[sup]3[/sup]+3[sup]3[/sup]
      回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
   3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。

作者: 神之梦 时间: 2013-6-29 20:42
题目感觉还是挺easy的，大家还在等什么呢？占个座位围观{:soso__3409329614010722382_3:}

作者: Just_Only 时间: 2013-6-29 20:44

神之梦发表于 2013-6-29 20:42
题目感觉还是挺easy的，大家还在等什么呢？占个座位围观 ...

题目不是很难，主要是综合，还有就是活跃大家的积极性，你说的别人看不见的啊，这是只有作者可见的啊

作者: 杨晓燕 时间: 2013-6-29 21:01
喔喔，送分的又来了

作者: Just_Only 时间: 2013-6-29 21:03

杨晓燕发表于 2013-6-29 21:01
喔喔，送分的又来了

恩恩，题目不是很难，积极写的哦。。。

作者: .netNo1 时间: 2013-6-29 21:49
标题: RE: ===>送技术分闪亮登场之第二周<===

int j1, j2, j3;/*j1是乙1的对手，j2是乙2的对手，j3是乙3的对手*/
for (j1 = 1; j1 <= 3; j1++)
{
for (j2 = 1; j2 <= 3; j2++)
{
if (j1 != j2)
for (j3 = 1; j3 <= 3; j3++)//两两相比
{
if (j1 != j3 && j2 != j3)//同一队的不进行比赛
{
if (j1 != 1 && j3 != 1 && j3 != 3)//条件判断
Console.WriteLine("乙队的一号对应甲队的{0}号，乙队的二号对应甲队的{1}号，乙队的三号对应甲队的{2}号", j1, j2, j3);
}
}
}
}
Console.ReadKey();
//输出结果为：乙队的一号对应甲队的3号，乙队的二号对应甲队的1号，乙队的三号对应甲队的2号

复制代码

作者: 李九一 时间: 2013-6-29 21:51
求加分

作者: 王靖远 时间: 2013-6-29 22:04
本帖最后由王靖远于 2013-6-29 22:05 编辑

public class Test1{
public static void main(String [] args){
Test1 instance = new Test1();
System.out.println("------------------第二题--------------------");
instance.printTest2();
System.out.println("------------------第三题--------------------");
instance.printTest3();
}
private void printTest2(){//打印第二题结果
for(int x=100;x<999;x++){
if(shuiXianHuaShu(x)&& huiWenShu(x) )
System.out.println(x);
else if(shuiXianHuaShu(x))
System.out.println(x);
}
}
private void printTest3(){//打印第三题结果
int temp = 0;
for(int x=100;x<200;x++){
if(!suShu(x) && !huiWenShu(x) && !shuiXianHuaShu(x))
temp += x;
}
System.out.println(temp);
}
private boolean suShu(int i ){
int count = 1;//初始化一个计数器
for(int x=1;x<i;x++){//
if(i%x==0)//这个数模从1到自身-1 如果==0计算器+1
count++;
}
if(count<=2)//计数器小于等于2说明这个数只有1和本身2个因子是素数。
return true;
else
return false;
}
private boolean huiWenShu(int i){
String iString = new String(i+"");
char[] chs = iString.toCharArray();
int i1 = Integer.parseInt(new String(chs[0]+""));
int i2 = Integer.parseInt(new String(chs[1]+""));
int i3 = Integer.parseInt(new String(chs[2]+""));
//以上取出一个数的个位十位百位。
StringBuilder iStringBuilder = new StringBuilder();
iStringBuilder.append(i3);
iStringBuilder.append(i2);
iStringBuilder.append(i1);
String newIString = new String(iStringBuilder);
int newI = Integer.parseInt(newIString);
//以上将原数的个位和百位调换并赋值给newI
if(i == newI)//判断原数与新数是否相等。
return true;
else
return false;
}
private boolean shuiXianHuaShu(int i){
String iString = new String(i+"");
char[] chs = iString.toCharArray();
int i1 = Integer.parseInt(new String(chs[0]+""));
int i2 = Integer.parseInt(new String(chs[1]+""));
int i3 = Integer.parseInt(new String(chs[2]+""));
//以上代码取出要判断的数的个位十位百位
if((Math.pow(i1, 3)+Math.pow(i2, 3)+Math.pow(i3, 3))==i)//判断
return true;
else
return false;
}
}

复制代码

只做了第二第三题。第一题做不好。

作者: .netNo1 时间: 2013-6-29 22:05

for (int i = 100; i < 1000; i++) //用i表示三位数
{
int bai = 0; //百位
int shi = 0; //十位
int ge = 0; //个位
int baiyushu = 0; //对百位进行求余后的数字
bai = i / 100;
baiyushu = i % 100; //两位数
shi = baiyushu / 10;
ge = baiyushu % 10;
if (i == bai * bai * bai + shi * shi * shi + ge * ge * ge &&bai==ge)
{
Console.Write("回文数：" + i + "\n");
}
else if (i == bai * bai * bai + shi * shi * shi + ge * ge * ge)
{
Console.Write("水仙花数：" + i + "\n");
}
}
Console.ReadKey();
//输出结果为：
//水仙花数：153
//水仙花数：370
//水仙花数：371
//水仙花数：407

复制代码

作者: ㄗs：/|丶hearts 时间: 2013-6-29 22:28

package com.java.test;
public class Team {
/**
* @param args
* 两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，
* 有人向队员打听比赛的名单。
* 甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] str1 = {"甲1号","甲2号","甲3号"};
String[] str2 = {"乙1号","乙2号","乙3号"};
for(int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++) {
//甲1号不和乙1号比
if (str1[i] == "甲1号" && str2[j] == "乙1号" ) {
continue;
}else
//甲3号不和乙1号和乙3号比
if (str1[i] == "甲3号" && (str2[j] == "乙1号" || str2[j] == "乙3号") ){
continue;
}else {
System.out.println(str1[i]+"--"+str2[j]);
}
}
}
}
}

复制代码

1.png (3.58 KB, 下载次数: 0)

作者: .netNo1 时间: 2013-6-29 22:44

int sum = 0;//和
for (int i = 101; i <= 200; i++) //用i表示三位数
{
int bai = 0; //百位
int shi = 0; //十位
int ge = 0; //个位
int baiyushu = 0; //对百位进行求余后的数字
bai = i / 100;
baiyushu = i % 100; //两位数
shi = baiyushu / 10;
ge = baiyushu % 10;
for (int k = 2; k < i; k++)
{
if (i % k == 0) //质数
{
if (i == bai * bai * bai + shi * shi * shi + ge * ge * ge) //水仙花数
{
break;
}
else if (bai == ge) //回文数
{
break;
}
else
sum += i;
}
else //素数
break;
}
}
Console.Write("既不是素数又不是回文数又不是水仙花数的总和为：" + sum );
Console.ReadKey();
//输出结果为：11900

复制代码

作者: 肥猫 时间: 2013-6-29 22:50
本帖最后由肥猫于 2013-6-30 21:53 编辑

题目一:

/*
题目一:两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
author:肥猫
*/
public class HomeWork {
public static void main(String[] args){
String[] a = new String[]{"a1","a2","a3"};//定义字符型数组A代表A队，三名队员分别为A1，A2，A3
String[] b = new String[]{"b1","b2","b3"};//B与A相似
for(int x=0;x<a.length;x++){
for(int y=0;y<b.length;y++){//两个FOR循环遍历两个数组
if(x==0&&y==0||x==0&&y==1||x==2&&y==0||x==2&&y==2){//这里是条件，当碰到题目所说情况时直接结束本次循环否则输出比赛名单。
continue;
}
else {
System.out.println(a[x]+":"+b[y]);
break;//这里是保证一名队员只能进行一次比赛，所以需要break。
}
}
}
}
}

复制代码

题目二:

/**
题目二：打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
author:肥猫
*/
public class Example
{
public static void main(String[] args)
{
for(int i=100;i<=999;i++)//三位数从100-999
{
int geWei,shiWei,baiWei;//定义个位、十位、百位
baiWei=i/100;
shiWei=(i-baiWei*100)/10;
geWei=i-baiWei*100-shiWei*10;
if(i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei && i==geWei*100+shiWei*10+baiWei*1)//同时满足既是水仙花数又是回文数才输出否则直接跳下一个IF
{
System.out.println(i);
}
else if(i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei){//若没有数满足上面判断则输出水仙花数
System.out.println(i);
}
}
}
}

复制代码

题目三:

/**
题目三：打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
思路：逆相思维，题目所求结果就是100到200的数之和减去既是回文数又是素数又水仙数的和。
author:肥猫
*/
public class Last
{
public static void main(String[] args)
{ int Sum = 0;//Sum为最后结果
int Sum1 = 0;//Sum1是100到200所有数之和
int Sum2 = 0;//Sum2是所有既是水仙数又是素数又是回文数的数之和
for(int i=100;i<=200;i++){
boolean b = false;//定义一个变量B来判断是否为素数,若为true则符合素数.
Sum1+=i;
int geWei,shiWei,baiWei;//定义个位、十位、百位
baiWei=i/100;
shiWei=(i-baiWei*100)/10;
geWei=i-baiWei*100-shiWei*10;
for(int j=2;j<=Math.sqrt(i);j++){
if(i%j==0){
b = false;
break;
}
else{
b=true;
}
if(b==true&&i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei && i==geWei*100+shiWei*10+baiWei*1){
Sum2+=i;//这整个IF语句是判断是否符合三种数条件的数,若符合则求和.
}
}
}
Sum=Sum1-Sum2;
System.out.println(Sum);
}
}

复制代码

本人菜鸟一枚,刚接触JAVA,答的不好请多谅解,多指教~~.

作者: 杨晓燕 时间: 2013-6-29 22:52
本帖最后由杨晓燕于 2013-6-29 22:53 编辑

我不会做啊，好不容易用最笨的办法做出来了，请大家不要笑哦，然后希望版主指出可以改进的地

/*
需求：打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
思路：
1,要打印所有三位数中既是水仙数又是回文数的数，使用for循环，定义x，从100遍历到999
2，定义一个容器，把水仙数存起来
3，判断x是否为水仙数，如果是，存入容器，再判断是否为回文数，如果也是则打印
4，定义一个自增变量i，初始化为0，每打印一次既是水仙数又是回文数的数，自增一次，如果i=0；
则打印存入容器的所有水仙数。
*/
class Test2_2
{
public static void main(String[] args)
{
StringBuffer sb=new StringBuffer();//定义一个容器，用来存水仙数
int i=0;
int a,b,c,z;
for(int x=100;x<=999;x++)
{
a=x/100;//获取百位数
b=x/10-a*10;//获取十位数
c=x-a*100-b*10;//获取个位数
z=c*100+b*10+a;//将x各位位置置换
if(x==a*a*a+b*b*b+c*c*c)
{
sb.append(x+" ");//是水仙数则，存入容器中，并加上空格，以区分开来
if(x==z)//判断是否为回文数
{
System.out.println(x);
i++;//如果i增加了说明有回文数
}
}
}
if(i==0)//i还是初始值，说明没有回文数
System.out.println(sb);//打印存在容器中的水仙数
}
}

复制代码

2-2.png (3.14 KB, 下载次数: 0)

作者: 杨晓燕 时间: 2013-6-29 22:54
本帖最后由杨晓燕于 2013-6-30 09:25 编辑

/*

需求：打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。

思路：

1，因为是求和，所以定义变量sum记录满足条件的数的和

2，使用for循环遍历100，到200之间的数

3，判断该数是否满足以上条件，如果都不满足，则求和

*/

class Test2_3

{

public static void main(String[] args)

{

int sum=0;

int a,b,c,s;

for(int i=100;i<=200;i++)

{

a=i/100;//获取百位数

b=i/10-a*10;//获取十位数

c=i-a*100-b*10;//获取个位数

//将x各位位置置换

s=a*a*a+b*b*b+c*c*c;

for(int y=2;y<=i/2;y++)//又定义一个for循环，以便求出x是否为素数

{

if(i%y==0&&a!=c&&i!=s)

{

sum+=i;

break;

}

}

}

System.out.println(sum);

}

}

复制代码
发现昨日的做错了，重新编辑了一下

2-3.png (2.25 KB, 下载次数: 0)

作者: 李九一 时间: 2013-6-29 22:56

/*
* 1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，
* 有人向队员打听比赛的名单。甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，
* 请编程找出两队的赛手名单。`
* */
package com.itheima;
public class test11 {
public static void main(String[] args) {
char a,b,c;/*a是甲队1号对手，b是甲队2号对手，c甲队3号对手*/
for(a='i';a<='k';a++)
for(b='i';b<='k';b++){
if(a!=b)
for(c='i';c<='k';c++){
if(a!=c&&b!=c){
if(a!='i'&&c!='i'&&c!='k')
System.out.println("甲队1号 VS "+a+"\n甲队2号 VS"+b+"\n甲队3号 VS"+c);
}
}
}System.out.println("i,j,k分别代表乙队的1，2，3号");
}
}

复制代码

比赛匹配.jpg (136.98 KB, 下载次数: 0)

结果

作者: 李九一 时间: 2013-6-29 23:23
/*2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
 水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
 回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
*/
package com.itheima;
public class test12 {
//判断是否是水仙花数
public static boolean IsNarcissusNumber(int n){
 int i, j, k;
 i = n / 100;
 j = n / 10%10;
 k = n % 10;
 if (i * i * i + j * j * j + k * k * k == n)
 return true;
 else
 return false;
 }
//判断是否是回文数
public static boolean isHuiWenShu(int n){
 int i, j, k;
 i = n / 100;
 j = n / 10%10;
 k = n % 10;
 if (i + j *10+ k * 100== n)
 return true;
 else
 return false;
}

public static void main(String[] args) {
for(int i=100;i<1000;i++){
if(IsNarcissusNumber(i)&&isHuiWenShu(i))//判断即是水仙数又是回文数的数
System.out.print(" "+i);
else if(IsNarcissusNumber(i)){//只打印水仙花数
System.out.print(" "+i);
}
}
}
}

水仙花数.jpg (100.44 KB, 下载次数: 0)

作者: ytblght55 时间: 2013-6-29 23:40

public class Test {
/**
*
1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，
抽签决定比赛名单，有人向队员打听比赛的名单。
甲队1号说不和乙队的1号比，
甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("这是第一题的要求,比赛的名单");
getVs();//得到比赛的名单
System.out.println("打印即是水仙花又是回数的数,如果没有打印水仙花数");
getNumber();//得到水仙花数或者回数的数
System.out.println("打印100-200不是素数不是回数也不是水仙花数的和");
getSum();//得到要求三的方法
}
//定义2队分别代表甲队成员a,b,c.乙队的选手x,y,z.
//判断比赛的名单,条件是甲队的a不和x进行比赛.甲队的c不和乙队的x,y比
public static void getVs()
{ //定义2队分别代表甲队成员a,b,c.乙队的选手x,y,z.
char i,j,k; //定义第三方变量分别表示:i是a的对手，j是b的对手，k是c的对手
for(i='x';i<='z';i++) {//重点就是a,b,c和x,y,z按照ASCII值来看待
for(j='x';j<='z';j++){
if(i!=j) //
for(k='x';k<='z';k++){
if(i!=k && j!=k){ //
if(i!='x' && k!='x'&& k!='z')
System.out.println(" a Vs "+i+"\n b Vs "+j+"\n c Vs "+k);
}
}
}
}
}
/*打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。*/
public static void getNumber()
{
for (int i = 100; i < 999; i++) {//遍历三位数,判断
int a=i%10;//个位数
int b=i/10%10;//十位数
int c=i/10/10%10;//百位数
if (a*a*a+b*b*b+c*c*c==i&&a==c) {//判断又是回数又是水仙花水的数字
System.out.print(i+" ");
}
else if(a*a*a+b*b*b+c*c*c==i){//如果是水仙花数输出
System.out.print(i+" ");
}
}
System.out.println();
}
//打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
public static void getSum()
{
int sum=0;//用sum来接收和
loop:for (int i = 100; i <=200; i++) {//遍历100-200之间的数
int a=i%10;//个位数
int b=i/10%10;//十位数
int c=i/10/10%10;//百位数
for (int j = 2; j <i; j++) {//被除数从2到i
if (i%j==0&&a!=c&&a*a*a+b*b*b+c*c*c!=i) {//这些数要满足不是素数不是水仙花数也不是回数
System.out.print(i+" ");
sum+=i;//记录sum的值
continue loop;//跳出内循环到外循环
}
}
}
System.out.println();
System.out.print("满足条件的数的和sum="+sum);
}
}

复制代码

运行的结果完美符合题目的要求!!!!

作者: 李九一 时间: 2013-6-29 23:46

// 3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
package com.itheima;
public class test13 {
//判断是否是水仙花数
public static boolean IsNarcissusNumber(int n){
int i, j, k;
i = n / 100;
j = n / 10%10;
k = n % 10;
if (i * i * i + j * j * j + k * k * k == n)
return true;
else
return false;
}
//判断是否是回文数
public static boolean isHuiWenShu(int n){
int i, j, k;
i = n / 100;
j = n / 10%10;
k = n % 10;
if (i + j *10+ k * 100== n)
return true;
else
return false;
}
public static void main(String[] args) {
int sum=0;
for(int i=100;i<=200;i++){
if(IsNarcissusNumber(i)||isHuiWenShu(i))
continue;
else
sum+=i;
}
System.out.println("100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和"+sum);
}
}

复制代码

非水仙花和回文数的和.jpg (115.14 KB, 下载次数: 0)

作者: lou413 时间: 2013-6-29 23:49

运行结果

作者: ytblght55 时间: 2013-6-29 23:54
楼主给分哦亲!!

作者: 傲鸽 时间: 2013-6-30 00:03

作者: 傲鸽 时间: 2013-6-30 00:08
楼主您好，我不知道怎么把帖子设置成仅作者可见

作者: lou413 时间: 2013-6-30 00:25

运行结果

作者: 张海龙 时间: 2013-6-30 13:30
/*
第三题
*/
class number{
number(int x){
this.m=x;
}
public boolean shuixian(int m){//判断水仙数的函数
int x=m/100;
int y=(m%100)/10;
int z=m%10;
int n=x*x*x+y*y*y+z*z*z;
if(m==n)
return true;
else return false;
}
public boolean huiwen(int m){//判断回文书的函数
int x=m/100;
int y=m%10;
if(x==y)
return true;
else return false;
}
public boolean sushu(int m){
int n=m/2;
int singal=0;//设置判断素数标志
for(int i=2;i<=n;i++){
if(m%i==0){
singal=1;;
}
}
if(singal==1)//标志改变，不是素数
return false;
else return true;
}
private int m;
}
public class Test4 {
public static void main(String[] args){
int sum=0;
for(int i=100;i<=200;i++){
number num=new number(i);
if((num.huiwen(i)==false)&&(num.sushu(i)==false)&&(num.shuixian(i)==false)){
sum+=i;
}
}
System.out.println(sum);
}
}
/*
刚学了面向对像，就用类写了下，第二题
*/
/*
定义一个number类，
*/
class Number{
Number(int x){
this.x=x;
}
public boolean shuixian(int m){//判断水仙数的函数
int x=m/100;
int y=(m%100)/10;
int z=m%10;
int n=x*x*x+y*y*y+z*z*z;
if(m==n)
return true;
else return false;
}
public boolean huiwen(int m){//判断回文书的函数
int x=m/100;
int y=m%10;
if(x==y)
return true;
else return false;
}
private int x;
}

class Test3 {
public static void main(String[] args){
for(int i=100;i<1000;i++){
Number num=new Number(i);//创建number对象
if((num.shuixian(i)==true)&&(num.huiwen(i)==true))//判断即是否是水仙数又是回文数的数
System.out.println(i);
else if(num.shuixian(i)==true)//判断是否是水仙数
System.out.println(i);
}
}

}
我截的图发不上去。怎么办。我第一题不会做，麻烦你把答案发我邮箱809494869@qq.com。我看看，谢谢

作者: vicoooo 时间: 2013-6-30 15:46

import java.util.HashMap;
/*
1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
*/
public class Test{
//HashMap 存储选手被选中状态来做
public static void main(String args[]){
String[] m ={"J3","J1","J2"};//甲队-先按提供信息详细程度把他们排好（容易的先入手）
String[] n ={"Y1","Y2","Y3"};//乙队
HashMap<String,Integer> hm = new HashMap<String,Integer>();
//存储队员已有对手了吗
//初始都没有对手 ,定义0代表还没有对手
hm.put("J1",0);
hm.put("J2",0);
hm.put("J3",0);
hm.put("Y1",0);
hm.put("Y2",0);
hm.put("Y3",0);
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
//甲队1号说不和乙队的1号比
if(i==1&&j==0)
continue;
//甲队的3号说不和乙队的1号和3号比
if(i==0&&(j==0||j==2))
continue;
//将没有对手的选手找出
if(hm.get(m[i])==0&&hm.get(n[j])==0){
//都没有对手就把他们设成对手
//他们的状态改为已有对手
hm.remove(m[i]);
//改成已有对手
hm.put(m[i],1);
hm.remove(n[j]);
//改成已有对手
hm.put(n[j],1);
System.out.println(m[i]+" vs "+n[j]);
}
}
}
}
}

复制代码

答案：
J3 vs Y2
J1 vs Y3
J2 vs Y1
------------------------------------------------
题目二：

import java.util.ArrayList;
import java.util.List;
/*
2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
*/
public class Test02 {
public static void main(String[] args) {
List<Integer> list = fun1();
//输出既是回文数又是水仙数的数，如果没有这个数那么输出所有的水仙数
if(list.size()!=0){
for(Integer i : list){
System.out.println(i);
}
}else{
//输出水仙数
shuiXina();
}
}
//找出所有三位数是水仙数的数例如:153=1^3+5^3+3^3
public static void shuiXina(){
int a1,a2,a3;
for(int i=100;i<1000;i++){
a1 = i/100;
a2 = i%100/10;
a3 = i%10;
if(a1*a1*a1+a2*a2*a2+a3*a3*a3==i){
System.out.println(i);
}
}
}
//找出既是水仙数又是回文数的数
public static List<Integer> fun1(){
int a1,a2,a3;
List<Integer> list = new ArrayList<Integer>();
for(int i=100;i<1000;i++){
a1 = i/100;
a2 = i%100/10;
a3 = i%10;
//既是水仙数又是回文数的数
if(a1==a3&&a1*a1*a1+a2*a2*a2+a3*a3*a3==i){
list.add(i);
}
}
return list;
}
}

复制代码

答案：
153
370
371
407
-------------------------
题目三：

// 3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
public class Test03 {
public static void main(String[] args){
int a1,a2,a3;
int sum = 0;
for(int i=100;i<=200;i++){
a1 = i/100;
a2 = i%100/10;
a3 = i%10;
//既不是回文数又不是素数又不是水仙数--第一步缩小范围，找出既不是回文数又不是水仙数的数
if(!(a1==a3||a1*a1*a1+a2*a2*a2+a3*a3*a3==i)){
for(int j=2;j<i-1;j++){
//找出又不是素数的数并求和
if(i%j==0){
System.out.println(i);
sum += i;
break;
}
}
}
}
System.out.println("sum="+sum);
}
}

复制代码

答案：
如果包括100和200
sum=11125
如果只包括100
sum=10925
如果都不包括
sum=10825

2013-06-30_154124.jpg (5.78 KB, 下载次数: 0)

2013-06-30_154200.jpg (7.41 KB, 下载次数: 0)

2013-06-30_154623.jpg (6.05 KB, 下载次数: 0)

作者: 王楚鑫 时间: 2013-6-30 18:44
第二题

/*
需求：打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
思路： 1.三位数循环
2.判断是否是水仙数
3.若是水仙数，判断是否是回文数，并标识
4.若存在即是水仙数又是回文数的数，则打印输出，否则保存当前水仙数
*/
import javax.swing.JOptionPane;
public class Flower
{
public static boolean sNumber(int i)//定义函数，判断是否是水仙数(水仙数是指一个三位数，其个位数立方和等于本身)
{
int ge,shi,bai;
bai=i/100;
shi=i%100/10;
ge=i%10;
if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai)//满足水仙数条件，返回真
return true;
return false;
}
public static boolean hNumber(int i)//定义函数，判断是否是回文数(回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231)
{
int ge,bai;
bai=i/100;
ge=i%10;
if(ge==bai)
return true;//满足回文数条件，返回真
return false;
}
public static void main(String args[])
{
int[] s=new int[1000];//保存水仙数
int m=0;//标识水仙数的个数
int n=0;//标识即是水仙数又是回文数的数的个数
for(int i=100;i<1000;i++)
{
if(sNumber(i))//调用判断是否是水仙花数的函数
{
if(hNumber(i))//调用判断是否是回文数的函数
{
System.out.print(i+" ");//把满足条件的数输出
n++;
if(n!=0)
continue;
}
s[m++]=i;
}
}
if(n==0)//如果没有即是水仙数又是回文数的数字，输出所有水仙数
{
System.out.println("不存在即是水仙数又是回文数的三位数，三位数的水仙数如下：");
for(int i=0;i<m;i++)
System.out.print(s[i]+" ");
}
}
}

复制代码

第三题

/*
需求：打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
思路： 1.100到200之间循环
2.判断是否是水仙数，回文数，素数
3.同时满足此条件的则累加求和，打印输出
*/
import javax.swing.JOptionPane;
public class Sum
{
public static boolean sNumber(int i)//定义函数，判断是否是水仙数（水仙数是指一个三位数，其个位数立方和等于本身）
{
int ge,shi,bai;
bai=i/100;
shi=i%100/10;
ge=i%10;
if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai)//满足水仙数条件，返回真
return true;
return false;
}
public static boolean hNumber(int i)//定义函数，判断是否是回文数（回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231）
{
int ge,bai;
bai=i/100;
ge=i%10;
if(ge==bai)
return true;//满足回文数条件，返回真
return false;
}
public static boolean Prime(int i)//定义函数，判断是否是素数（素数，只能被1和本身整除的数）
{
int j;
for(j=2;j<i/2;j++)
{
if(i%j==0)break;
}
if(j>i/2)
return true;
return false;
}
public static void main(String args[])
{
int sum=0;//保存和
for(int i=100;i<200;i++)
{
if(!sNumber(i) && !hNumber(i) && !Prime(i))//调用函数选择即不是回文数又不是素数又不是水仙数的数累加求和
{
//System.out.print(i+" ");
sum+=i;
}
}
System.out.println("sum="+sum);
}
}

复制代码

作者: 王楚鑫 时间: 2013-6-30 21:36

/*
需求：打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
思路： 1.三位数循环
2.判断是否是水仙数
3.若是水仙数，判断是否是回文数，并标识
4.若存在即是水仙数又是回文数的数，则打印输出，否则保存当前水仙数
*/
import javax.swing.JOptionPane;
public class Flower
{
public static boolean sNumber(int i)//定义函数，判断是否是水仙数(水仙数是指一个三位数，其个位数立方和等于本身)
{
int ge,shi,bai;
bai=i/100;
shi=i%100/10;
ge=i%10;
if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai)//满足水仙数条件，返回真
return true;
return false;
}
public static boolean hNumber(int i)//定义函数，判断是否是回文数(回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231)
{
int ge,bai;
bai=i/100;
ge=i%10;
if(ge==bai)
return true;//满足回文数条件，返回真
return false;
}
public static void main(String args[])
{
int[] s=new int[1000];//保存水仙数
int m=0;//标识水仙数的个数
int n=0;//标识即是水仙数又是回文数的数的个数
for(int i=100;i<1000;i++)
{
if(sNumber(i))//调用判断是否是水仙花数的函数
{
if(hNumber(i))//调用判断是否是回文数的函数
{
System.out.print(i+" ");//把满足条件的数输出
n++;
if(n!=0)
continue;
}
s[m++]=i;
}
}
if(n==0)//如果没有即是水仙数又是回文数的数字，输出所有水仙数
{
System.out.println("不存在即是水仙数又是回文数的三位数，三位数的水仙数如下：");
for(int i=0;i<m;i++)
System.out.print(s[i]+" ");
}
}
}

复制代码

第三题

/*
需求：打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
思路： 1.100到200之间循环
2.判断是否是水仙数，回文数，素数
3.同时满足此条件的则累加求和，打印输出
*/
import javax.swing.JOptionPane;
public class Sum
{
public static boolean sNumber(int i)//定义函数，判断是否是水仙数（水仙数是指一个三位数，其个位数立方和等于本身）
{
int ge,shi,bai;
bai=i/100;
shi=i%100/10;
ge=i%10;
if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai)//满足水仙数条件，返回真
return true;
return false;
}
public static boolean hNumber(int i)//定义函数，判断是否是回文数（回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231）
{
int ge,bai;
bai=i/100;
ge=i%10;
if(ge==bai)
return true;//满足回文数条件，返回真
return false;
}
public static boolean Prime(int i)//定义函数，判断是否是素数（素数，只能被1和本身整除的数）
{
int j;
for(j=2;j<i/2;j++)
{
if(i%j==0)break;
}
if(j>i/2)
return true;
return false;
}
public static void main(String args[])
{
int sum=0;//保存和
for(int i=100;i<200;i++)
{
if(!sNumber(i) && !hNumber(i) && !Prime(i))//调用函数选择即不是回文数又不是素数又不是水仙数的数累加求和
{
//System.out.print(i+" ");
sum+=i;
}
}
System.out.println("sum="+sum);
}
}

复制代码

这次能不能看到啊？？？【挠头】

作者: ytblght55 时间: 2013-6-30 21:41

ytblght55 发表于 2013-6-29 23:54
楼主给分哦亲!!

楼主啊.用字母和数字不都一样吗....... 用字母更直观...数字更不直观本来想用个二维数组的...

作者: 张海龙 时间: 2013-6-30 21:47

张海龙发表于 2013-6-30 13:30
/*
第三题
*/

我截的图粘贴不上去

作者: ytblght55 时间: 2013-6-30 21:51

ytblght55 发表于 2013-6-29 23:54
楼主给分哦亲!!

有道理... 问题是怎么遍历这中带中文字的字符串...

作者: 水。。。海 时间: 2013-7-1 00:26
搞了半天累死我了终于搞完了第一题

/**1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
*/
/*思路：1.把两队的球员分别用连续的字母表示。
2.然后通过for循环来判断筛选
*/
class BiSai
{
public static void main(String[] args)
{
char i,j,k;
//定义甲队的选手为a b c
//乙队的选手为l m n
char a='a',b='b',c='c';
char l,m,n;
for(i='m';i>'l'&&i<'n' ;i++ ) //用第三方变量记录甲队3号要比赛的对手，并且根据ASCII码这几个数在一起来思考
{
c=i;
}
for(j='l';j>='l'&&j<='n';j++)
{
if(j!=c)
a=j;
}
for(k='l';k>='l'&&k<'n';k++)
{
if(k!=a&&k!=c)
b=k;
}
System.out.println("a vs "+a+" b vs "+b+" c vs "+c);
}
}

复制代码

第二题

/**2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
*@author 倪成伟
*/
/*
思路：1.将三位数的各个位取出用变量代替
2.通过for循环来实现遍历所有三位数
3.通过StringBuffer来接受所需值
*/
class Shu
{
public static void main(String[] args)
{
int x=1,y,z,s,h,m,n,i=0,a=0;
StringBuffer sb=new StringBuffer();
StringBuffer sb1=new StringBuffer(); //用StringBuffer接受所要值
while(x>0&&x<=9) //while循环控制百位数
{
for(y=0;y>=0&&y<10;y++)
{
for(z=0;z>=0&&z<10;z++)
{
m=(x*100+y*10+z); //将xyz转换为三位数付给m
n=(x*x*x+y*y*y+z*z*z); //三位数各个位三次方后付给n
h=(z*100+y*10+x); //各位和百位互换后的值付给h
if(m==n&&m==h) //判断看是否是所需值
{
sb.append(m+" ");
}
if(m==n)
{
sb1.append(m+" ");
}
}
}
x++;
}
System.out.print("即是水仙数又是回文数的数：");
System.out.println(sb);
System.out.print("全部水仙数：");
System.out.println(sb1);
}
}

复制代码

第三题

/**
*3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
*@author 倪成伟
*/
/*思路：1.通过for循环找出不是素数的数。
2.然后建立一个函数确定所需数。
3.通过累加计数完成求和。
*/
class ShuHe
{
public static void main(String[] args)
{
int x,sum=0;
for(x=100;x<=200;x++)
{
w:for(int m=2;m<x;m++) //用循环来判断是不是素数
{
if(x%m==0)
{
sum+=panDuan(x); //累加计数
break w; //选中数后跳出循环
}
}
}
System.out.println(sum);
}
public static int panDuan(int a) //定义一个函数输入不是素数的数并判断是不是水仙数和回文数
{
int x,y,z,h,sum=0,n;
x=a/100;
y=(a-100)/10;
z=(a-x*100-y*10);
n=(x*x*x+y*y*y+z*z*z);
h=(z*100+y*10+x);
if(a!=n&&a!=h)
sum=a;
return sum; //返回选定的值
}
}

复制代码

BVO6$FK@U6~C0EI77G~E6IW.jpg (9.28 KB, 下载次数: 0)

作者: ㄗs：/|丶hearts 时间: 2013-7-1 00:44
本帖最后由ㄗs：/|丶hearts 于 2013-7-1 00:49 编辑

第2题第3题放一起了

package com.java.test;
public class NumTest {
/**
*
* @param args
* 2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
* 水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
* 回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
*
* 3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
*
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
for(int i = 100; i < 1000; i++){
//如果即是水仙数又是回文数打印该数否则打印所有水仙数
if(isDoffodils(i) && isHuiwen(i)){
System.out.println(i);
}else {
//打印所有水仙数
if(isDoffodils(i))
System.out.println(i);
}
}
System.out.println("---------------------");
//打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
int sum = 0;
for(int i = 100; i <= 200; i++){
//即不是回文数又不是素数又不是水仙数
if(!isDoffodils(i) && !isHuiwen(i) && !isPrime(i)){
//System.out.println(i);
sum += i;
}
}
System.out.println("sum="+ sum );
}
//判断一个三位数是不是水仙花数
public static Boolean isDoffodils(int i){
//百位上的数字
int x = i/100;
//十位上的数字
int y = i%100/10;
//个位上的数字
int z = i%10;
//如果是水仙花数返回true 否则返回false
if(i == (Math.pow(x, 3)+Math.pow(y, 3)+Math.pow(z, 3)) ){
return true;
}
return false;
}
//判断一个三位数是不是回文数
public static Boolean isHuiwen(int i){
//百位上的数字
int x = i/100;
//十位上的数字
int y = i%100/10;
//个位上的数字
int z = i%10;
//如果是水仙花数返回true 否则返回false
if(i == (z*100 + y*10 + x))
return true;
return false;
}
//判断一个数是不是素数
//素数只能被1和它本身整除 -- 如果某个大于1小于它的数能被这个数本身整除，那么这个数就不是素数；反之则是素数
public static Boolean isPrime(int i ) {
for(int j = 2; j < i; j++){
if(i % j == 0){
return false;
}
}
return true;
}
}

复制代码

QQ图片20130701004300.jpg (6.19 KB, 下载次数: 0)

作者: emos-c 时间: 2013-7-1 10:05
本帖最后由 emos-c 于 2013-7-1 10:15 编辑

用的都是最简单的知识来做的。
2.打印出所有三位数中既是水仙数又是回文数的数，如果没有这个数，那么输出所有的水仙数。
思路
1.首先需要遍历所有的三位数 100-999。用3个变量来表示一个三位数 a*100+b*10+c
2.水仙数：a*a*a+b*b*b+c*c*c=a*100+b*10+c。回文数：a=c
3.当没有既是水仙数又是回文数的数时，输出水仙数。所以要分开判断，当满足既是水仙数又是回文数时，输出打印。如果不能同时满足
时，就把水仙数输出。

class ShuiXianShu
{
public static void main(String[] args)
{
ShuiXian sx=new ShuiXian();
sx.getShuiXianShu();
}
}
class ShuiXian
{
//这其实是一个判断标记，如果既是水仙数又是回文数，该变量将被赋值。如果循环结束后num仍为0，说明没有符合条件的数。
int num=0;
public void getShuiXianShu()
{
int a,b,c;
//通过三个for循环实现用a，b，c三个变量从100到999遍历
for (a=1;a<10 ;a++ )
{
for (b=0;b<10 ;b++ )
{
for (c=0;c<10 ;c++ )
{
//判断是否同时是回文数和水仙数。如果是，就输出打印。也可以分成两次判断，先判断水仙数并用毕老师在进制转换里讲到的StringBuffer，用append方法把水仙数记下来
if (a==c && a*100+b*10+c==a*a*a+b*b*b+c*c*c)
{
num=a*100+b*10+c;
System.out.println(num);
}
}
}
}
//判断如果没有同时满足的数，就只打印水仙数。在这里如果用打印StringBuffer对象把存储的水仙数打印也可以，就不用重新判断了，但是元素之间不会用逗号隔开，所以又判断了一次。
if (num==0)
{
System.out.println("没有既是水仙数又是回文数的数，所有的水仙数");
for (a=1;a<10 ;a++ )
{
for (b=0;b<10 ;b++ )
{
for (c=0;c<10 ;c++ )
{
if (a*100+b*10+c==a*a*a+b*b*b+c*c*c)
{
num=a*100+b*10+c;
System.out.println(num);
}
}
}
}
}
}
}
//输出结果：没有既是水仙数又是回文数的数，所有的水仙数153，370，371，407

复制代码

3.打印出100到200之间既不是回文数，又不是素数，又不是水仙数的所有数的和。
思路：
1.看到关键词100-200之间，求和，知道要用累加思想，遍历这些数
2.遍历过程中，加入判断语句，如果不是回文数，水仙数或素数，就进行累加动作，并用一个变量记住累加的结果。
3.判断时，需要用3个变量来表示一个三位数 a*100+b*10+c。水仙数：a*a*a+b*b*b+c*c*c=a*100+b*10+c。回文数：a=c
4.素数就是在大于1的自然数中，不能被其它自然数整除的数。判断素数代码较长，需要单独封装成一个函数。
5.最后变量中的数就是所要的结果。把它作为返回值传递给调用者。

class QiuHeTest
{
public static void main(String[] args)
{
QiuHe qh=new QiuHe();
System.out.println("它们的和是"+qh.getSum());
}
}
class QiuHe
{
int a,b,c;
public int getSum()
{
int sum=0;
//通过三个for循环实现用a，b，c三个变量从100到200遍历
for (a=1;a<=2;a++ )
{
for (b=0;b<10 ;b++ )
{
for (c=0;c<10 ;c++ )
{
//分别判断该数值是否为回文数，水仙数和素数。素数调用了单独的方法。如果满足不是以上三者，就进行累加。
if (a!=c && a*100+b*10+c!=a*a*a+b*b*b+c*c*c && SuShu(a,b,c))
sum=sum+a*100+b*10+c;
}
}
}
return sum;
}
//判断100到200之间的一个数是不是素数，就先要把这个数传进来
public boolean SuShu(int a,int b,int c)
{
int x=a*100+b*10+c;
for (int y=2;y<x ;y++ )
{
if (x%y==0)
return false;
}
return true;
}
}
//输出结果：它们的和是 6460

复制代码

作者: 殷挥笔 时间: 2013-7-1 10:09

package Demo;
public class DemoTi1 {
/**
* @param args
*/
/*
* 最终对战：
* 甲1-乙3
甲2-乙1
甲3-乙2
*/
static String[] team1 = {"甲1","甲2","甲3"};
static String[] team2 = {"乙1","乙2","乙3"};
public static void main(String[] args) {
System.out.println("最终的对阵情况为：");
for(int i =0;i< team1.length;i++){
for(int j = 0;j <team2.length;j++){
if((team1[i] =="甲1" && team2[j]=="乙1")||(team1[i] =="甲1" && team2[j]=="乙2")){
continue;
}else if((team1[i] =="甲2" && team2[j]=="乙2")||(team1[i] =="甲2" && team2[j]=="乙3")){
continue;
}else if((team1[i] =="甲3" && team2[j]=="乙1")||(team1[i] =="甲3" && team2[j]=="乙3")){
continue;
}else{
System.out.println(team1[i] + " vs " + team2[j]);
}
}
}
}
}

复制代码

运行结果为：

最终的对阵情况为：
甲1 vs 乙3
甲2 vs 乙1
甲3 vs 乙2

作者: 殷挥笔 时间: 2013-7-1 10:42

package Demo;
public class DemoTi2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=100;i<=999;i++){
if(ShuiXian(i)==true && HuiWen(i)==true){
System.out.println("既是水仙数又为回文数的数："+i);
}else if(ShuiXian(i)==true){
System.out.println("水仙数："+i);
}
}
}
public static boolean ShuiXian(int x){
int i,j,k;
i = x/100;
j = x%100/10;
k = x%10;
if(x==i*i*i+j*j*j+k*k*k){
return true;
}else{
return false;
}
}
public static boolean HuiWen(int x){
int i,j,k;
i = x/100;
j = x%100/10;
k = x%10;
int[] b = new int[]{k,j,i};
if(x == k*100+j*10+i){
return true;
}else{
return false;
}
}
}

复制代码

输出结果为：
水仙数：153
水仙数：370
水仙数：371
水仙数：407

作者: 殷挥笔 时间: 2013-7-1 11:34

package Demo;
public class DemoTi3 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int He = 0;
for(int i=100;i<=200;i++){
if(SuShu(i) == false && ShuiXian(i) == false && HuiWen(i) ==false){
He += i;
}
}
System.out.println("和为:"+He);
}
public static boolean ShuiXian(int x){
int i,j,k;
i = x/100;
j = x%100/10;
k = x%10;
if(x==i*i*i+j*j*j+k*k*k){
return true;
}else{
return false;
}
}
public static boolean HuiWen(int x){
int i,j,k;
i = x/100;
j = x%100/10;
k = x%10;
int[] b = new int[]{k,j,i};
if(x == k*100+j*10+i){
return true;
}else{
return false;
}
}
public static boolean SuShu(int i){
int j;
boolean fag = false;
for (j = 2; j < i; j++){
if (i % j== 0){
break;
}
}
if(j<i){
}
else{
fag = true;
}
return fag;
}
}

复制代码

运行结果为：
和为:11125

作者: longlangcx 时间: 2013-7-1 13:18
第一题：

/*
* 题目：两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，
* 有人向队员打听比赛的名单。甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，
* 请编程找出两队的赛手名单。
*
* 思路：寻找对战名单，相当于确定一组数据对，但甲队的人员顺序是一定的，最终目的就是要寻找对应的
* 乙队人员的出战顺序。相当于将三个不同的数按一定顺序填入到三个坑中。填入的条件首先肯定是
* 要保证三个数各不相同，相当于对1,2,3三个数进行全排列。满足了各不相同的条件，还要满足题目
* 所给的条件，即在全排列中将第一个坑里为1的，和第三个坑里为1或3的排除掉，剩下的那组数就是名单。
*
* 步骤：首先定义a,b,c三个变量（相当于三个坑）分别用于存放甲队1、2、3号球员的对手。
* 然后通过循环枚举出可能值往里面填数。填的过程中排除a、b、c三者各不相等
* 并且保证a != 1, c!= 1和3.剩下的就是乙队可能的出战顺序。
*/
public class VsList {
public static void main(String[] args) {
int a, b, c; //a, b, c分别用于存储甲队1、2、3号球员的对手编号
for(a = 1; a <= 3; a++){
for(b = 1; b <= 3; b++){ //先对a,b的取值进行枚举
if(a != b){ //为true表示甲队一号二号球员的对手不同
for(c = 1; c <= 3; c++){ //枚举c的取值
if(a != c && b != c){ //至此为true表示甲队三名球员对手各不相同
if(a != 1 && c != 1 && c != 3){ //队友特殊条件判断
System.out.println("甲队1号 vs 乙队" + a + "号");
System.out.println("甲队2号 vs 乙队" + b + "号");
System.out.println("甲队3号 vs 乙队" + c + "号");
}
}
}
}
}
}
}
}/* Output:
甲队1号 vs 乙队3号
甲队2号 vs 乙队1号
甲队3号 vs 乙队2号
*///:~

复制代码

第二题：

/*
* 题目：打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
* 水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
* 回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
*
*
* 思路： 1.既然是在所有三位数中选择，且判断方式没有简单规律需要一个数一个数的判断，那么就要考虑
* 进行一次从100~999之间的遍历，每个数分别判断是否为水仙数或回文数
*
* 2.判断水仙数和回文数都是对3位数中各位数进行操作，因此需要提取出三位数的各数位上的值
*
* 3.题目要求没有二者皆是的才打印水仙数。那么在遍历过程中，无法判断是否打印，要在遍历结束后
* 才知道是否包含有二者皆是的数。因此需要对水仙花数进行保存，并且记录下是否包含二者皆是的数。
*
*
* 步骤：先弄3个int变量准备好保存百位、十位、个位的处理结果（只在循环里有用，放for里了）
* 保存水仙数使用ArrayList（因数量未知）
* 定义一个int计数器用来记录水仙数的个数，这个只是为了确定是否有，所以定义个boolean也行
* 之后弄个循环开始遍历，提取数位可以用数学方法，也可以借助字符串，这里用了前者
* 剩下的就没啥好说的了，各种if判断下条件选择输出内容就OK了
*/
import java.util.ArrayList;
public class FindNum {
public static void main(String[] args) {
ArrayList<Integer> shuiXianList = new ArrayList<Integer>(); //用于存储水仙数
int count = 0; //记录既是水仙数又是回文数的数的个数
for(int i = 100, a, b, c; i < 1000; i++){ //a,b,c用于保存百位、十位、个位的处理结果
a = (int)Math.pow(i / 100, 3); //取出百位值做立方运算
b = (int)Math.pow(i % 100 / 10, 3); //取出十位值做立方运算
c = (int)Math.pow(i % 10, 3); //取出个位值做立方运算
if (i == a + b + c){
if(a == c){ //两数的立方相等说明两数相等
System.out.println(i + "既是水仙数又是回文数");
count++; //一个回文水仙计数器
}
shuiXianList.add(i);
}
}
if(count == 0){ //通过判断计数器是否正值确定是否有回文水仙数
System.out.println("没有找到既是水仙数又是回文数的数");
System.out.println("水仙数有：");
for(int i : shuiXianList){ //foreach循环，遍历ArrayList
System.out.println(i);
}
}
}
}/* Output:
153
370
371
407
*///:~

复制代码

第三题：

/*
* 题目：打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
*
* 思路：回文数--个位百位相同
* 水仙数--各位的三次方之和等于本身
* 素数----除1、本身外，无法被其他整数整除
* 设置一个累加器，每找到一个符号要求的，就加进去
* 遍历100~200之间的每一个数，然后分别验证其是否为素数、回文、水仙，如果都不是即符合要求
* 素数的判断：每取一个数i就用从2到Math.sqrt(i)之间的整数对其取模，模全不为0即为素数
* 其他两种的判断参考题目2
*
*
* 步骤：为了方便，依然定义3个int来保存各位上的值，用于判断回文和水仙时用。
* 弄个for遍历100~200
* 对每个数进行3次判别，其中素数的判别还需再用一次for遍历
* 三个判断都不是，加之
*/
public class FindNum2 {
public static void main(String[] args) {
int sum = 0;
for(int i = 100, a, b, c; i <= 200; i++){ //a,b,c用于保存百位、十位、个位
a = (int)Math.pow(i / 100, 3);
b = (int)Math.pow(i % 100 / 10, 3);
c = (int)Math.pow(i % 10, 3); //取出百、十、个位值做立方运算
if (a != c){ //为true说明不是回文数
if(i != a + b + c){ //为true说明也不是水仙数
for(int j = 2; j <= (int)Math.sqrt(i); j++){ //遍历小于i的平方根的整数
if(i % j == 0){ //被整除说明不是素数
sum += i; //结果丢入累加器
break; //继续测试下一个目标数
}
}
}
}
}
System.out.println("100到200之间中既不是回文数又不是素数又不是水仙数的所有数的和为" + sum);
}
}/* Output:
100到200之间中既不是回文数又不是素数又不是水仙数的所有数的和为11125
*///:~

复制代码

论坛使用很菜~，输出结果也很简单，就不截图了，直接注释在了每段代码结尾处~~

作者: java.love 时间: 2013-7-1 16:20

/*
2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
*/
class Test2
{
public static void main(String[] args)
{
System.out.print("所有的水仙数:");
for(int i=100;i<1000;i++)
{
if(isSxh(i)==true&&isHw(i)==true)
System.out.println("即是水仙数又是回文数的数"+i);
else if(isSxh(i)==true)
System.out.print(i+" ");
}
}
public static boolean isSxh(int x)
{
int i,j,k;
i=x/100;//求x的百位上的数
j=x%100/10;//求x的十位上的数
k=x%10;//求x的个位上的数
if(x==i*i*i+j*j*j+k*k*k)//判断是否为水仙数
return true;
else
return false;
}
public static boolean isHw(int x)
{
int i,j,k;
i=x/100;//求x的百位上的数
j=x%100/10;//求x的十位上的数
k=x%10;//求x的个位上的数
if(x==k*100+j*10+i)//判断x是否为回文
return true;
else
return false;
}
}

复制代码

复制代码

/*
3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
*/
class Test3
{
public static void main(String[] args)
{
 int sum=0;
 for(int i=100;i<=200;i++)
 {
if(isSushu(i)==false&&isSxh(i)==false&&isHw(i)==false)
sum=sum+i;//累加求和
//System.out.println("所有数"+i);
 }
 System.out.println("所有数的和:"+sum);
}
public static boolean isSushu(int x)
{//判断是否为素数
 int i,j;
 for(i=2;i<x;i++)
 {
if(x%i==0)
break;
 }
 if(i>=x)
return true;
 else
return false;
}
public static boolean isSxh(int x)
{//判断是否为水仙数
 int i,j,k;
 i=x/100;//求x的百位上的数
 j=x%100/10;//求x的十位上的数
 k=x%10;//求x的个位上的数
 if(x==i*i*i+j*j*j+k*k*k)//判断是否为水仙数
return true;
 else
return false;
}
public static boolean isHw(int x)
{//判断是否为回文
 int i,j,k;
 i=x/100;//求x的百位上的数
 j=x%100/10;//求x的十位上的数
 k=x%10;//求x的个位上的数
 if(x==k*100+j*10+i)//判断x是否为回文
return true;
 else
return false;
}
}

作者: .netNo1 时间: 2013-7-1 19:21

int y1, y2, y3;/*y1是甲1的对手，y2是甲2的对手，y3是甲3的对手*/
for (y1 = 1; y1 <= 3; y1++)
{
for (y2 = 1; y2 <= 3; y2++)
{
if (y1 != y2)
for (y3 = 1; y3 <= 3; y3++)//两两相比
{
if (y1 != y3 && y2 != y3)//同一队的不进行比赛
{
if (y1 != 1 && y3 != 1 && y3 != 3)//条件判断
Console.WriteLine("甲队的一号对应乙队的{0}号，甲队的二号对应乙队的{1}号，甲队的三号对应乙队的{2}号", y1, y2, y3);
}
}
}
}
Console.ReadKey();
//输出结果为：甲队的一号对应乙队的3号，甲队的二号对应乙队的1号，甲队的三号对应乙队的2号

复制代码

作者: .netNo1 时间: 2013-7-1 19:41

int sum = 0;//和
for (int i = 101; i <= 200; i++) //用i表示三位数
{
int bai = 0; //百位
int shi = 0; //十位
int ge = 0; //个位
int baiyushu = 0; //对百位进行求余后的数字
bai = i / 100;
baiyushu = i % 100; //两位数
shi = baiyushu / 10;
ge = baiyushu % 10;
for (int k = 2; k < i; k++)
{
if (i % k == 0) //质数
{
if (i == bai * bai * bai + shi * shi * shi + ge * ge * ge) //水仙花数
{
continue;
}
else if (bai == ge) //回文数
{
continue;
}
else
sum += i;
}
else //素数
continue;
}
}
Console.Write("既不是素数又不是回文数又不是水仙花数的总和为：" + sum);
Console.ReadKey();
//输出结果为：61275

复制代码

作者: 黄少海 时间: 2013-7-1 22:16

/** 题目1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
*
*思路：
* 1：甲队各队选手的编号均为1号，2号，3号。可以用一个外循环来实现。其中x范围为1到3，分别代表选手号码。
* 2：一队同理用一个内循环来实现。变量用y来表示。
* 3：根据已知条件找出两队的赛手名单在内循环分别用条件语句进行判断
*/
package exercises;
public class dfdfd {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("甲队赛手名单:1;2;3;");
for(int x=1; x<=3; x++){ //变量x的范围代表的是甲队比赛选手
for(int y=1; y<=3; y++){ //变量y的范围代表的是乙队比赛选手
if(x==1 && y==3 ) //判断甲队1号的对手
System.out.print("乙队赛手名单:"+y+";");
if(x==2 && y==1) //判断甲队2号的对手
System.out.print(y+";");
if(x==3 && y==2) //判断甲队3号的对手
System.out.println(y+";");
}
}
}
}

复制代码

第一道题结果.png (6.65 KB, 下载次数: 0)

作者: 宋智超 时间: 2013-7-1 22:46
以下是第一题的代码
class diyiti
{
 public static void main(String[] args)
 {
 int j,y; //定义两个变量，j代表甲队，其中的数值1代表1号，如j=1表示为甲队一号。
 for (j=1;j<4;j++) //控制甲队循环
 {
 for (y=1;y<4;y++) //控制乙队循环
 {
 boolean temp=!((j==1&&y==1)||((j==3)&&(y==1))||((j==3)&&(y==3))); //声明甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比
 if (temp) //对对比的结果进行判断，若符合条件则进行下面语句
 {
 System.out.println("甲队的"+j+"号 VS 乙队的"+y+"号"); //输出对比结果
 }
 }
 }
 }
}

下图是运行的结果

作者: 宋智超 时间: 2013-7-1 23:29
以下是第二题代码
class dierti
{
 public static void main(String[] args)
 {
 int g=0,s=0,b=1,num,num1,num2; //定义变量，g代表个位，s代表十位，b代表百位。。。
 for (b=1;b<10;b++)
 {
 for (s=0;s<10;s++)
 {
 for (g=0;g<10;g++) //上部分代码作用为对100到999的数字进行循环
 {
 num=g+s*10+b*100; //num代表现在所循环的数字
 num1=b+s*10+g*100;
 num2=g*g*g+s*s*s+b*b*b;
 boolean x,y;
 x=(num==num1);
 y=(num==num2); //对所循环的数字进行判断，x=ture说明是回文数，y=ture说明是水仙花数
 if (x&y) //判断是否即是回文数也是水仙花数，如果是则打印
 {
 System.out.println(num+"即是回文数也是水仙花数");
 }

 else if (y) //若次数不能同时即是回文数也是水仙花数，则判断是否是水仙花数，如果是则打印
 {

 System.out.println(num+"是水仙花数");
 }

 }
 }
 }

 }
 }

以下是第二题的运行结果 PS：从EditPlus从直接考过来代码全乱了……最后还是用空格排版……好幸苦……

2.png (2.22 KB, 下载次数: 0)

下载附件

2013-7-1 23:27 上传

作者: 宋智超 时间: 2013-7-2 00:20
本帖最后由宋智超于 2013-7-2 00:21 编辑

第三题代如下：

class disanti
{
public static void main(String[] args)
{
int g=0,s=0,b=1,num,num1,num2,sum=200; //定义变量，g代表个位，s代表十位，b代表百位。。。
for (b=1;b<2;b++)
{
for (s=0;s<10;s++)
{
for (g=0;g<10;g++) //上部分代码作用为对100到999的数字进行循环
{
num=g+s*10+b*100; //num代表现在所循环的数字
num1=b+s*10+g*100;
num2=g*g*g+s*s*s+b*b*b;
boolean x,y,z=true,j;
for (int a=2;a<num;a++)
{
if (num%a==0)
{
z=false;
break;
}
}
x=!(num==num1);
y=!(num==num2); //对所循环的数字进行判断，x=ture说明不是是回文数，y=ture说明不是是水仙花数，!z=ture说明不是素数。
j=x&&y&&(!z); //声明既不是素数也不是回文数也不是水仙花数
if (j) //判断是否符合求和条件，如果符合则对其进行求和
{
sum=sum+num;
}
}
}
}
System.out.println("100~200之间即不是回文数又不是素数又不是水仙数的所有数的和为："+sum); //输出求和结果
}
}

复制代码

第三题运行结果如下：

新手一枚，所做三道题代码较为繁琐，已有优化思路。

作者: 宋智超 时间: 2013-7-2 00:23
为什么我每次粘过来的代码全乱了呢？

作者: 黄少海 时间: 2013-7-2 00:26

/**打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=1*1*1+5*5*5+3*3*3
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
*
*思路：
* 1：从题中可以看出被判断的数为一个3位数。可以用3个变量x、y、z分别来代表他的百位、十位、个位。用变量value代表它的值。
* （1）百位提取：用vlaue除以100取整；
* （2）十位提取：用vlaue除以10取整在除以10取余数
* （3）个位取整：用vlaue除以10取余数；
* 2：打印出所有三位数中即是水仙数又是回文数的数。3位数值范围为100-999 定义for循环来实现在进行逐个判断.
* 首先判断是否是水仙数，如果是存入一个数组arr数组中。在对该数是否是一个回文数。如果是直接输出该数。
*
* 3:如果即是水仙数又是回文数的数不存在。定义一个boolean isExist来判断是否存在。false表示水仙数又是回文数的数不存在。
*/
package exercises;
public class Exercises_02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int x = 0;//百位
int y = 0;//十位
int z = 0;//个位
boolean isExist = false;//即是水仙数又是回文数的数不存在
int [] arr = new int [999];//存放所有的水仙数
int index=0;
for(int value=100; value<=999; value++){
x = value/100;
y = (value/10) % 10;
z = value%10;//提取个位十位百位
if(x*x*x+y*y*y+z*z*z==value ){//判断是否是一个水仙数。如果是存入数组arr中
arr[index]=value;
index++;
if(x==z){//判断这个数是否是水仙数又是回文数
System.out.println("即是水仙数又是回文数的值"+value);
isExist = true;//即是水仙数又是回文数的数存在
}
}
}
if(isExist==false){//如果没有这个数那么输出所有的水仙数
System.out.println("即是水仙数又是回文数不存在"+"\r\n"+"所有的水仙数是");
printArr(arr,index);
}
}
/**打印一个int类型数组的内容.格式是[1;2;3;4;......]
* @param arr 接受一个int类型的数组。
* @param index 接受一个int类型的数值表示要打印的个数
*/
public static void printArr(int[] arr, int index){
System.out.print("[");
for(int x=0; x<index; x++)
if(x<index-1)
System.out.print(arr[x]+";");
else
System.out.println(arr[x]+"]");
}
}

复制代码

请版主看看这边代码哪里可以简化。

第二题.png (6.82 KB, 下载次数: 0)

作者: mulua 时间: 2013-7-2 09:10

package huodong;
import java.lang.Math ;
public class Shui
{
public static void main(String[] args)
{
//调用函数
shuixian();
}
public static int shuixian()
{
StringBuilder x=new StringBuilder();
StringBuilder y=new StringBuilder();
//遍历100-999之间的数查找水仙数
for (int i = 100; i < 1000; i++)
{
int arr[]=new int[3];
int m = i;
//将整数的各个位上的数取出来
for (int j=0; j <3; j++)
{
arr[j]=m%10;
m=m/10;
}
Double sum=Math.pow(arr[0],3)+Math.pow(arr[1],3)+Math.pow(arr[2],3);
//判断是否是水仙数
if (i==sum)
{
//是水仙数的话存起来
y.append(i);
y.append("|");
int xin=arr[0]*100+arr[1]*10+arr[2];
//判断是否既是水仙数又是回文数
if (xin==i)
{
System.out.println("既是水仙数又是回文数的数："+i);
//是的话存起来
x.append(i);
}
}
}
//判断是否存在既是水仙数又是回文数的数
if (x.length()==0)
{
System.out.println("没有发现既是水仙数又是回文数的数");
//输出水仙数
String str=y.toString();
System.out.println("水仙数字："+str);
}
else
{
String str1=x.toString();
System.out.println("既是水仙数又是回文数的数"+str1);
}
return 0;
}
}

复制代码

作者: 黄少海 时间: 2013-7-2 11:02
本帖最后由黄少海于 2013-7-2 11:04 编辑

/**题目3：打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
*
* 思路：
* 根据题意可以得出。涉及到的变量有即不是回文数又不是素数又不是水仙数的所有数的和用int类型的变量s来表示，
* 100到200范围的数值用int类型的变量num来表示。采用for循环从100逐个进行条件判断。
*
*/
package exercises;
public class Exercises_03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int s = 0; //即不是回文数又不是素数又不是水仙数的所有数的和
for(int num=100; num<=200;num++){ //100到200范围的数值逐个进行判断
if(isShuixian(x)==false & isHuiWen(x)==false & isPrime(x)==false){
//调用水仙数、回文数、素数的判定方法
s += num;
}
}
System.out.println("100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和为："
+"\r\n"+s);//输出结果
}
/**回文数的判断
* @param value 接受一个int类型的值
* @return true 代表该值是一个回文数。
* false 代表该值不是回文数。n
*/
private static boolean isHuiWen(int value) {
// TODO Auto-generated method stub
int x = 0;//百位
int y = 0;//十位
int z = 0;//个位
x = value/100;
y = (value/10) % 10;
z = value%10; //提取个位十位百位
if(x==z){//判断这个数是否是是回文数
return true;
}
return false;
}
/**素数的判断
* @param value 接受一个int类型的值
* @return true 代表该值是一个素数。
* false 代表该值不是素数。
*/
private static boolean isPrime(int value) {
// TODO Auto-generated method stub
for(int i=2; i<=value/2; i++){
if(value%i==0){
return false;
}
}
return true;
}
/**水仙数的判断
* @param value 接受一个int类型的值
* @return true 代表该值是一个水仙数。
* false 代表该值不是水仙数。
*/
private static boolean isShuixian(int value) {
// TODO Auto-generated method stub
int x = 0;//百位
int y = 0;//十位
int z = 0;//个位
x = value/100;
y = (value/10) % 10;
z = value%10; //提取个位十位百位
if(x*x*x+y*y*y+z*z*z==value ){//判断是否是一个水仙数。
return true;
}
return false;
}
}

复制代码

题目3结果.png (7.43 KB, 下载次数: 0)

作者: 王楚鑫 时间: 2013-7-2 13:45
第一题

/*
需求：两个兵乓球队进行比赛,各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。甲队1号说不和乙队的1号比，甲队的3号说不和
乙队的1号和3号比，请编程找出两队的赛手名单。
思路： 1.定义三个变量i,j,k为乙队三名队员，保存i是甲队1号的对手，j是甲队2号的对手，k是甲队3号的对手
--------------------------------
甲 i j k
乙
a 0 0
--------------------------------
b
--------------------------------
c 0
--------------------------------
2.按题目要求进行嵌套循环,同时满足题目要求时即为最终结果
*/
public class Game{
public static void main(String[] args) {
char i,j,k;//定义三个变量i,j,k为乙队三名队员，保存i是甲队1号的对手，j是甲队2号的对手，k是甲队3号的对手
for(i='a'; i<='c'; i++) //乙队三名队员按1,2,3号顺序分别标记为a,b,c
{
if(i!='a') //条件1：甲队1号说不和乙队的1号比
{
for(k='a'; k<='c'; k++)
if(k!='a'&&k!='c') //甲队的3号说不和乙队的1号和3号比
{
for(j='a'; j<='c'; j++)
if(i!=j&&j!=k&&k!=i)
System.out.println("甲队1号的对手是"+i+"\t"+"甲队2号的对手是"+j+"\t"+"甲队3号的对手是"+k+"\t");
}
}
}
}
}

复制代码

第二题

/*
需求：打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
思路： 1.三位数循环
2.判断是否是水仙数
3.若是水仙数，判断是否是回文数，并标识
4.若存在即是水仙数又是回文数的数，则打印输出，否则保存当前水仙数
*/
import javax.swing.JOptionPane;
public class Flower
{
public static boolean sNumber(int i)//定义函数，判断是否是水仙数(水仙数是指一个三位数，其个位数立方和等于本身)
{
int ge,shi,bai;
bai=i/100;
shi=i%100/10;
ge=i%10;
if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai)//满足水仙数条件，返回真
return true;
return false;
}
public static boolean hNumber(int i)//定义函数，判断是否是回文数(回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231)
{
int ge,bai;
bai=i/100;
ge=i%10;
if(ge==bai)
return true;//满足回文数条件，返回真
return false;
}
public static void main(String args[])
{
int[] s=new int[1000];//保存水仙数
int m=0;//标识水仙数的个数
int n=0;//标识即是水仙数又是回文数的数的个数
for(int i=100;i<1000;i++)
{
if(sNumber(i))//调用判断是否是水仙花数的函数
{
if(hNumber(i))//调用判断是否是回文数的函数
{
System.out.print(i+" ");//把满足条件的数输出
n++;
if(n!=0)
continue;
}
s[m++]=i;
}
}
if(n==0)//如果没有即是水仙数又是回文数的数字，输出所有水仙数
{
System.out.println("不存在即是水仙数又是回文数的三位数，三位数的水仙数如下：");
for(int i=0;i<m;i++)
System.out.print(s[i]+" ");
}
}
}

复制代码

第三题

/*
需求：打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
思路： 1.100到200之间循环
2.判断是否是水仙数，回文数，素数
3.同时满足此条件的则累加求和，打印输出
*/
import javax.swing.JOptionPane;
public class Sum
{
public static boolean sNumber(int i)//定义函数，判断是否是水仙数（水仙数是指一个三位数，其个位数立方和等于本身）
{
int ge,shi,bai;
bai=i/100;
shi=i%100/10;
ge=i%10;
if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai)//满足水仙数条件，返回真
return true;
return false;
}
public static boolean hNumber(int i)//定义函数，判断是否是回文数（回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231）
{
int ge,bai;
bai=i/100;
ge=i%10;
if(ge==bai)
return true;//满足回文数条件，返回真
return false;
}
public static boolean Prime(int i)//定义函数，判断是否是素数（素数，只能被1和本身整除的数）
{
int j;
for(j=2;j<i/2;j++)
{
if(i%j==0)break;
}
if(j>i/2)
return true;
return false;
}
public static void main(String args[])
{
int sum=0;//保存和
for(int i=100;i<200;i++)
{
if(!sNumber(i) && !hNumber(i) && !Prime(i))//调用函数选择即不是回文数又不是素数又不是水仙数的数累加求和
{
//System.out.print(i+" ");
sum+=i;
}
}
System.out.println("sum="+sum);
}
}

复制代码

运行结果

第二周.jpg (28.15 KB, 下载次数: 0)

作者: liujkh123 时间: 2013-7-2 16:43
解题思路都在代码里边
第一题：
代码

/**
* 题目1：思路就是将甲乙两队分别看成一个集合，然后对集合进行迭代，因为计算机看不懂题目，那只能我们认为的对迭代过程进行设计
* 迭代的过程中，首先找到甲队第三个选手，然后再对乙迭代，找到乙中既不是1也不是3的选手，找到之后，将这两个选手信息存入HashMap集合中
* 并删除原来甲乙集合中的信息，这样就题目再给的条件又可以找到下一个配对组合了。
*/
package test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
public class TwoTeamDemo {
public static void main(String[] args) {
List<Integer> listA = new ArrayList<Integer>();
List<Integer> listB = new ArrayList<Integer>();
listA.add(1);
listA.add(2);
listA.add(3);
listB.add(1);
listB.add(2);
listB.add(3);
HashMap<String, String> nameList = new HashMap<String, String>();
int a, b = 0;
while (listA.size() != 0) {//只要集合中还有未配对的，就要进行下面的配对代码
for (Iterator<Integer> it = listA.iterator(); it.hasNext();) {
a = it.next();
if (a == 3) {//因为甲的第三个选手的对手最明确，应该从第三个选手开始配对
for (Iterator<Integer> it2 = listB.iterator(); it2
.hasNext();) {
b = it2.next();
if (b != 1 && b != 3) {
nameList.put("A:" + a, "B:" + b); //把配对信息记录到map里边
it2.remove();//配对完成的选手从集合中去除
}
}
it.remove();//配对完成的选手从集合中去除
} else if (a == 1 && listA.size() < 3) {//第三个选手配对完了之后，才开始配对第一个有条件的选手
for (Iterator<Integer> it2 = listB.iterator(); it2
.hasNext();) {
b = it2.next();
if (b != 1) {
nameList.put("A:" + a, "B:" + b);
it2.remove();
}
}
it.remove();
} else if (a == 2 && listA.size() < 2) {//最后剩下的就相互配对了
for (Iterator<Integer> it2 = listB.iterator(); it2
.hasNext();) {
b = it2.next();
nameList.put("A:" + a, "B:" + b);
it2.remove();
}
it.remove();
}
}
}
System.out.println(nameList);//输出配对信息
}
}

复制代码

结果：
{A:3=B:2, A:1=B:3, A:2=B:1}

第二题：
代码

/**
* 这个题目就先弄个循环从100到1000（不包括1000），循环判断这里边的数是不是水仙数，如果是水仙数就继续判断是不是回文数
* 在判断是水仙数的时候，就把它存到水仙数的集合中，是回文数，就把它存到既是水仙数又是回文数的集合中
*/
package test;
import java.util.ArrayList;
public class IsOrNot {
private static ArrayList<Integer> shuiXnum = new ArrayList<Integer>();//用来装水仙数的集合
private static ArrayList<Integer> huiwenNumAndSX = new ArrayList<Integer>();//用来装水仙数回文数的集合
public static void main(String[] args) {
for(int i=100; i<1000; i++){//用循环来一次判断100到999
if(isShuixian(i)){
isHuiwen(i);
}
}
if(huiwenNumAndSX.size() == 0){//判断有没有又是水仙又是回文的数，然后输出
System.out.println("只有水仙数:" + shuiXnum);
}else
System.out.println("既是回文又是水仙数:" + huiwenNumAndSX);
}
public static boolean isShuixian(int i){//判断是否为水仙数，怎么判断的就省去说了
int sum = 0;
int temp1 = i;
while(i!= 0){
sum = (i%10) * (i%10) * (i%10) + sum;
i = i/10;
}
if(sum == temp1){
shuiXnum.add(temp1);
return true;
}
return false;
}
public static boolean isHuiwen(int i){//判断是否为回文数,怎么判断的也不说了，有返回值可以方便调试
int temp = i;
int sum = 0;
while(temp != 0){
sum = sum*10 + temp%10;
temp = temp/10;
}
if(sum == i){
huiwenNumAndSX.add(i);
return true;
}
return false;
}
}

复制代码

结果：
只有水仙数:[153, 370, 371, 407]

第三题：
代码

/**
* 因为只要判断100到200之间的素数，所以这个判断素数的方法可以写得简单点。
* 思路就是100到200循环，每个数都要判断既不是水仙又不是回文又不是素数，满足条件就加起来。
*/
package test;
public class GetSum {
public static void main(String[] args) {
int sum = 0;
int line = 10; //这个变量时用来控制每行输出多少个数的
for(int i=100; i<=200; i++){
if(!isHuiwen(i) && !isPrime(i) && !isShuixian(i)){//判断既不是回文又不是素数又不是水仙数， &&是个短路的运算符，这里的效果还算很高的
System.out.print(i + " "); //把满足条件的数都打印出来
line --;
if(line == 0){
System.out.println();
line = 10;
}
sum = sum + i;
}
}
System.out.println("合计：" + sum);
}
public static boolean isShuixian(int i){//判断是否为水仙数，怎么判断的就省去说了
int sum = 0;
int temp1 = i;
while(i!= 0){
sum = (i%10) * (i%10) * (i%10) + sum;
i = i/10;
}
if(sum == temp1){
return true;
}
return false;
}
public static boolean isHuiwen(int i){//判断是否为回文数,怎么判断的也不说了，有返回值可以方便调试
int temp = i;
int sum = 0;
while(temp != 0){
sum = sum*10 + temp%10;
temp = temp/10;
}
if(sum == i){
return true;
}
return false;
}
public static boolean isPrime(int i){//判断是否为素数了，因为只要判断100到200，所以代码比较简单
for(int j=2; j<=i/2; j++){
if(i%j == 0 ){
return false;
}
}
return true;
}
}

复制代码

结果：
100  102  104  105  106  108  110  112  114  115
116  117  118  119  120  122  123  124  125  126
128  129  130  132  133  134  135  136  138  140
142  143  144  145  146  147  148  150  152  154
155  156  158  159  160  162  164  165  166  168
169  170  172  174  175  176  177  178  180  182
183  184  185  186  187  188  189  190  192  194
195  196  198  200  合计：11125

作者: mulua 时间: 2013-7-4 10:55

package huodong;
/**题目
* 两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
*
*思路
*设甲队三名队员为A,B,C;
* 乙队单名队员为X,Y,Z;
*因为加队的C和A号有条件限制，所以让C好和A号先选
*通过分析c只能和Y比赛 A只能和z比赛 B只能和x比赛
*通过三层循环让甲队的C A B 一次挑选自己的对手
*
*/
public class PingPang {
public static void main(String[]args){
char i,j,k; // i是a的对手，j是b的对手，k是c的对手
for(i='X';i<='Z';i++)
{
for(j='X';j<='Z';j++){
if(i!=j)
for(k='X';k<='Z';k++){
if(i!=k && j!=k){
if(i!='X' && k!='X'&& k!='Z')//甲队的C不和乙队的X和Z比赛
{
System.out.println("--比赛安排--");
System.out.println(" A 和"+i+" 比赛");
System.out.println(" B 和"+j+" 比赛");
System.out.println(" C 和"+k+" 比赛");
}
}
}
}
}
}
}

复制代码

作者: 王楚鑫 时间: 2013-7-5 06:37
弱弱的问一句、这个还给不给加分了？再不加这周就快过去了、、49#的没给分呢{:soso_e149:}

作者: liguangcaiup 时间: 2013-7-5 17:36

public class test {
// 1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
// 甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
// 2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
// 水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
// 回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
// 3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
public static void main(String[] args) {
System.out.println("第1题");
test1();
System.out.println("第2题");
test2();
System.out.println("第3题");
test3();
}
static void test1() {
int[] A = new int[3]; // A[0],A[1],A[2]表示甲队1，2，3球员。其值表示乙队对手编号。
int i, j, k;
for (i = 1; i <= 3; i++)
for (j = 1; j <= 3; j++) {
// 甲队1号和甲队2号对手不重
if (i != j)
for (k = 1; k <= 3; k++) {
// 甲队1号和甲队3号对手不重，甲队2号和甲队3号对手不重
if (i != k && j != k) {
// 甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比
if (i != 'x' && k != 'x' && k != 'z') {
A[0] = i;
A[1] = j;
A[2] = k;
}
}
}
}
System.out.println("甲队1 VS 乙队" + A[0]);
System.out.println("甲队2 VS 乙队" + A[1]);
System.out.println("甲队3 VS 乙队" + A[2]);
}
static void test2() {
boolean hasShuixian = false; // 标志是否有水仙数
ArrayList<Integer> huiWunNums = new ArrayList<Integer>(); // 记录回文数
for (int i = 100; i < 1000; i++) {
if (shuiXian(i) && huiWun(i)) {
System.out.println(i);
hasShuixian = true;
continue;
}
if (huiWun(i))
huiWunNums.add(i);
}
int j = 0;
if (!hasShuixian)
for (Integer i : huiWunNums) {
if (j == 10) { // 控制每行打印10个数字
System.out.println();
j = 0;
}
System.out.print(i + " ");
j++;
}
}
static void test3() {
int sum = 0;
for (int i = 100; i <= 200; i++) {
if (!shuiXian(i) && !huiWun(i) && !shuShu(i))
sum += i;
}
System.out.println();
System.out.println(sum);
}
// 判断是否水仙数
static boolean shuiXian(int num) {
char[] A = String.valueOf(num).toCharArray(); // int转换为char[]
return num == (int) (Math.pow(A[0], 3) + Math.pow(A[1], 3) + Math.pow(
A[2], 3));
}
// 判断是否回文数
static boolean huiWun(int num) {
char[] A = String.valueOf(num).toCharArray(); // int转换为char[]
for (int i = 0; i < A.length / 2; i++) {
if (A[i] == A[A.length - 1 - i])
continue;
else
return false;
}
return true;
}
static boolean shuShu(int num) { // 判断是否是素数
if (2 == num)
return true;
for (int i = 2; i < Math.sqrt(num); i++) {
if (num % i == 0)
return false;
}
return true;
}
}

复制代码

第1题
甲队1 VS 乙队3
甲队2 VS 乙队2
甲队3 VS 乙队1
第2题
101  111  121  131  141  151  161  171  181  191
202  212  222  232  242  252  262  272  282  292
303  313  323  333  343  353  363  373  383  393
404  414  424  434  444  454  464  474  484  494
505  515  525  535  545  555  565  575  585  595
606  616  626  636  646  656  666  676  686  696
707  717  727  737  747  757  767  777  787  797
808  818  828  838  848  858  868  878  888  898
909  919  929  939  949  959  969  979  989  999
第3题
11109

作者: chslzj 时间: 2013-7-6 10:15

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
/**
*
*/
/**
* @author Administrator
*
*/
public class Exam {
public static void nameList(){
int[] arrays=new int[]{1,2,3};//乙队队员
boolean[] flags=new boolean[]{false,false,false};//乙队队员是否已经被选中
for(int i=0;i<3;i++)//找到乙队中不是1号也不是3号的队员
if(arrays[i]!=1&&arrays[i]!=3)
{
System.out.println("甲队3号选手的对手是乙队"+arrays[i]+"号");
flags[i]=true;//2号队员被选中
}
for(int i=0;i<3;i++)//乙队中不是一号且没有被选中的队员
if(arrays[i]!=1&&!flags[i])
{
System.out.println("甲队1号选手的对手是乙队"+arrays[i]+"号");
flags[i]=true;//3号队员被选中
}
for(int i=0;i<3;i++)//乙队中没有被选中的队员
if(!flags[i])
{
System.out.println("甲队2号选手的对手是乙队"+arrays[i]+"号");
flags[i]=true;//1号队员被选中
}
}
/**
@function:
* @data:2013-7-6上午10:02:11
* @author csl
*/
private static void question3() {
int sum=0;
for(int i=100;i<=200;i++)
{
int hundred=i/100;
int ten=i/10-hundred*10;
int one=i%10;
if(!check1(hundred,ten,one,i)&&!check2(hundred,one)&&!check3(i))//即不是回文数又不是素数又不是水仙数
sum+=i;
}
System.out.println("第三题的答案是："+sum);
}
/**
@function:
* @data:2013-7-6上午10:05:15
* @author chenyanli
* @param i
* @ 判断是否为素数
*/
private static boolean check3(int i) {
for(int j=2;j<i/2;j++)
if(i%j==0)
return false;
return true;
}
/**
@function:
* @data:2013-7-6上午9:42:50
* @author csl
*/
private static void question2() {
List<Integer> list=new ArrayList<Integer>();//水仙数存储
List<Integer> list1=new ArrayList<Integer>();//水仙数和回文数
for(int i=100;i<1000;i++){
int hundred=i/100;
int ten=i/10-hundred*10;
int one=i%10;
if(check1(hundred,ten,one,i)){//是否水仙数
list.add(i);
if(check2(hundred,one))//是否回文数
list1.add(i);
}
}
if(!list1.isEmpty())
for(int i :list1)
System.out.println(i);
else
for(int i :list)
System.out.println(i);
}
/**
@function:
* @data:2013-7-6上午9:55:12
* @author chenyanli
* @param hundred
* @param one
* 判断是否为回文数
*/
private static boolean check2(int hundred, int one) {
return hundred==one;
}
/**
@function:
* @data:2013-7-6上午9:51:07
* @author chenyanli
* @param hundred
* @param ten
* @param one
*
* 判断是否为水仙数
*/
private static boolean check1(int hundred, int ten, int one,int i) {
int sum=one*one*one+ten*ten*ten+hundred*hundred*hundred;
return sum==i;
}
public static void main(String[] args) {
nameList();//第一题
System.out.println("第二题答案");
question2();//第二题
question3();//第三题
}
}

复制代码

运行结果为：
甲队3号选手的对手是乙队2号
甲队1号选手的对手是乙队3号
甲队2号选手的对手是乙队1号
第二题答案
153
370
371
407
第三题的答案是：11125

作者: 29198102shihao 时间: 2013-7-6 15:42
C:\Users\shilinhu\Desktop\截图01.jpg
C:\Users\shilinhu\Desktop\截图00.jpg

作者: 29198102shihao 时间: 2013-7-6 15:42
图片怎么贴啊？

作者: 29198102shihao 时间: 2013-7-6 15:45
第二题代码：

public class Test2 {

/**
* 第二题
*/

public static void main(String[] args) {
int number=0;
int verseNumber=0;
boolean flag=false;
for(int i=1;i<10;i++)
{
for(int j=0;j<10;j++)
{
for(int k=0;k<10;k++)
{
number=i*100+j*10+k;
verseNumber=k*100+j*10+i;
if(number==verseNumber&&(Math.pow(i, 3)+Math.pow(j, 3)+Math.pow(k, 3))==number)
{
flag=true;
System.out.println("即是水仙数又是回文数的数");
System.out.println(number);
}
}
}
}

if(!flag)
{
System.out.println("水仙花数有");
System.out.println(number);
}
}

}

运行结果

截图01.jpg (67.4 KB, 下载次数: 0)

第一题代码

截图00.jpg (24.64 KB, 下载次数: 0)

第一题运行结果

截图02.jpg (27.47 KB, 下载次数: 0)

第2题运行结果

作者: 29198102shihao 时间: 2013-7-6 15:48

public class Test2 {

/**
* 第二题
*/

第二题代码
public static void main(String[] args) {
int number=0;
int verseNumber=0;
boolean flag=false;
for(int i=1;i<10;i++)
{
for(int j=0;j<10;j++)
{
for(int k=0;k<10;k++)
{
number=i*100+j*10+k;
verseNumber=k*100+j*10+i;
if(number==verseNumber&&(Math.pow(i, 3)+Math.pow(j, 3)+Math.pow(k, 3))==number)
{
flag=true;
System.out.println("即是水仙数又是回文数的数");
System.out.println(number);
}
}
}
}

if(!flag)
{
System.out.println("水仙花数有");
System.out.println(number);
}
}

}

作者: liguangcaiup 时间: 2013-7-6 21:44
惭愧啊之前结果一题没对 但出错不怕，重要的是要知道原因！
debug了下：
第一题是因为头开始用xyz表示乙队了后来想都可以用数字，循环的xyz改了下面条件忘了。
 原程序if (i != ‘x’ && k != ‘y’ && k != ‘z’)改为if (i != 1 && k != 1 && k != 3)就行了。
第二题要求打印如果没有这个数那么输出所有的水仙数。我给打印回文数了。。。
 原程序if (huiwen(i)) huiWenNums.add(i);改为if (shuiXian(i)) shuiXianNums.add(i);
第三题 判断素数循环条i <Math.sqrt(num) 改为for (int i = 2; i <= Math.sqrt(num); i++)，这个导致少了一个169=13*13 的数字
总结：虽然思路对，但是小错误导致大问题。要多练，多测试。共勉！

package com.share.eclipse;
import java.awt.List;
import java.util.ArrayList;
import org.junit.Test;
public class test {
// 1.两个兵乓球队进行比赛，各出三个人。各队选手的编号均为1号，2号，3号，抽签决定比赛名单，有人向队员打听比赛的名单。
// 甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比，请编程找出两队的赛手名单。
// 2.打印出所有三位数中即是水仙数又是回文数的数，如果没有这个数那么输出所有的水仙数。
// 水仙数是指一个三位数，其个位数立方和等于本身，例如:153=13+53+33
// 回文数是121置换后还是其本身，而132就不是回文数，因为置换后是231。
// 3.打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数的和。
public static void main(String[] args) {
System.out.println("第1题");
test1();
System.out.println("第2题");
test2();
System.out.println();
System.out.println("第3题");
test3();
}
static void test1() {
int[] A = new int[3]; // A[0],A[1],A[2]表示甲队1，2，3球员。其值表示乙队对手编号。
int i, j, k;
for (i = 1; i <= 3; i++)
for (j = 1; j <= 3; j++) {
// 甲队1号和甲队2号对手不重
if (i != j)
for (k = 1; k <= 3; k++) {
// 甲队1号和甲队3号对手不重，甲队2号和甲队3号对手不重
if (i != k && j != k) {
// 甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比
if (i != 1 && k != 1 && k != 3) {
A[0] = i;
A[1] = j;
A[2] = k;
}
}
}
}
System.out.println("甲队1 VS 乙队" + A[0]);
System.out.println("甲队2 VS 乙队" + A[1]);
System.out.println("甲队3 VS 乙队" + A[2]);
}
static void test2() {
boolean flag = false; // 标志是否有水仙数&&回文
ArrayList<Integer> shuiXianNums = new ArrayList<Integer>(); // 记录回文数
for (int i = 100; i < 1000; i++) {
if (shuiXian(i) && huiWun(i)) {
System.out.println(i);
flag = true;
continue;
}
if (shuiXian(i))
shuiXianNums.add(i);
}
int j = 0;
if (!flag)
for (Integer i : shuiXianNums) {
if (j == 10) { // 控制每行打印10个数字
System.out.println();
j = 0;
}
System.out.print(i + " ");
j++;
}
}
static void test3() {
int sum = 0;
int j = 0;
for (int i = 100; i <= 200; i++) {
if (!shuiXian(i) && !huiWun(i) && !shuShu(i)) {
System.out.print(i + " ");
j++;
if (j == 10) {
System.out.println();
j = 0;
}
sum += i;
}
}
System.out.println("总的::"+sum);
}
// 判断是否水仙数
static boolean shuiXian(int num) {
char[] A = String.valueOf(num).toCharArray(); // int转换为char[]
int baiWei = A[0] - '0';
int shiWei = A[1] - '0';
int geWei = A[2] - '0';
return num == (int) (Math.pow(baiWei, 3) + Math.pow(shiWei, 3) + Math.pow(geWei, 3));
}
// 判断是否回文数
static boolean huiWun(int num) {
char[] A = String.valueOf(num).toCharArray(); // int转换为char[]
for (int i = 0; i < A.length / 2; i++) {
if (A[i] == A[A.length - 1 - i])
continue;
else
return false;
}
return true;
}
static boolean shuShu(int num) { // 判断是否是素数
if (2 == num)
return true;
for (int i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0)
return false;
}
return true;
}
}

复制代码

第1题
甲队1 VS 乙队3
甲队2 VS 乙队1
甲队3 VS 乙队2
第2题
153  370  371  407
第3题
100  102  104  105  106  108  110  112  114  115
116  117  118  119  120  122  123  124  125  126
128  129  130  132  133  134  135  136  138  140
142  143  144  145  146  147  148  150  152  154
155  156  158  159  160  162  164  165  166  168
169  170  172  174  175  176  177  178  180  182
183  184  185  186  187  188  189  190  192  194
195  196  198  200  总的::11125

作者: ゞ傀儡鮭鮭ぃ 时间: 2013-7-7 02:25
第一题
import java.util.*;
class ten{
public static void main(String [] args)
{
 int i,j,k; /*i是甲队1号的对手，j是甲队2号的对手，k是甲队3号的对手*/
String[] num = {"乙队1号","乙队2号","乙队3号"};
 for(i=0;i<=2;i++)
 for(j=0;j<=2;j++){
 if(i!=j)
 for(k=0;k<=2;k++){
 if(i!=k && j!=k){
 if(i!=0 && k!=0 && k!=2 ) /*甲队1号说不和乙队的1号比，甲队的3号说不和乙队的1号和3号比*/
 System.out.println(" 甲队1号 Vs "+num+"\n 甲队2号 Vs "+num[j]+"\n 甲队3号 Vs "+num[k]);
 }
 }
 }
}
}
运算结果：

第二题

class eleven
{
public static void main(String[] agrs)
{
int n=0;
for (int i = 100; i <=999; i++) //求出三位数
{
int a = i / 100;
int b = i / 10 % 10;
int c = i % 10;
if (Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3) == i&&a==c)//如果同时水仙花和回文数
{
n+=1;
System.out.println("水仙花和回文数 : " +i);}
if(Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3) == i&&n==0)//如果不存在回文数,直接打印水仙花数
System.out.println("水仙花数 : " +i);
}
}
}
运算结果：

第三题

class twelve
{
public static void main(String [] args)
{
int s=0;
 for(int i = 100;i<=200;i++)//for循环 100-200间的所有素数(质数)
{
if(isZhiShu(i)==false)
{
//调用isZhiShu（int number）方法，返回true
int a = i / 100;
int b = i / 10 % 10;
int c = i % 10;
if (Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3) != i||a!=c)//如果同时不是水仙花或者回文数
{
s+=i;//求和
}
}
 }
System.out.println("总和" +s);//打印出100到200之间中即不是回文数又不是素数又不是水仙数的所有数
的和
}
public static boolean isZhiShu(int number)
{
//判断是否是质数的方法
 if(number==1)
{
return false;
 }
 for(int i = 2;i<number;i++)
{
if(number%i == 0)
{
return false;
}
 }
 return true;
}
}
思路：先用递归判断是否是素数，然后再判断回文数和水仙花数，然后求和打印
结果：

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

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