5.1
代码1/*
创建101个长度的数组，如果输入一个数字，那么这个数组的值加一，最后输出的时候输出第i个数字的个数，如果不等于0就输出。然后根据数字的个数看是不是复数即可
*/
import java.util.*;
class Home05_01{
public static void main(String []args){
Scanner in = new Scanner(System.in);
int []num=new int[101];//创建数组
System.out.print("输入1-100若干数字，输入0结束");
while (true){
int a = in.nextInt();
if (a!=0){
num[a]++;//这个数字的个数加一
}
else{
break;//结束
}
}
for (int i = 1;i<=100;i++){
if (num[i]!=0){
if (num[i]>1){
System.out.println(i+" occurs "+num[i]+" times");//大于1
}
else{
System.out.println(i+" occurs "+num[i]+" time");//等于1
}
}
}
}
}
代码2
import java.util.*;
class Demo05_01{
public static void main(String[] args){
/*
思路1：数组长度不固定 需要读取一个数据 数组扩容 填入数据
数据填入之后进行排序 然后遍历数组依次判断数据的个数
连续相等
2 2 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7
思路2：借助计数排序的思想 将数组固定起来
*/
//1.获取用户输入的数据 动态的扩容数组填充数据
Scanner scanner = new Scanner(System.in);
int[] arr=new int[0];
System.out.print("Enter numbers:");
while(true){
int num=scanner.nextInt();
if(num==0){
break;
}
//验证用户输入数据的正确性
if(num<1||num>100){
System.out.println("有非法数据！");
return;
}
arr=copyOf(arr,arr.length+1);
arr[arr.length-1]=num;
}
//2.按照输出结果 将数据中的数据进行排序
insertSort(arr);
//3.输出连续相等的数字
show(arr);
}
public static int[] copyOf(int[] arr,int newLen){
int[] newArr=new int[newLen];
for(int i=0;i<arr.length;i++){
newArr[i]=arr[i];
}
return newArr;
}
public static void insertSort(int[] arr){
for(int i=1;i<arr.length;i++){
int e=arr[i];
int j;
for(j=i;j>0&&arr[j-1]>e;j--){
arr[j]=arr[j-1];
}
arr[j]=e;
}
}
/*
Arrays Math都是属于工具类
Arrays 特殊的是数组的工具类
toString(arr) 就是将数据的每个元素进行拼接 并返回拼接后的字符串数据
"[1,2,3,4]"
*/
public static void show(int[] arr){
System.out.println(Arrays.toString(arr));
//此时就将问题转成了如何判断连续相等的数据分别出现多少次
//[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 6]
for(int i=0;i<arr.length;){
int count=1;
for(int j=i+1;j<arr.length;j++){
if(arr[j]==arr[i]){
count++;
}else{
break;
}
}
System.out.println(arr[i]+" occurs "+count+(count>1?" times":" time"));
i+=count;
}
}
}
代码3
import java.util.Scanner;
class Demo05_01_02{
public static void main(String[] args){
//0 1 2 3 4 5 ~ 100
//0 单独不算 懒一下 不想计算offset
//arr[i] 就表示数字i出现的次数
int[] arr=new int[101];
Scanner scanner=new Scanner(System.in);
System.out.print("Enter numbers:");
while(true){
int num=scanner.nextInt();
if(num==0){
break;
}
arr[num]++;
}
for(int i=0;i<arr.length;i++){
if(arr[i]!=0){
System.out.println(i+" occurs "+arr[i]+(arr[i]>1?" times":" time"));
}
}
}
}
5.2
代码1
/*
创建一个数组，没输入一个数字，就遍历一遍数组，看是否有，如果没有，就添加上，如果有，就继续下一次。
最后输出这个数字即可
*/
import java.util.Scanner;
class Home05_02{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int []num=new int[10];
int count = 0;
System.out.print("输入10个数字");
for (int i = 0;i<10;i++){//输入数字
int k = 0;
int n = in.nextInt();
for (int j = 0;j<count;j++){
if (num[j]==n)
k = 1;//看是否存在
}
if (k==0){
num[count]=n;//不存在，添加数组
count++;
}
}
for (int i = 0;i<count;i++) {
System.out.println(num[i]);//遍历输出
}
}
}
代码2
import java.util.*;
class Demo05_02{
public static void main(String[] args){
/*
思路1
在全部输入之后去重复 func1
思路2
边输入边去重复 func2
*/
// func1();
func2();
}
public static void func2(){
int[] arr=new int[0];
Scanner scanner = new Scanner(System.in);
System.out.print("Enter numbers:");
for(int i=0;i<10;i++){
int num=scanner.nextInt();
if(!contains(arr,num)){
arr=copyOf(arr,arr.length+1);
arr[arr.length-1]=num;
}
}
System.out.println(Arrays.toString(arr));
}
public static void func1(){
//1.循环遍历数组进行赋值
Scanner scanner = new Scanner(System.in);
System.out.print("Enter numbers:");
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = scanner.nextInt();
}
//2.开始对已有的数据进行去重复操作
// 1 2 3 3 2 4 3 2 4 1
// 1 2 3 4
// method1(arr); //空间S(n) 时间O(nm)
// method2(arr); //空间S(1) 时间O(n^2)
// method3(arr);
}
public static void method3(int[] arr){
//不创建额外空间 不许改变原先的顺序
int i=0;
int size=arr.length;
while(i<size){
for(int j=i+1;j<size;){
if(arr[j]==arr[i]){
for(int k=j+1;k<size;k++){
arr[k-1]=arr[k];
}
size--;
}else{
j++;
}
}
i++;
}
for(i=0;i<size;i++){
System.out.print(arr[i]+" ");
}
}
public static void method2(int[] arr){
//插入排序
for(int i=1;i<arr.length;i++){
int e=arr[i];
int j;
for(j=i;j>0&&arr[j-1]>e;j--){
arr[j]=arr[j-1];
}
arr[j]=e;
}
//连续相等
for(int i=0;i<arr.length;){ //O(n)
System.out.print(arr[i]+" ");
int count=1;
for(int j=i+1;j<arr.length;j++){
if(arr[j]==arr[i]){
count++;
}else{
break;
}
}
i+=count;
}
}
public static void method1(int[] arr){
int[] newArr=new int[0];
for(int i=0;i<arr.length;i++){ //O(n)
if(!contains(newArr,arr[i])){ //O(m)
newArr=copyOf(newArr,newArr.length+1);
newArr[newArr.length-1]=arr[i];
}
}
System.out.println(Arrays.toString(newArr));
}
public static boolean contains(int[] arr,int key){
for(int i=0;i<arr.length;i++){
if(arr[i]==key){
return true;
}
}
return false;
}
public static int[] copyOf(int[] arr,int newLen){
int[] newArr=new int[newLen];
for(int i=0;i<arr.length;i++){
newArr[i]=arr[i];
}
return newArr;
}
}
5.3
代码1
/*
创建一个函数，将数组传递进去，进行循环，判断他是不是后一个数字大于前一个数字，如果都是，那么就排好了，如果不是，就没有
*/
import java.util.Scanner;
class Home05_03{
public static boolean isSort(int[]list){
for (int i = 0;i<list.length-1;i++){
if (list[i+1]<list[i]){//不是所有的都升序
return false;
}
}
return true;
}
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("请输入一个列表：");
int n = in.nextInt();
int []num = new int[n];
for (int i = 0;i<n;i++){
int m = in.nextInt();//读取数据
num[i]=m;
}
if(isSort(num)){//看函数的返回值
System.out.println("ok");
}
else{
System.out.println("no");
}
}
}
代码2
import java.util.*;
class Demo05_03{
public static void main(String[] args){
//1.获取用户的输入 只不过第一个输入的数据时数据的个数(数组的长度)
Scanner scanner=new Scanner(System.in);
System.out.print("Enter a list:");
int len=scanner.nextInt();//获取的第一个数值就是数组的长度
int[] arr=new int[len];
for(int i=0;i<arr.length;i++){
arr[i]=scanner.nextInt();
}
//2.对数组进行有序的判断
if(isSorted(arr)){
System.out.println("The list is already sorted.");
}else{
System.out.println("The list is not sorted.");
}
}
public static boolean isSorted(int[] list){
//如果不是升序排列 那么势必会出现有一组数据 左大右小的情况
for(int i=1;i<list.length;i++){
if(list[i-1]>list[i]){
return false;
}
}
return true;
}
}
5.4
代码1/*
根据随机路径中R的总数，判断落入第几个槽中如LLRRLLR,落到第3+1个槽中
*/
import java.util.Scanner;
class Home05_04{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("输入球的个数： ");
int num=scanner.nextInt();
System.out.println();
System.out.print("输入层数： ");
int layers=scanner.nextInt();
scanner.close();
System.out.println();
int []slot=new int[layers+1];
for(int i=0;i<num;i++){
int Rnum=0
for(int j=0;j<layers;j++){
char pos=Direction();
System.out.print(pos);
if(pos=='R')
Rnum++;
}
System.out.println();
System.out.println("第 "+(i+1)+" 个球落入 "+(Rnum+1)+" 槽。");
slot[Rnum]++;
}
for(int i=0;i<slot.length;i++){
System.out.println("第 "+(i+1)+" 槽有 "+slot[i]+" 个球");
}
}
public static char Direction(){
double random=Math.random();
if(random<0.5)
return 'L';
else
return 'R';
}
}
代码2
import java.util.*;
class Demo05_04{
/*
输入的数据：槽子的个数 球的个数=路径的个数
创建槽子的具体的容器int[]
每一个小球下落的路径L R 字符串
对于每一个小球而言其路径中的步骤是随机产生L R
1.提示用户输入槽子的个数和小球的个数
2.根据已有的槽子的个数去创建槽子容器
3.根据已有的球和槽子的个数去随机创建一个小球下落的路径
4.路径中经过几个钉子？路径的步骤有几步 和槽子的个数有关
5.如何通过路径的经过得知最终所落入的槽子？
*/
public static void main(String[] args){
//1.
Scanner scanner=new Scanner(System.in);
System.out.print("Enter the number of balls to drop:");
int balls=scanner.nextInt();
System.out.print("Enter the number of slots in the bean machine:");
int slots=scanner.nextInt();
//2.
int[] arr=new int[slots];
//3.几个球几个路径path
for(int i=0;i<balls;i++){
String path=getPath(slots);
System.out.println(path);
//5.只要看当前路径中R的个数即可
arr[getR(path)]++;
}
//6.输出
System.out.println(Arrays.toString(arr));
show(arr);
}
public static void show(int[] arr){
int w=arr.length;
int h=0;
for(int i=0;i<arr.length;i++){
if(arr[i]>h){
h=arr[i];
}
}
for(int i=h-1;i>=0;i--){
for(int j=0;j<w;j++){
if(i<arr[j]){
System.out.print("O");
}else{
System.out.print(" ");
}
}
System.out.println();
}
}
public static int getR(String path){
int count=0;
for(int i=0;i<path.length();i++){
if(path.charAt(i)=='R'){
count++;
}
}
return count;
}
public static String getPath(int slots){
//4.根据槽子的个数计算每一个球下落的路径
Random random=new Random();
String path="";
for(int j=0;j<slots-1;j++){
if(random.nextInt(2)==0){ //向左
path+="L";
}else{ //向右
path+="R";
}
}
return path;
}
}
5.5
class Demo05_05{
public static void main(String[] args){
int[] list1={1,2,3,4,5,6,7};
int[] list2={1,2,3,4,5,7,6};
System.out.println(equals(list1,list2));
}
public static boolean equals(int[] list1,int[] list2){
//判断两个数组是否完全相同
//1.先判断长度
if(list1.length!=list2.length){
return false;
}
//2.再依次判断元素大小
for(int i=0;i<list1.length;i++){
if(list1[i]!=list2[i]){
return false;
}
}
return true;
}
}
自己写的
/*
遍历两个数组，如果每一个数字都相等，那么就是完全相同的数组，如果有一个数字不一样，就退出循环，就不是完全相同的数组
*/
import java.util.Scanner;
class Hmoe05_05{
public static boolean equals(int []a,int[] b){
for (int i = 0;i<a.length;i++) {//看是不是每一个元素都相等
if (a[i]!=b[i]){
return false;//不是 }
}
return true;
}
}
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("请输入两个整数列表：");
int n = in.nextInt();
int []a = new int [n];
for (int i = 0;i<n;i++){//输入两个数组
a[i]= in.nextInt();
}
int m = in.nextInt();
int []b = new int [m];
for (int i = 0;i<m;i++) {
b[i]= in.nextInt();
}
if (equals(a,b)) {//判断
System.out.println("yes");
}
else{
System.out.println("no");
}
}
}
5.6
class Demo05_06{
public static void main(String[] args){
int[] arr={1,1,1,1,2,2,2,2,2,3,3,3,3,3,4};
for(int i=0;i<arr.length;){
int count=1;
for(int j=i+1;j<arr.length;j++){
if(arr[i]==arr[j]){
count++;
}else{
break;
}
}
if(count>=4){
System.out.println(arr[i]);
return;
}
i+=count;
}
System.out.println("没有！");
}
}
5.7
import java.util.*;
class Demo05_07{
public static void main(String[] args){
int[] list1={1,3,5,7,9};
int[] list2={2,4,6,8,10};
System.out.println(Arrays.toString(merge(list1,list2)));
}
/*
有序数组的合并
最主要的问题在于 数组之间有长有短
*/
public static int[] merge(int[] list1,int[] list2){
if(list1==null&&list2==null){
return null;
}
if(list1==null){
return list2;
}
if(list2==null){
return list1;
}
//只有两个都不是null的情况再考虑具体操作
int[] list3=new int[list1.length+list2.length];
int p1=0;
int p2=0;
int p3=0;
while(true){
if(p1==list1.length&&p2==list2.length){
break;
}
if(p1<list1.length&&p2==list2.length){
list3[p3++]=list1[p1++];
}else if(p1==list1.length&&p2<list2.length){
list3[p3++]=list2[p2++];
}else{
if(list1[p1]<=list2[p2]){
list3[p3++]=list1[p1++];
}else{
list3[p3++]=list2[p2++];
}
}
}
return list3;
}
}
5.8
import java.util.*;
class Demo05_08{
/*
数据 一组单词的明文 单词的密文 单词的状态
program
1000000 r r
pr**r**
*/
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
Random random=new Random();
//1.创建一个单词表
String[] words={"naruto","kakashi","sasuke","banana","java","program"};
//10.最后再去做多单词猜测
while(true){
//2.随机从单词表中抽取一个单词
String word=words[random.nextInt(words.length)];
//3.创建一个该单词的状态表 默认值是false(密文)
boolean[] status=new boolean[word.length()];
int miss=0; //猜错的个数
//4.开始猜一个单词
while(true){
//5.根据单词和状态表 决定密文形式
String ciphertext=getCipherText(word,status);
//6.输出密文并提示用户输入字母
System.out.print("Enter a letter in word "+ciphertext+" >");
char letter=scanner.nextLine().charAt(0);//"p".charAt(0)
//7.判断单词中是否有该字母
if(isContainsLetter(word,letter)){
//8.改变单词状态表 已修改/未修改
//true 表示从未修改 第一次来的
//false 表示已修改 不是第一次来 提示已经存在
if(!changeWordStatus(word,status,letter)){
System.out.println("\t "+letter+" is already in the word");
}
}else{
System.out.println("\t "+letter+" is not in the word");
miss++;
}
//9.是否结束
if(isFinish(status)){
System.out.println("The word is "+word+". You miss "+miss+" time");
break;
}
}
System.out.print("Do you want to guess another word?Enter y or n:");
String choice=scanner.nextLine();
if(choice.equals("n")){
System.out.println("Welcome!Thank you! FUCK PROGRAM!");
break;
}
}
}
public static boolean isFinish(boolean[] status){
for(int i=0;i<status.length;i++){
if(!status[i]){
return false;
}
}
return true;
}
public static boolean changeWordStatus(String word,boolean[] status,char letter){
for(int i=0;i<word.length();i++){
if(word.charAt(i)==letter){
if(status[i]){
return false; //说明已经修改
}else{
status[i]=true;
}
}
}
return true;
}
public static boolean isContainsLetter(String word,char letter){
for(int i=0;i<word.length();i++){
if(word.charAt(i)==letter){
return true;
}
}
return false;
}
public static String getCipherText(String word,boolean[] status){
String ciphertext="";
for(int i=0;i<status.length;i++){
if(status[i]){
ciphertext+=word.charAt(i);
}else{
ciphertext+="*";
}
}
return ciphertext;
}
}
5.9
import java.util.Scanner;
public class Home5_9 {
public static double suma(double [][]m,int col) {
double sum = 0;
for (int row = 0;row <m.length;row++) {
sum += m[row][col];//遍历行数
}
return sum;//返回
}
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
double [][]num = new double [3][4];
for (int i = 0;i<num.length;i++) {
for (int j = 0;j<num[i].length;j++) {
num[i][j] = in.nextDouble();//输入数组
}
}
for (int col = 0;col<num[0].length;col++) {
System.out.println(suma(num,col));//传入函数
}
}
}
5.10
代码1：
class Home5_10{
public static void main(String[] args){
/*
(0,0) (0,1) (0,2)
(1,0) (1,1) (1,2)
(2,0) (2,1) (2,2)
主对角线上的元素 行列角标是相等的
*/
int[][] m={
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10,11,12},
{13,14,15,16}
};
//主对角线
int sum=0;
for(int i=0;i<m.length;i++){
sum+=m[i][i];
}
System.out.println(sum);
//副对角线
int subsum=0;
for(int i=0;i<m.length;i++){
subsum+=m[i][m.length-1-i];
}
System.out.println(subsum);
/*
for(int i=0;i<m.length;i++){
for(int j=0;j<m[i].length;j++){
if(i==j){
sum+=m[i][j];
}
}
}
*/
}
}
代码2：
import java.util.Scanner;
public class Home5_10_2 {
public static double sum1(double [][]num) {
double sum = 0;
for (int i = 0;i<num.length;i++) {
sum += num[i][i];//对角线相加
}
return sum;//返回
}
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
double [][]num = new double [4][4];
for (int i = 0;i<num.length;i++) {
for (int j = 0;j<num[0].length;j++) {
num[i][j] = in.nextDouble();//读入数组
}
}
System.out.println(sum1(num));//传入函数
}
}
5.11
代码1：
class Home5_11{
public static void main(String[] args){
//m*n n*p m*p 矩阵相乘 前者的列 必须等于 后者的行
/*
1 2 3 1 2 1*1+2*3+3*5 1*2+2*4+3*6
× 3 4 =
4 5 6 5 6 4*1+5*3+6*5 4*2+5*4+6*6
对于数学上的一些运算公式 如果直接通过看计算流程还是比较麻烦的
此时推荐使用已知公式计算！
*/
double[][] A={ //m*p
{1,2,3},
{4,5,6},
{7,8,9}
};
double[][] B={ //p*n
{0,2.0,4.0},
{1,4.5,2.2},
{1.1,4.3,5.2}
};
double[][] C=new double[A.length][B[0].length];//m*n
for(int i=0;i<C.length;i++){
for(int j=0;j<C[i].length;j++){
double sum=0;
for(int k=0;k<B.length;k++){
sum+=A[i][k]*B[k][j];
}
C[i][j]=sum;
System.out.print(C[i][j]+" ");
}
System.out.println();
}
}
}
代码2：
import java.util.*;
public class Home5_11_1 {
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
double [][]A = new double [3][3];
double [][]B = new double[3][3];
for (int i = 0;i<3;i++) {
for (int j = 0;j<3;j++) {
A[i][j] = in.nextDouble();//输入A数组
}
}
for (int i = 0;i<3;i++) {
for (int j = 0;j<3;j++) {
B[i][j] = in.nextDouble();//读入B数组
}
}
double [][]C = new double[3][3];
for (int i = 0;i<C.length;i++) {
for (int j = 0;j<C[i].length;j++) {
for (int k = 0;k<B.length;k++) {
C[i][j] += A[i][k]*B[k][j];//套入公式
}
System.out.printf("%.2f ",C[i][j]);//输出
}
System.out.println();
}
}
}
5.12
import java.util.*;
class Home5_12{
public static void main(String[] args){
//1.输入方针的尺寸 创建方阵
Scanner scanner=new Scanner(System.in);
System.out.print("Enter size:");
int size=scanner.nextInt();
int[][] m=new int[size][size];
//2.随机的给方阵中填入0或1
Random random=new Random();
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
m[i][j]=random.nextInt(2);
System.out.print(m[i][j]+" ");//输出每一个随机数
}
System.out.println();//换行打印
}
//3.让行，列，对角线累加 sum==0 sum==size 表示全相等
checkRow(m);
checkCol(m);
checkDiagonal(m);
checkSubDiagonal(m);
}
public static void checkSubDiagonal(int[][] m){
int sum=0;
for(int i=0;i<m.length;i++){
sum+=m[i][m.length-1-i];
}
if(sum==m.length||sum==0){
System.out.printf("副主对角线全相等且是%d\n",sum==0?0:1);
}
}
public static void checkDiagonal(int[][] m){
int sum=0;
for(int i=0;i<m.length;i++){
sum+=m[i][i];
}
if(sum==m.length||sum==0){
System.out.printf("主对角线全相等且是%d\n",sum==0?0:1);
}
}
public static void checkRow(int[][] m){
for(int i=0;i<m.length;i++){
int sum=0;
for(int j=0;j<m[i].length;j++){
sum+=m[i][j];
}
if(sum==m.length||sum==0){
System.out.printf("第%d行全相等且是%d\n",i+1,sum==0?0:1);
}
}
}
public static void checkCol(int[][] m){
for(int j=0;j<m.length;j++){
int sum=0;
for(int i=0;i<m.length;i++){
sum+=m[i][j];
}
if(sum==m.length||sum==0){
System.out.printf("第%d列全相等且是%d\n",j+1,sum==0?0:1);
}
}
}
}
5.13
import java.util.*;
class Home5_13{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("Enter row ,col:");
int row=scanner.nextInt();
int col=scanner.nextInt();
int[][] m=new int[row][col];
for(int i=0;i<row;i++){
for(int j=0;j<col;j++){
m[i][j]=scanner.nextInt();
}
}
System.out.println(isConsecutiveFour(m));
}
public static boolean isConsecutiveFour(int[][] m){
for(int i=0;i<m.length;i++){
for(int j=0;j<m[i].length;j++){
//向右
if(j<=m[i].length-4){
boolean flag=true;
for(int c=j+1;c<=j+3;c++){
if(m[i][j]!=m[i][c]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
//向下
if(i<=m.length-4){
boolean flag=true;
for(int r=i+1;r<=i+3;r++){
if(m[i][j]!=m[r][j]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
//向右下
if(i<=m.length-4&&j<=m[0].length-4){
boolean flag=true;
for(int r=i+1,c=j+1;r<=i+3;r++,c++){
if(m[i][j]!=m[r][c]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
//向右上
if(i>=3&&j<=m[0].length-4){
boolean flag=true;
for(int r=i-1,c=j+1;c<=j+3;r--,c++){
if(m[i][j]!=m[r][c]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
}
}
return false;//四个方向都没有连续的
}
}
5.14
public class Lading {
void init(linkList l,int n){
linkList p=l;
linkList s;
for(int i=0;i<n*n;i++) {
s = new linkList();
s.data=0;
p.next=s;
p=s;
}
p.next = l.next;
creat(l,n);
print(l,n);
}
void creat(linkList l,int n){
linkList p=l;
for(int i=0;i<n*n;i++) {
int a = i / n;
int b = i % n + 1;
int r = (a + b) % n;
r = r % n ==0 ? n : r;
p.next.data = r;
p = p.next;
}
}
void print(linkList l,int n) {
linkList p=l;
for(int i=0;i<n*n;i++) {
System.out.print(p.next.data+" ");
p=p.next;
if((i+1)%n==0) System.out.println();
}
}
public static void main(String[] args) {
Lading la = new Lading();
linkList l = new linkList();
la.init(l, 5);
}
}
class linkList{
int data;
linkList next;
}
5.15 打印五子棋
import java.util.*;
class Home5_15{
/*
五子棋 黑白棋 谁先连成5个子 谁就赢
棋盘 我们用什么去表示棋盘
+++++++
+++++++
+++++++
那也就是说我们需要创建一个String的二维数组来表示棋盘
如何下棋呢？
目前我们的程序是控制台程序，不能说是用点击的方式进行下棋
只能是输入棋子的坐标进行下棋
输入 1,1 指的就是在(0,0)处下一个棋子
初始化棋盘 initBoard()
打印棋盘 printBoard()
开始游戏 startGame()
下棋(黑白) putDownChess()
判断输赢 isGameOver()
上述方法都会去调用棋盘board数据
如果每次讲board当做参数传递个函数的时候 会显得比较麻烦
我们可以将board数据定义为全局变量 任何函数都可以访问的变量
全局变量定义在函数的外面 类的里面 必须public static开头
*/
//全局变量 棋盘 方便函数直接调用 而不需要依次传参
public static String[][] board; //定义为是15*15的棋盘
public static String BLACK_CHESS="O"; //黑棋
public static String WHITE_CHESS="X"; //白棋
public static Scanner scanner=new Scanner(System.in);
public static void main(String[] args){
//1.初始化棋盘
initBoard();
//2.打印棋盘
printBoard();
//3.开始游戏
startGame();
}
public static void startGame(){
/*
黑方 白方 轮流 下棋
*/
int player=0; //player 偶数 黑 ；奇数 白
while(true){
if(player%2==0){ //黑方下棋
System.out.print(">>>请黑方下棋:");
if(!putDownChess(BLACK_CHESS)){
continue;
}
}else{ //白方下棋
System.out.print(">>>请白方下棋:");
if(!putDownChess(WHITE_CHESS)){
continue;
}
}
if(isGameOver()){
break;
}
player++;
}
}
public static boolean isGameOver(){
//你们自己写吧 我写过了 注意和棋的情况
return false;
}
public static boolean putDownChess(String chess){
//用户输入的 (1,1) -> (0,0)
//1 B
int x=scanner.nextInt()-1;
int y=scanner.next().charAt(0)-'A';
if(!board[x][y].equals("+")){
System.out.println(">>>此处已有棋子，请重新下棋");
//另外一种处理方式 就是讲player定义为全局 此处player--即可
return false;//意味着下棋不成功
}
board[x][y]=chess;
printBoard();
return true; //意味着下棋成功
}
public static void printBoard(){
System.out.print(" ");
for(int i=0;i<=14;i++){
System.out.print((char)('A'+i)+" ");
}
System.out.println();
for(int i=0;i<board.length;i++){
System.out.printf("%2d ",i+1);
for(int j=0;j<board[i].length;j++){
System.out.print(board[i][j]+" ");
}
System.out.println();
}
}
public static void initBoard(){
board=new String[15][15];
for(int i=0;i<board.length;i++){
for(int j=0;j<board[i].length;j++){
board[i][j]="+";
}
}
}
}
