程序语言与编程实践3-> Java实操1 | 第一周作业及思路讲解 | 数组

0313星期天，翻了翻课本，把很早就布置的作业（但下周收）写了。

出于个人感觉的难度排序，我先写的作业四，然后是1-2-3。代码风格是有渐变的。比如作业四中还在使用类似C++（非迭代器的）的循环结构，作业一中就学会了使用

for (String i : strarr)

Hashmap

ArrayList

这个系列3比1先发，这完全符合实际情况😓。

00 作业一

00-1 题目

1 （计算字符串中单词的出现次数）编写程序，从控制台读取100 个字符串，然后计算每个 字符串中单词的出现的次数。
例如：
从控制输入：
“hello Java”
“hello world”
….
输出结果为：
hello 2
Java 1
World 1

00-2 解决

这道题，记得一年多以前，拿C语言做，是比较麻烦的，需要手动遍历、以“ ”分割，然后穷举查找次数，然后想办法把查找结果输出。

但对于C++和Java而言，就比较方便，因为提供了一些比较高级的封装结构（C语言可能也有），比如HashMap和Interator。

先练习一下字符串的一些操作：

String[] str = new String[]{"a b", "bc cd", "c e"};
String arr = String.join(" ", str);
String arr1[] = arr.split(" ");
for(int i = 0; i < arr1.length;i++){
System.out.print(arr1[i] + " ");
}

代码：

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

package homework1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.String;
import java.util.Scanner;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
* @author zzrs123
*/
public class Homework1 {

/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
// TODO code application logic here
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = 3;//检验方便，这里用3方便。
//输入100个字符串
String strin;
String strarr[];
HashMap<String, Integer> map = new HashMap<String, Integer>();
while (n > 0) {
strin = br.readLine();
//读入一行
strarr = strin.split(" ");
//利用空格分隔得到字符串数组
for (String i : strarr) {
if (!map.containsKey(i)){
map.put(i, 1);
}
//字典里没有这个字符串的话，就把它放进去
else{
map.put(i, map.get(i) + 1);
}
//如果有，就把键值+1
}
n--;
//继续输入
//这个思路其实要比把全部的字符串输入，放进一个字符串数组再处理好，自己最近总是有这个倾向，但并不总是要放进数组才行。
}
Iterator<String> iterate = map.keySet().iterator();
//学过C++知道这是迭代器
while (iterate.hasNext()) {
strin = iterate.next();
System.out.println(strin + " " + map.get(strin));
}
}
}

01 作业二

01-1 题目

2 编写一个程序，使用随机函数 random 产生1000个[0-99]的整数。

这些整数有可能可能存在重复，程序对这些数据进行过滤后，去掉重复出现的数，排序并计算整数的个数。

例如，随机产生的数据为：1，10,43，10,2,1,98 输出结果为：1,2，10,43,98 数据个数为 5

01-2 解决

这个题我想应用一下类似于C++中的vector之类的结构，如果在哈希表里没有，就把放入动态数组等待后续的排序和输出。Java中的动态数组有ArrayList。可以据此实现数组动态扩容以及排序，下面我就使用到了这些内容：

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

package homework2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Random;
import java.util.Scanner;
/**
*
* @author zzrs123
*/
public class Homework2 {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//先产生1000个随机数从0到99
//1000太大了，试试500
Random num = new Random(500);
HashSet<Integer> set = new HashSet<Integer>();
for(int i  = 0; i < 500; i++){
set.add(num.nextInt(100));
}
ArrayList<Integer> list1 = new ArrayList<Integer>();
for(int i : set){
list1.add(i);
}

//Collections.sort(list1);
list1.sort(Comparator.naturalOrder());
//两种排序方式

//System.out.println(list1);
System.out.println("输出结果为：" + list1);
System.out.println("数据个数：" + list1.size());
}
}

02 作业三

02-1 题目

3 豆机游戏，也称为梅花瓶或者高尔顿瓶，它是一个用来制作统计实验的设备，是用英国科 学家赛弗兰克斯高尔顿的名字来命名的。它是一个三角形的均匀放置钉子（或钩子）的直立 板子，如下图所示（每个球都会选择一个随机路径，然后进入一个槽中）。
编写程序模拟豆机。程序应该提示用户输入球的个数以及机器的槽数。打印每个球的路 径模拟它的下落。例如，在图(a)中的球的路径是 LLRRLLR。而在图(c)中的球的路径是 RLRRLRR。使用条形图显示槽中球的最终储备量。下面是一个运行实例。
Enter the number of balla to drop:5
Enter the number of slots in the bean machine:8 （回车）
LRLRLRR 4
RRLLLRR 4
LLRLLRR 3
RRLLLLL 2
LRLRRLR 4
输出：
0
0
0 0 0

02-2 解决

这道题看上去很难，但实际上思路很多，觉得无处下手只是觉得方法不好，暴力思路也不是不行（笑）。

思路参考地址

这里我的解决方式其实跟老师的示例不太一样，看示例应当要求的是输出字符串，但自己输出的是

vector<char>

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

package homework3;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Vector;

/**
*
* @author zzrs123
*/
public class Homework3 {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Scanner input = new Scanner(System.in);
System.out.print("Enter the number of balla to drop: ");
int num_Balls = input.nextInt();
System.out.print("Enter the number of slots in the bean machine:");
int num_slots= input.nextInt();
int[] slots = new int[num_slots];

//接下来需要根据随机数生成RL路径
for(int i = 0; i < num_Balls; i++){
char RL;
if(Math.random() >= 0.5){
RL = 'R';
}
else{
RL = 'L';
}

//下面生成RL路径，三种办法
//这里利用字符串拼接符号‘+’，化简一下字符数组的遍历生成
//或者可以利用vector:
//ArrayList只能用于引用类型如String；
//同时统计一下R的数量
// String RLroad = "";
Vector charlist = new Vector();
int Rcount = 0;
for(int n: slots){
RL = Math.random() >= 0.5 ? 'R' : 'L';
charlist.add(RL);
if(RL == 'R'){
Rcount++;
}
}
System.out.println(charlist);//事实上输出的是一个个字符的数组
//转换成字符串
//找了好多转换办法都不行(在下面注释着)，只能遍历了
for (Object target : charlist) {
System.out.print(target);
}

System.out.println();
//String target_str = new String(charlist);这样写不行。
//            char temp[] = new char[num_slots];
//            charlist.copyInto(temp);
//            String target_str = String.valueOf(temp);
//            System.out.println(target_str);
slots[Rcount]++;
//            //char []RLroad  = new char[nums_slots];

}
//画图需要从上往下画，所以需要确定高度，即有槽中球的最大值。
int max = max(slots);
//画
draw(max, slots);
}

/*槽里最多多少个球*/
public static int max(int[] slots) {
int max = 0;
for(int i = 0; i < slots.length; i++) {
if(slots[i] > max)
max = slots[i];
}
return max;
}

/*打印条形图*/
public static void draw(int max, int[] slots) {
for(int i = max; i > 0; i--) {
for(int k = 0; k < slots.length; k++) {
if(slots[k] == i) {
System.out.print(" 0 ");
slots[k]--;
}
else
System.out.print("   ");
}
System.out.print(" ");
System.out.println("");
}
}

}

03 作业四

03-1 题目

4（最大行和最大列）编写一个程序，在一个 4*$的矩阵中数据填入0和1，打印该矩阵，找到第一个具有最多1的行和列。

03-2 解决

这个题目是我java实操的第一道题，这个代码风格整个还是很像C的。思路很简单，想办法输入4×4数组，想办法输出这个数组，然后分别就行列遍历，找到1最多的行列。

不过有两个容易犯的错误：

1. 在行列遍历找到1最多的行列时，完成一次内部遍历时，每次的1的count都得赋0，再进入下一次遍历；
2. 找到一个比max还大的count，得把max更新，我写的时候就卡在这里，输出结果总是最后一行和列，推断出最大值没有更新。

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

package homework4;
import java.util.Scanner;

/**
*
* @author zzrs123
*/
public class Homework4 {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Scanner in =new Scanner(System.in);
int arr[][] = new int [4][4];
for(int i = 0;i < 4 ;i++){
for(int j = 0; j < 4; j++){
arr[i][j]=in.nextInt();
}
}

for(int i = 0; i < 4; i++){
for(int j = 0; j < 4; j++){
System.out.print(arr[i][j]+" ");
//System.out.print(' ');
}
System.out.println();
}
int max=0;//行列最大值
int count = 0,num =0 ;//计数和行列标志
for(int i = 0; i < 4; i++){
count = 0;
for(int j = 0; j < 4; j++){
if(arr[i][j]==1)count++;
}
if(count>max){
max = count;
num = i;
}
}
System.out.println(num);
num = 0;
//System.out.println(tag);
max = 0;
for(int i = 0; i < 4; i++){
count = 0;
for(int j = 0; j < 4; j++){
if(arr[j][i]==1)count++;
}
if(count>max){
max = count;
num = i;
}
}
System.out.println(num);
}
}