数组问题（课后作业）

一、动手动脑

　　1、qipan.java

　　　　(1)源代码　　　　　

package Guidang6;

import java.io.BufferedReader;
import java.io.InputStreamReader;
public class QiPan
{
    //定义一个二维数组来充当棋盘
    private String[][] board;
    //定义棋盘的大小
    private static int BOARD_SIZE = 15;
    public void initBoard()
    {
        //初始化棋盘数组
        board = new String[BOARD_SIZE][BOARD_SIZE];
        //把每个元素赋为"╋"，用于在控制台画出棋盘
        for (int i = 0 ; i < BOARD_SIZE ; i++)
        {
            for ( int j = 0 ; j < BOARD_SIZE ; j++)
            {
                board[i][j] = "╋";
            }
        }
    }
    //在控制台输出棋盘的方法
    public void printBoard()
    {
        //打印每个数组元素
        for (int i = 0 ; i < BOARD_SIZE ; i++)
        {
            for ( int j = 0 ; j < BOARD_SIZE ; j++)
            {
                //打印数组元素后不换行
                System.out.print(board[i][j]);
            }
            //每打印完一行数组元素后输出一个换行符
            System.out.print("\n");
        }
    }
    public static void main(String[] args)throws Exception
    {
        QiPan gb = new QiPan();
        gb.initBoard();
        gb.printBoard();
        //这是用于获取键盘输入的方法
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputStr = null;
                System.out.println("请输入您下棋的座标，应以x,y的格式：");
        //br.readLine()：每当在键盘上输入一行内容按回车，刚输入的内容将被br读取到。
        while ((inputStr = br.readLine()) != null)
        {
            //将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
            String[] posStrArr = inputStr.split(",");
            //将2个字符串转换成用户下棋的座标
            int xPos = Integer.parseInt(posStrArr[0]);
            int yPos = Integer.parseInt(posStrArr[1]);
            //把对应的数组元素赋为"●"。
            gb.board[xPos - 1][yPos - 1] = "●";
            /*
             电脑随机生成2个整数，作为电脑下棋的座标，赋给board数组。
             还涉及
                1.座标的有效性，只能是数字，不能超出棋盘范围
                2.如果下的棋的点，不能重复下棋。
                3.每次下棋后，需要扫描谁赢了
             */
            gb.printBoard();
            System.out.println("请输入您下棋的座标，应以x,y的格式：");
        }
    }
}

　　　　(2)、结果

　　　　　　　　　

　　　　(3)、流程

　　　　　　用for循环进行棋盘的输出，用二维数组，之后输入坐标，再进行替换。

二、汉化

　　（1）、数字转换成汉字的源代码

package Guidang6;

import java.util.Scanner;

public class Changnum {
    public static void main(String[] args) {
        Changnum t2r = new Changnum();
        String s = t2r.cleanZero(t2r.numFormat((t2r.getNum())));
        // 如果转换过后是一个空串，则不输出屏幕
        if(!"".equals(s)) {
            System.out.println("转换成中文后为：" + s);
        }
    }  

    private String getNum() {
        String s = null;
        System.out.println("请输入一个整数（非负数）：");
        // 从命令行输入这个数
        Scanner scanner = new Scanner(System.in);
        s = scanner.next();
        scanner.close();
        return s;
    }  

    private String numFormat( String s) {
        int sLength = s.length();
        // 货币大写形式
        String bigLetter[] = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
        // 货币单位
        String unit[] = {" ", "十", "百", "千", "万",  "十", "百", "千", "亿", "十", "百", "千", "万"};  

        // 用来存放转换后的新字符串
        String newS = "";
        // 逐位替换为中文大写形式
        for(int i = 0; i < sLength; i ++) {
            newS = newS + bigLetter[s.charAt(i) - 48] + unit[sLength - i - 1];
        }
        return newS;
    }  

    private String cleanZero(String s) {
        // 如果传入的是空串则继续返回空串
        if("".equals(s)) {
            return "";
        }
        // 如果用户开始输入了很多 0 去掉字符串前面多余的‘零‘，使其看上去更符合习惯
        while(s.charAt(0) == ‘零‘) {
            // 将字符串中的 "零" 和它对应的单位去掉
            s = s.substring(2);
            // 如果用户当初输入的时候只输入了 0，则只返回一个 "零"
            if(s.length() == 0) {
                return "零";
            }
        }
        // 字符串中存在多个‘零‘在一起的时候只读出一个‘零‘，并省略多余的单位
        String regex1[] = {"零千", "零百", "零十"};
        String regex2[] = {"零亿", "零万"};
        String regex3[] = {"亿", "万"};
        // 第一轮转换把 "零仟", 零佰","零拾"等字符串替换成一个"零"
        for(int i = 0; i < 3; i ++) {
            s = s.replaceAll(regex1[i], "零");
        }
        // 第二轮转换考虑 "零亿","零万","零元"等情况
        // "亿","万","元"这些单位有些情况是不能省的，需要保留下来
        for(int i = 0; i < 2; i ++) {
            // 当第一轮转换过后有可能有很多个零叠在一起
            // 要把很多个重复的零变成一个零
            s = s.replaceAll("零零零", "零");
            s = s.replaceAll("零零", "零");
            s = s.replaceAll(regex2[i], regex3[i]);
        }  

        // 当"万"到"亿"之间全部是"零"的时候，忽略"亿万"单位，只保留一个"亿"
        s = s.replaceAll("亿万", "亿");
        return s;
    }
}

　　（2）、结果截图

　　　　

　　2、数字汉化成大写的汉字

　　　　（1）、源代码

package Guidang6;

import java.util.Scanner;

public class Changrmb {
    public static void main(String[] args) {
        Changrmb t2r = new Changrmb();
        String s = t2r.cleanZero(t2r.splitNum(t2r.roundString(t2r.getNum())));
        // 如果转换过后是一个空串，则不输出屏幕
        if(!"".equals(s)) {
            System.out.println("转换成中文后为：" + s);
        }
    }  

    private String getNum() {
        String s = null;
        System.out.println("请输入一个数字（非负数，精确到小数点后两位）：");
        // 从命令行输入这个浮点数
        Scanner scanner = new Scanner(System.in);
        s = scanner.next();
        scanner.close();
        return s;
    }  

    /**
     * 把用户输入的数以小数点为界分割开来，并调用 numFormat() 方法
     */
    private String splitNum(String s) {
        // 如果传入的是空串则继续返回空串
        if("".equals(s)) {
            return "";
        }
        // 以小数点为界分割这个字符串
        int index = s.indexOf(".");
        // 截取并转换这个数的整数部分
        String intOnly = s.substring(0, index);
        String part1 = this.numFormat(1, intOnly);
        // 截取并转换这个数的小数部分
        String smallOnly = s.substring(index + 1);
        String part2 = this.numFormat(2, smallOnly);
        // 把转换好了的整数部分和小数部分重新拼凑一个新的字符串
        String newS = part1 + part2;
        return newS;
    }  

    /**
     * 对传入的数进行四舍五入操作
     * @param s String 从命令行输入的那个数
     * @return 四舍五入后的新值
     */
    private String roundString(String s) {
        // 如果传入的是空串则继续返回空串
        if("".equals(s)) {
            return "";
        }
        // 将这个数转换成 double 类型，并对其进行四舍五入操作
        int index = s.indexOf(".");
        // 这个数的整数部分
        String intOnly = s.substring(0, index);
        // 规定数值的最大长度只能到万亿单位，否则返回 "0"
        if(intOnly.length() > 13) {
            System.out.println("输入数据过大！（整数部分最多13位！）");
            return "";
        }
        // 这个数的小数部分
        String smallOnly = s.substring(index + 1);
        // 如果小数部分大于两位，只截取小数点后两位
        if(smallOnly.length() > 2) {
            String roundSmall = smallOnly.substring(0, 2);
            // 把整数部分和新截取的小数部分重新拼凑这个字符串
            s = intOnly + "." + roundSmall;
        }
        return s;
    }  

    /**
     * 把传入的数转换为中文金额大写形式
     */
    private String numFormat(int flag, String s) {
        int sLength = s.length();
        // 货币大写形式
        String bigLetter[] = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        // 货币单位
        String unit[] = {"元", "拾", "佰", "仟", "万",  "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万"};
        String small[] = {"分", "角"};
        // 用来存放转换后的新字符串
        String newS = "";
        // 逐位替换为中文大写形式
        for(int i = 0; i < sLength; i ++) {
            if(flag == 1) {
                // 转换整数部分为中文大写形式（带单位）
                newS = newS + bigLetter[s.charAt(i) - 48] + unit[sLength - i - 1];
            }
            else if(flag == 2) {
                // 转换小数部分（带单位）
                newS = newS + bigLetter[s.charAt(i) - 48] + small[sLength - i - 1];
            }
        }
        return newS;
    }  

    private String cleanZero(String s) {
        // 如果传入的是空串则继续返回空串
        if("".equals(s)) {
            return "";
        }
        // 如果用户开始输入了很多 0 去掉字符串前面多余的‘零‘，使其看上去更符合习惯
        while(s.charAt(0) == ‘零‘) {
            // 将字符串中的 "零" 和它对应的单位去掉
            s = s.substring(2);
            // 如果用户当初输入的时候只输入了 0，则只返回一个 "零"
            if(s.length() == 0) {
                return "零圆";
            }
        }
        // 字符串中存在多个‘零‘在一起的时候只读出一个‘零‘，并省略多余的单位
        String regex1[] = {"零仟", "零佰", "零拾"};
        String regex2[] = {"零亿", "零万", "零元"};
        String regex3[] = {"亿", "万", "元"};
        String regex4[] = {"零角", "零分"};
        // 第一轮转换把 "零仟", 零佰","零拾"等字符串替换成一个"零"
        for(int i = 0; i < 3; i ++) {
            s = s.replaceAll(regex1[i], "零");
        }
        // 第二轮转换考虑 "零亿","零万","零元"等情况
        // "亿","万","元"这些单位有些情况是不能省的，需要保留下来
        for(int i = 0; i < 3; i ++) {
            // 当第一轮转换过后有可能有很多个零叠在一起
            // 要把很多个重复的零变成一个零
            s = s.replaceAll("零零零", "零");
            s = s.replaceAll("零零", "零");
            s = s.replaceAll(regex2[i], regex3[i]);
        }
        // 第三轮转换把"零角","零分"字符串省略
        for(int i = 0; i < 2; i ++) {
            s = s.replaceAll(regex4[i], "");
        }
        // 当"万"到"亿"之间全部是"零"的时候，忽略"亿万"单位，只保留一个"亿"
        s = s.replaceAll("亿万", "亿");
        return s;
    }
}

　　（2）、结果截图

　　　　

　三、大数类

　　　(1）、源代码

package Guidang6;

import java.util.Scanner;

public class Dashu {

    public static void main(String[] args) {
            // TODO Auto-generated method stub
        String s1,s2;
        Scanner in=new Scanner(System.in);
        System.out.println("输入第一个大数：");
        s1=in.next();
        System.out.println("输入第二个大数：");
        s2=in.next();
        System.out.println(add(s1,s2));
        System.out.println(sub(s1,s2));
        in.close();
}

private static String add(String a, String b)
{
    System.out.print("加法结果:");
    char[] aa = new StringBuffer(a).reverse().toString().toCharArray();
    char[] bb = new StringBuffer(b).reverse().toString().toCharArray();
    int aLen = aa.length;
    int bLen = bb.length; 

    int len = aLen > bLen ? aLen : bLen; 

    int[] result = new int[len + 1];
    for (int i = 0; i < len + 1; ++i) {
        int aint = i < aLen ? aa[i] - ‘0‘ : 0;
        int bint = i < bLen ? bb[i] - ‘0‘ : 0;
        result[i] = aint + bint;
} 

    for(int i=0;i<result.length-1;++i){
        if(result[i]>=10){
            result[i+1] += result[i]/10;
            result[i] %= 10;
        }
} 

    boolean flag = true;
    StringBuffer sb = new StringBuffer(len);
    for(int i=len;i>=0;--i){
        if(result[i]==0&&flag){
            continue;
        }
        else{
            flag=false;
        }
        sb.append(result[i]);
    }
    return sb.toString();
}
public static String sub(String f, String s) {
    System.out.print("减法结果:");
    // 将字符串翻转并转换成字符数组
    char[] a = new StringBuffer(f).reverse().toString().toCharArray();
    char[] b = new StringBuffer(s).reverse().toString().toCharArray();
    int lenA = a.length;
    int lenB = b.length;
    // 找到最大长度
    int len = lenA > lenB ? lenA : lenB;
    int[] result = new int[len];
    // 表示结果的正负
    char sign = ‘+‘;
    // 判断最终结果的正负
    if (lenA < lenB) {
        sign = ‘-‘;
    }
    else if (lenA == lenB) {
        int i = lenA - 1;
        while (i > 0 && a[i] == b[i]) {
            i--;
        }
        if (a[i] < b[i]) {
            sign = ‘-‘;
        }
    }
    // 计算结果集，如果最终结果为正，那么就a-b否则的话就b-a
    for (int i = 0; i < len; i++) {
        int aint = i < lenA ? (a[i] - ‘0‘) : 0;
        int bint = i < lenB ? (b[i] - ‘0‘) : 0;
        if (sign == ‘+‘) {
            result[i] = aint - bint;
        }
        else {
            result[i] = bint - aint;
        }
    }
    // 如果结果集合中的某一位小于零，那么就向前一位借一，然后将本位加上10。其实就相当于借位做减法
    for (int i = 0; i < result.length - 1; i++) {
        if (result[i] < 0) {
            result[i + 1] -= 1;
            result[i] += 10;
        }
    } 

    StringBuffer sb = new StringBuffer();
    // 如果最终结果为负值，就将负号放在最前面，正号则不需要
    if (sign == ‘-‘) {
        sb.append(‘-‘);
    }
    // 判断是否有前置0
    boolean flag = true;
    for (int i = len - 1; i >= 0; i--) {
        if (result[i] == 0 && flag) {
            continue;
        }
        else {
            flag = false;
        }
        sb.append(result[i]);
    }
    // 如果最终结果集合中没有值，就说明是两值相等，最终返回0
    if (sb.toString().equals("")) {
        sb.append("0");
    }
    // 返回值
    System.out.println(sb.toString());
    return ""; 

    }
}

　　　　(2)、结果截图

　　　　　　

　　　　(3)、阅读BigInteger类源码，弄清楚它是使用什么算法实现加减乘除四种运算的

　　　　BigInteger是不可变的任意精度的整数。所有操作中，都以二进制补码形式表示 BigInteger（如 Java 的基本整数类型）。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

四、随机数组

　　（1）、源代码

　　　　

package Guidang6;

import javax.swing.JOptionPane;
public class Shuzu {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int[] arr = new int[10];//定义数组
        int num=0;
        String output="";
        for(int i=0;i<10;i++){//循环赋值
            arr[i] = (int)(Math.random()*10);//随机0-10范围内的整数
        }
        output+="十个元素："+"\n";
        for(int i=0;i<10;i++)//循环输出
            {
                output+=arr[i]+" ";
                num=num+arr[i];
            }
        output+="\n";
        output+="十个元素相加结果:"+"\n";
        output+=num;
        JOptionPane.showMessageDialog( null,output, "数组",JOptionPane.PLAIN_MESSAGE);
    }
}

　　　　（2）、设计思路

　　　　　　首先定义一个长度为十的数组，在运用for循环进行数组的赋值，赋值运用随机数发生器赋值，最后再运用消息框输出结果。

　　　　（3）程序流程图

　　　　　　

　　　　（4）结果截图

　　　　　　

时间： 2024-10-08 09:46:55

数组问题（课后作业）的相关文章

数组课后作业

课后作业: 随机生成10个数,填充一个数组,然后用消息框显示数组,接着计算数组元素的和,将结果也显示在消息框中. 设计思路:首先使用random随机产生10个数,存储在数组中,然后使用for循环把数字存储在一个String对象中,再使用for循环求出数组中所有数字的和,最后用对话框输出内容. 程序流程图: 源程序代码: import javax.swing.*; public class Test1{ public static void main( String args[] ){ Strin

第七讲 数组动手动脑和课后作业

[动手动脑1] 数据作为方法参数示例代码 int[] arr= new int[ 24 ]; -- modifyArray( arr ); 阅读并运行示例PassArray.java,观察并分析程序输出的结果,小结,然后与下页幻灯片所讲的内容进行对照. // PassArray.java // Passing arrays and individual array elements to methods public class PassArray { public static void ma

数组求和与课后作业

数组求和: 设计思路: 1.创建一个int型数组,长度为10,用来存放随机数: 2.使用Random类,产生随机数: 3.使用for循环把随机数存入数组中并求出数组中所有元素的和 4.使用JTextArea和JOptionPane生成消息框,输出数组的求和结果 程序流程图: 源程序: package shuzuadd;//包名 import javax.swing.*;//把 javax包里面的swing包里面的 所有东西 引进来. public class ShuZuAdd {//类名 pub

课后作业5

动手动脑1:运行示例代码,查看结果,解释为什么是这个结果,从中你能总结出什么? 运行结果:tru truefalse 分析结果:s1,s2,s0均指向hello字符串常量的地址.所以在执行过程中,Java对于同一字符串是不会开辟新的空间的,而在最后的两者的内容虽然相同,但是他们的地址不同所以不等. 动手动脑2:查看String.equals()方法的实现代码 结果分析:s1==s2是判断地址和值,equals()仅仅判断值,s1,s2的值相同,但是地址不同,s3,s4的地址,内容都相同. 动手动

课后作业和动手动脑（字符串）

动手动脑1: (1)       在Java中,内容相同的字串常量(“Hello”)只保存一份以节约内存,所以s0,s1,s2实际上引用的是同一个对象. (2)       编译器在编译s2一句时,会去掉“+”号,直接把两个字串连接起来得一个字串(“Hello”).这种优化工作由Java编译器自动完成. (3)       当直接使用new关键字创建字符串对象时,虽然值一致(都是“Hello”),但仍然是两个独立的对象 动手动脑2: equals所在位置: 在Object类当中,而Object是

课后作业

课后作业 "类型转换"知识点考核-2 程序源代码: 1 class Mammal{} 2 class Dog extends Mammal {} 3 class Cat extends Mammal{} 4   5 public class TestCast 6 { 7      public static void main(String args[]) 8      { 9             Mammal m; 10             Dog d=new Dog();

lhtjzC++征对视频教程的课后作业在哪里可以找到哦

⌒鉴闽 lhtjzC++征对视频教程的课后作业在哪里可以找到哦

异常处理---动手动脑及课后作业

动手动脑1:请阅读并运行AboutException.java示例,然后通过后面的几页PPT了解Java中实现异常处理的基础知识. 源码: import javax.swing.*; class AboutException { public static void main(String[] a) { int i=1, j=0, k; k=i/j; try { k = i/j; // Causes division-by-zero exception //throw new Exception

课后作业---字符串

一.课后作业一 1.设计思想:根据题意,首先提示输入要进行的操作:解密或加密,然后输入一个字符串,利用charAt()方法将改变的字母连接到结果上,加密:将前23个大小写字母+3,后3个-23强制转化为char:解密:后23个大小写字母-3,前3个+23.再根据结果进行改变,添加提示. 2.程序流程图: 3.源代码: package T4; //胡建峰,2016.10.25 //字串加密 import java.util.Scanner; public class Test { public s

TJU_SCS_C#课后作业（1）

一.作业要求 这是本学期C#课程学习的第一次课后作业,主要大体感受一下C#编程Visual Studio的界面以及一些基本操作.几乎所有编程语言的学习最初都是由hello world开始的,这次我所做的就是根据章老师上课的示范在控制台中显示hello world字样. 二.作业内容 这是一个很简单的代码,最主要的就一句Console.WriteLine("Hello World!"),我还根据章老师上课的示范对控制台的背景和前景进行了些许尝试. 三.课后思考 感觉C#编程语言和Java