怎么不继续了？

曹睿翔 发表于 2013-5-10 07:18
怎么不继续了？

这个星期太忙了 人很累 终于放双休一次了

3.24（游戏：挑一张牌）编写程序，模拟从一副52张的牌中选择一张牌。程序应该显示牌的大小（Ace ,2,3,4,5,6,7,8,9,10,jack,queen,king）以及牌的花色（Clubs(黑梅花)，（Diamond）红方块，（Heats）红心，（Spades）黑桃）。

class  PickCard24  //挑一张牌
{
public static void main(String[] args)
{
  String[] sizeOfCard={"Ace","2","3","4","5","6","7","8","9","10","jack","queen","king"};//牌的大小.这章还没有数组知识，先用了
  int x=(int)(Math.random()*14) ;// 产生随机值 0<= x<14 x是数组的角标
String[] cardSuit={"黑梅花","红方块","红心","黑桃"};//牌的花色
          int y=(int)(Math.random()*5) ;// 产生随机值 0<=y<5 y是数组的角标
  System.out.println("随机产生的牌是"+cardSuit[y]+sizeOfCard[x]);
}
}
/*
随机产生的牌是黑梅花9
随机产生的牌是红方块6
*/

3.25（计算一个三角形的周长）编写程序，读取三角形的三条边，如果输入值合法就计算这个三角形的周长；否则，显示这些输入值不合法。如果任意两条边的和大于第三边，那么输入值都是合法的。

import java.util.Scanner;
class  TriangularPerimeter25//一个三角形的周长 利用19题
{
public static void main(String[] args)
{
  Scanner input=new Scanner(System.in);
  System.out.print("请依次输入三角形的三边 ：  ");
  double a =input.nextDouble();
  double b =input.nextDouble();
  double c =input.nextDouble();
  if((a+b)>c && (a+c)>b && (b+c)>a)
  System.out.println("这个三角形的周长是"+(a+b+c));
  else
   System.out.println("这个三角形是无效的");
  }
}
/*
请依次输入三角形的三边 ：  1 2.5 1
这个三角形是无效的
请依次输入三角形的三边 ：  2.5 2 1
这个三角形的周长是5.5
*/

3.26（使用运算符&&、||、和^）编写一个程序，提示用户输入一个整数值，然后判定它是否能被5和6整除，是否能被5或6整除，以及是否能被5或6整除但是不能同时被他们整除。

import java.util.Scanner;
class  UsingOperators26  //使用运算符  利用程序清单3-7
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
  System.out.print("请输入一个整数：");
  int number =input.nextInt();
System.out.println(number+"能被5和6整除吗？"+(number%5==0 && number%6==0)+"\n"+
number+"能被5或6整除吗？"+(number%5==0 || number%6==0)+"\n"+
number+"只能被5或6中的一个整除，但不能同时使用吗？"+(number%5==0 ^ number%6==0));
  }
}
/*
请输入一个整数：10
10能被5和6整除吗？false
10能被5或6整除吗？true
10只能被5或6中的一个整除，但不能同时使用吗？true
*/

3.27（几何方面：点是否在三角形内？）假设一个直角三角形放在一个平面上。直角点在（0,0）处，其他两个点分别在（200,0）和（0,100）处。编写一个程序，提示用户输入一个点的坐标X坐标和Y坐标，然后判定这个点是否在该三角形内。

/*计算一次函数y=kx+b  k=（y2-y1）/（x2-x1）
   斜率  笔算出 y=-0.5x+100
如果没学过解析几何的又该如何                       
*/
import java.util.Scanner;
class  PointInsideTriangle27  //点是否在三角形内
{
public static void main(String[] args)
{
  Scanner input=new Scanner(System.in);
  System.out.print("请输入一个点（x  y）: ");
        double x =input.nextDouble();
  double y =input.nextDouble();
               
if ( y<=( -0.5*x+100))
{
System.out.println("点("+x+","+y+")在三角形内");
}else
System.out.println("点("+x+","+y+")在三角形外");
}
}
/*
请输入一个点（x  y）: 100.5 25.5
点(100.5,25.5)在三角形内
请输入一个点（x  y）: 100.5 50.5
点(100.5,50.5)在三角形外
*/

3.28(几何方面：两个矩形)编写一个程序，提示用户输入两个矩形中点的X坐标和Y坐标以及它们的宽度和高度。然后判定第二个矩形是在第一个矩形内
，还是和第一个矩形有交集，或者是没有交集。

这个是我向论坛求助后，long 大侠 写的代码
public class Rectangle{
        public static int getInt(){
                int i = 0;
                try{
                        byte[] buf = new byte[20];
                        System.in.read(buf);
                        String s = new String(buf);
                        i = Integer.parseInt(s.trim());
                }
                catch(Exception e){
                        System.out.println("程序遇到异常，即将终止");
                        System.exit(0);
                }
                finally{
                        return i;
                }
        }
        public static void sop(Object o){
                System.out.print(o);
        }
                        
        public static void main(String[] args){
                //先定义并初始化两个矩形的变量
                int rx1 = 0; //第一个矩形的x坐标
                int ry1 = 0; //第一个矩形的y坐标
                int width1 = 0; //第一个矩形的宽度
                int height1 = 0; //第一个矩形的高度
               
                int rx2 = 0; //第二个矩形的x坐标
                int ry2 = 0; //第二个矩形的y坐标
                int width2 = 0; //第二个矩形的宽度
                int height2 = 0; //第二个矩形的高度
               
                sop("请输入第一个矩形的x坐标（按回车键结束）：");
                rx1 = getInt();
                sop("请输入第一个矩形的y坐标（按回车键结束）：");
                ry1 = getInt();
                sop("请输入第一个矩形的宽度（按回车键结束）：");
                width1 = getInt();
                sop("请输入第一个矩形的高度（按回车键结束）：");
                height1 = getInt();
                sop("\n");
               
                sop("请输入第二个矩形的x坐标（按回车键结束）：");
                rx2 = getInt();
                sop("请输入第二个矩形的y坐标（按回车键结束）：");
                ry2 = getInt();
                sop("请输入第二个矩形的宽度（按回车键结束）：");
                width2 = getInt();
                sop("请输入第二个矩形的高度（按回车键结束）：");
                height2 = getInt();
               
                int left1 = rx1 - width1/2; //矩形一的左下角的x坐标,确定矩形一最左边
                int right1 = rx1 + width1/2; //矩形一的右上角的x坐标,确定矩形一最右边
                int up1 = ry1 + height1/2; //矩形一的右下角的y坐标,确定矩形一最高点
                int down1 = ry1 - height1/2; //矩形一的左下角的y坐标,确定矩形一最低点
               
                int left2 = rx2 - width2/2; //矩形二的左下角的x坐标,确定矩形二最左边
                int right2 = rx2 + width2/2; //矩形二的右上角的x坐标,确定矩形二最右边
                int up2 = ry2 + height2/2; //矩形二的右下角的y坐标,确定矩形二最高点
                int down2 = ry2 - height2/2; //矩形二的左下角的y坐标,确定矩形二最低点
               
                //判定第二个矩形是否在第一个矩形内
                if(left1 <= left2 && right1 >= right2 && up1 >= up2 && down1 <= down2){
                        sop("第二个矩形在第一个矩形内。");
                        return;
                }
                //判定第二个矩形和第一个矩形是否没有交集
                else if(right1 <= left2 || left1 >= right2 || down1 >= up2 || up1 <= down2){
                        sop("第二个矩形和第一个矩形没有交集。");
                        return;
                }
                else
                        sop("第二个矩形和第一个矩形有交集。");               
        }
}

自己再写了一遍

import java.util.Scanner;
class TwoRectangles28 //两个矩形
{
public static void main(String[] args)
{
  Scanner input=new Scanner(System.in);
  System.out.print("请输入第一个矩形的中点坐标（x  y）和宽度、高度: ");
        double x1 =input.nextDouble();
  double y1=input.nextDouble();
  double w1=input.nextDouble();
  double h1=input.nextDouble();
  System.out.print("请输入第二个矩形的中点坐标（x  y）和宽度、高度: ");
        double x2 =input.nextDouble();
  double y2=input.nextDouble();
  double w2=input.nextDouble();
        double h2=input.nextDouble();
  double left1 = x1 - w1 /2; //矩形一的左下角的x坐标,确定矩形一最左边
        double right1 = x1 + w1 /2; //矩形一的右上角的x坐标,确定矩形一最右边
        double up1 = y1 + h1 /2; //矩形一的右下角的y坐标,确定矩形一最高点
        double down1 = y1 - h1 /2; //矩形一的左下角的y坐标,确定矩形一最低点
               
        double left2 = x2 - w2 /2; //矩形二的左下角的x坐标,确定矩形二最左边
        double right2 = x2 + w2 /2; //矩形二的右上角的x坐标,确定矩形二最右边
        double up2 = y2 + h2 /2; //矩形二的右下角的y坐标,确定矩形二最高点
        double down2 = y2 - h2 /2; //矩形二的左下角的y坐标,确定矩形二最低点
           //判定第二个矩形是否在第一个矩形内
                if(left1 <= left2 && right1 >= right2 && up1 >= up2 && down1 <= down2){
                        System.out.println("第二个矩形在第一个矩形内。");
                        
                }
                //判定第二个矩形和第一个矩形是否没有交集
                else if(right1 <= left2 || left1 >= right2 || down1 >= up2 || up1 <= down2){
                        System.out.println("第二个矩形和第一个矩形没有交集。");
                        
                }
                else
                       System.out.println("第二个矩形和第一个矩形有交集。");           
  
}
}
/*
请输入第一个矩形的中点坐标（x  y）和宽度、高度: 2.5 4 2.5 43
请输入第二个矩形的中点坐标（x  y）和宽度、高度: 1.5 5 0.5 3
第二个矩形在第一个矩形内。
请输入第一个矩形的中点坐标（x  y）和宽度、高度: 1 2 3 5.5
请输入第二个矩形的中点坐标（x  y）和宽度、高度: 3 4 4.5 5
第二个矩形和第一个矩形有交集。
请输入第一个矩形的中点坐标（x  y）和宽度、高度: 1 2 3 3
请输入第二个矩形的中点坐标（x  y）和宽度、高度: 40 45 3 2
第二个矩形和第一个矩形没有交集。
*/

3.29（几何方面：两个圆）编写程序，提示用户输入两个圆的中心坐标和各自的半径值，然后决定第二个圆是否在第一个圆内，还是和第一个圆重叠。
提示：如果两个圆心的距离 <= | r1-r2  |,就认为圆2在圆1内。如果两个圆心的距离<=r1+r2,就认为圆1和圆2重叠。

import java.util.Scanner;
class  TwoCircles29 //两个圆
{
public static void main(String[] args)
{
  Scanner input=new Scanner(System.in);
  System.out.print("请输入第一个圆的中心坐标（x  y）和半径值: ");
        double x1 =input.nextDouble();
  double y1=input.nextDouble();
  double r1=input.nextDouble();
  System.out.print("请输入第二个圆的中心坐标（x  y）和半径值: ");
        double x2 =input.nextDouble();
  double y2=input.nextDouble();
  double r2=input.nextDouble();
double distance=Math.pow(Math.pow(x2-x1,2)+Math.pow(y2-y1,2),0.5); //计算两个圆心的距离
if (distance<=Math.abs(r1-r2))  //Math.abs(r1-r2)  ==|r1-r2|
    System.out.println("圆2在圆1内");
else if (distance<=r1+r2)
System.out.println("圆2与圆1有交集");
else
System.out.println("圆2与圆1没有任何交集");
}
}
/*
请输入第一个圆的中心坐标（x  y）和半径值: 0.5 5.1 13
请输入第二个圆的中心坐标（x  y）和半径值: 1 1.7 4.5
圆2在圆1内
请输入第一个圆的中心坐标（x  y）和半径值: 3.4 5.7 5.5
请输入第二个圆的中心坐标（x  y）和半径值: 6.7 3.5 3
圆2与圆1有交集
请输入第一个圆的中心坐标（x  y）和半径值: 3.4 5.5 1
请输入第二个圆的中心坐标（x  y）和半径值: 5.5 7.2 1
圆2与圆1没有任何交集
*/

最后两个难题做不出来，准备抛到论坛上。这两个题目似乎还需要一些数学知识。
自己先跑步进入第四章 循环 学习。

最后一道做出来了。倒数第二道是论坛大侠帮写的。然后自己又重写了一遍。

//程序清单4-1 猜数字
import java.util.Scanner;
class  GuessNumberOneTime  //提示用户一次猜测值
{
        public static void main(String[] args)
        {
                int number=(int)(Math.random()*101);  // 0<=随机值<101
                Scanner input=new Scanner(System.in);
                System.out.println("请猜一个魔法数字（0-100）");
                System.out.print("\n请输入您的数字：");
                int guess=input.nextInt();
                if (guess==number)
                {
                        System.out.println("您猜对了，魔法数字是："+number);
                }else if (guess>number)
                {
                        System.out.println("您猜的数字太大了");
                }else
          System.out.println("您猜的数字太小了");
        }
}
/*
请猜一个魔法数字（0-100）

请输入您的数字：50
您猜的数字太大了
*/

//程序清单4-2 猜数字的加强版
import java.util.Scanner;
class  GuessNumber //猜数字
{
        public static void main(String[] args)
        {
                int number=(int)(Math.random()*101);  // 0<=随机值<101
                Scanner input=new Scanner(System.in);
                System.out.println("请猜一个魔法数字（0-100）");

                int guess=-1; //初始化
                while (guess!=number)  //循环
                {
                        System.out.print("\n请输入您的数字：");
                   guess=input.nextInt();

                if (guess==number)
                     System.out.println("您猜对了，魔法数字是："+number);
                else if (guess>number)
               
                        System.out.println("您猜的数字太大了");
                else
          System.out.println("您猜的数字太小了");
}
               
        }
}
/*
请猜一个魔法数字（0-100）

请输入您的数字：50
您猜的数字太大了

请输入您的数字：25
您猜的数字太小了

请输入您的数字：38
您猜的数字太大了

请输入您的数字：30
您猜的数字太小了

请输入您的数字：33
您猜的数字太大了

请输入您的数字：32
您猜的数字太大了

请输入您的数字：31
您猜对了，魔法数字是：31
*/

//程序清单4-3 高级数学学习工具
import java.util.Scanner;
class  SubtractionQuizLoop //减法测验循环
{
        public static void main(String[] args)
        {
                final int NUMBER_OF_QUESTIONS=5; //问题数5,常数
                int correctCount=0;  //做对的题数
                int count=0;        //做了几道题
                long startTime=System.currentTimeMillis();  //计时开始
                String output="";
                Scanner input=new Scanner(System.in);

                while (count<NUMBER_OF_QUESTIONS)//循环出5道减法题
                {
                        int number1=(int)(Math.random()*10);  //随机产生两个 0-9的整数
                        int number2=(int)(Math.random()*10);
                         
                         if (number1<number2)  //如果第一个数小于第二个数 则换位
                         {
                                 int temp=number1;
                                 number1=number2;
                                 number2=temp;
                         }

System.out.print(number1+"-"+number2+"="+"?   ");
int answer=input.nextInt();

if (number1-number2==answer)
{
System.out.println("你算对了!\n");
correctCount++;
}else
        System.out.println("你算错了!\n"+number1+"-"+number2+"="+(number1-number2)+"\n");

count++; //做了几道题
output=output+"\n"+number1+"-"+number2+"="+answer+"    "+((number1-number2==answer)?"正确":"错误");//三元判断
                }
long endTime=System.currentTimeMillis();//计时结束
long testTime=endTime-startTime; //测试时间

                System.out.println("您做对了"+correctCount+"题。\n"+"测试时间为"+testTime/1000+"秒。\n"+output);
        }
}
/*
4-4=?   0
你算对了!

3-0=?   3
你算对了!

2-2=?   1
你算错了!
2-2=0

3-1=?   7
你算错了!
3-1=2

6-3=?   3
你算对了!

您做对了3题。
测试时间为14秒。

4-4=0    正确
3-0=3    正确
2-2=1    错误
3-1=7    错误
6-3=3    正确
*/

//程序清单4-4 使用标志值控制循环
import java.util.Scanner;
class  SentinelValue //计算个数不确定的整数之和
{
        public static void main(String[] args)
        {
                Scanner input=new Scanner(System.in);
                System.out.print("请输入一个整数(如果输入0则表示输入结束): ");
                int date=input.nextInt();

                int sum=0;
                while (date!=0)
                {
sum=sum+date;
System.out.print("请输入一个整数(如果输入0则表示输入结束): ");
                 date=input.nextInt();
                }
                System.out.println("总数和为"+sum);
               
        }
}
/*
请输入一个整数(如果输入0则表示输入结束): 2
请输入一个整数(如果输入0则表示输入结束): 3
请输入一个整数(如果输入0则表示输入结束): 4
请输入一个整数(如果输入0则表示输入结束): 0
总数和为9
*/

//程序清单4-5 do-while循环
import java.util.Scanner;
class  TestDoWhile //计算个数不确定的整数之和 加强版
{
        public static void main(String[] args)
        {
                int date=0;
                int sum=0;
                Scanner input=new Scanner(System.in);
                do
                {
                        System.out.print("请输入一个整数(如果输入0则表示输入结束): ");
                 date=input.nextInt();
                 sum=sum+date;
                }
                while (date!=0);
                System.out.println("总数和为"+sum);
        }
}
/*
请输入一个整数(如果输入0则表示输入结束): 3
请输入一个整数(如果输入0则表示输入结束): 5
请输入一个整数(如果输入0则表示输入结束): 6
请输入一个整数(如果输入0则表示输入结束): 0
总数和为14
*/

// 程序清单4-6 使用嵌套for循环打印一个乘法表
class  MultiplicationTable//乘法表
{
        public static void main(String[] args)
        {
                System.out.println("           九九乘法表");
        System.out.print("       ");
                for (int j=1;j<=9 ;j++ )
                     System.out.print("  "+j);
                System.out.println("\n---------------------------------------------  ");

                for (int i=1;i<=9 ;i++ )
                {
                         System.out.print(i+" | ");
                for (int j=1;j<=9 ;j++ )
                {
System.out.printf("%4d",i*j);
                }
System.out.println();
                }
        }
}
/*与毕老师不同的样子
           九九乘法表
         1  2  3  4  5  6  7  8  9
---------------------------------------------
1 |    1   2   3   4   5   6   7   8   9
2 |    2   4   6   8  10  12  14  16  18
3 |    3   6   9  12  15  18  21  24  27
4 |    4   8  12  16  20  24  28  32  36
5 |    5  10  15  20  25  30  35  40  45
6 |    6  12  18  24  30  36  42  48  54
7 |    7  14  21  28  35  42  49  56  63
8 |    8  16  24  32  40  48  56  64  72
9 |    9  18  27  36  45  54  63  72  81
*/

//程序清单4-7 浮点数的数值误差是不可避免的 最小化数值误差
class  TestSum //计算0.01到1.0的数列之和
{
        public static void main(String[] args)
        {
                float sum=0;
                for (float i=0.01f;i<=1.0f ;i=i+0.01f )//变量i从0.01开始，每次迭代增加0.01,当I超过1.0时循环终止。
                sum=sum+i;
                System.out.println("总和数是"+sum);
        }
}
//精确结果应该是50.50.
总和数是50.499985

//程序清单4-8 求最大公约数 提示用户输入两个正整数，然后找到它们的最大公约数
import java.util.Scanner;
class  GreatestCommonDivisor
{
        public static void main(String[] args)
        {
                Scanner input=new Scanner(System.in);

                System.out.print("请输入第一个整数： ");
                int n1=input.nextInt();
                System.out.print("请输入第二个整数： ");
                int n2=input.nextInt();

                int gcd=1; //公约数
                int k=2;
                while (k<=n1 && k<=n2)
                {
                        if (n1%k==0 && n2%k==0)
                                gcd=k;
                                k++;
                        }
                        System.out.println(n1+"和"+n2+"的最大公约数是"+gcd);
                }
}
/*
请输入第一个整数： 125
请输入第二个整数： 2525
125和2525的最大公约数是25
*/

//程序清单4-9 预测未来学费 假设某大学今年的学费是10000美金，而且以每年7%的速度增加。多少年之后学费会翻倍？
class  FutureTuition
{
        public static void main(String[] args)
        {
                double tuition=10000; //一年学费10000
                int year=1;
                while (tuition<20000)
                {
                        tuition=tuition*1.07;
                        year++;
                }
                System.out.println("学费涨到20000美元，要"+year+"年。");
        }
}
/*
学费涨到20000美元，要12年。
*/

//程序清单4-10 蒙特卡罗模拟 使用随机数和概率来分析问题
class MoterCarloSimulation //用蒙特卡罗来估算π
{
        public static void main(String[] args)
        {
                final int NUMBER_OF_TRIALS=10000000;
                int numberOfHits=0;
                for (int i=0;i<NUMBER_OF_TRIALS ;i++ )
                {
                        double x=Math.random()*2.0-1;
                        double y=Math.random()*2.0-1;
                        if (x*x+y*y<=1)
                        {
                                numberOfHits++;
                        }
                }
                double pi=4.0*numberOfHits/NUMBER_OF_TRIALS;
                System.out.println("π等于"+pi);
        }
}
/*
π等于3.1419248
*/

不是吧, 这样也可以?