强训之【井字棋和密码强度等级】

1.井字棋

1.1题目

链接: link
描述
给定一个二维数组board，代表棋盘，其中元素为1的代表是当前玩家的棋子，0表示没有棋子，-1代表是对方玩家的棋子。当一方棋子在横竖斜方向上有连成排的及获胜（及井字棋规则），返回当前玩家是否胜出。

测试样例：
[[1,0,1],[1,-1,-1],[1,-1,0]]
返回：true

1.2思路讲解

我们要判断玩家是否获胜，就要判断一行或一列或者斜线/反斜线是否都是1.
那就可以让数组一行/一列/斜线的数相加，判断和是否等于3，等于3意味着这一行/一列全是1，那么就玩家获胜

斜线的话我们就只需要判断，行列坐标都是i的情况
反斜线的话就需要判断行不变，列的话是从后往前的也就是board[i][board.length-1-i]；

另外大家需要注意：每一个循环之前都需要将sum置为0。

1.3代码展示

import java.util.*;

public class Board {
    public boolean checkWon(int[][] board) {
        int sum = 0;
        for (int i = 0; i < board.length; i++) {
            sum=0;
            for (int j = 0; j < board[0].length; j++) {
                sum = sum + board[i][j];
            }
            if (sum == 3) {
                return true;
            }
        }
        for (int i = 0; i < board.length; i++) {
            sum=0;
            for (int j = 0; j < board[0].length; j++) {
                sum = sum + board[j][i];
            }
            if (sum == 3) {
                return true;
            }
        }

        sum=0;
        for (int i = 0; i < board.length; i++) {
            sum = sum + board[i][i];
        }
        if (sum == 3) {
            return true;
        }
        sum=0;
        for (int i = 0; i < board.length; i++) {
            sum = sum + board[i][board.length-1-i];
        }
        if (sum == 3) {
            return true;
        }
        return false;
    }
}

2.密码强度判断

2.1题目

链接: link
描述
密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。

一、密码长度:
5 分: 小于等于4 个字符
10 分: 5 到7 字符
25 分: 大于等于8 个字符

二、字母:
0 分: 没有字母
10 分: 密码里的字母全都是小（大）写字母
20 分: 密码里的字母符合”大小写混合“

三、数字:
0 分: 没有数字
10 分: 1 个数字
20 分: 大于1 个数字

四、符号:
0 分: 没有符号
10 分: 1 个符号
25 分: 大于1 个符号

五、奖励（只能选符合最多的那一种奖励）:
2 分: 字母和数字
3 分: 字母、数字和符号
5 分: 大小写字母、数字和符号

最后的评分标准:
= 90: 非常安全
= 80: 安全（Secure）
= 70: 非常强
= 60: 强（Strong）
= 50: 一般（Average）
= 25: 弱（Weak）
= 0: 非常弱（Very_Weak）

对应输出为：

VERY_SECURE
SECURE
VERY_STRONG
STRONG
AVERAGE
WEAK
VERY_WEAK

请根据输入的密码字符串，进行安全评定。

注：
字母：a-z, A-Z
数字：0-9
符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)
!"#$%&'()*+,-./ (ASCII码：0x21~0x2F)
:;<=>?@ (ASCII码：0x3A~0x40)
[]^_` (ASCII码：0x5B~0x60)
{|}~ (ASCII码：0x7B~0x7E)

提示:
1 <= 字符串的长度<= 300
输入描述：
输入一个string的密码

输出描述：
输出密码等级

示例1
输入：
38$@NoNoN

输出：
VERY_SECURE

说明：
样例的密码长度大于等于8个字符，得25分；大小写字母都有所以得20分；有两个数字，所以得20分；包含大于1符号，所以得25分；由于该密码包含大小写字母、数字和符号，所以奖励部分得5分，经统计得该密码的密码强度为25+20+20+25+5=95分。

示例2
输入：
Jl)M:+

输出：
AVERAGE

说明：
示例2的密码强度为10+20+0+25+0=55分。

2.2思路讲解

我们只需要判断是否符合条件，然后再将符合条件的值加起来，判断在哪个区间就可以了。
1.我们先判断字符串的长度，很简单就不多说了
2.字母，我们判断条条件为，定义两个变量，count1和count2，如果出现小写字母（该下标的字母ASCII在‘a’-‘z’之间就是小写字母），count1++，反之如果出现大写字母（该下标的字母ASCII在‘A’-‘Z’之间就是大写字母），count2++.然后判断count1和count2是否为0，如果都为0，没有字母，有一个就全是小写/大写的，全都不为0，就是混合的字母。
3.数字，这个也是一样，判断字符是否处于‘0’-‘9’之间，有的话count3++,最后判断count3的数量
4一样判字符是否处于符号的ASCII之间，不过这个符号的区间不是连续的所以需要用上 ||，这个逻辑运算符，（ch[i] >= 0x21 && ch[i] <= 0x2F || ch[i] >= 0x3A && ch[i] <= 0x40|| ch[i] >= 0x5B && ch[i] <= 0x60 || ch[i] >= 0x7B && ch[i] <= 0x7E )
5.最后判断 都有哪些
字母和数字
字母、数字和符号
大小写字母、数字和符号

2.3代码

import java.util.Scanner;

public class Main {

    public static int score(String str) {
        char[] ch = str.toCharArray();
        int sum = 0;
        int len = ch.length;
        //计算长度
        if (len <= 4) {
            sum += 5;
        } else if (len >= 5 && len <= 7) {
            sum += 10;
        } else {
            sum += 25;
        }
        //计算数字
        int count = 0;
        for (int i = 0; i < len; i++) {
            if (ch[i] >= '0' && ch[i] <= '9') {
                count++;
            }
        }
        if (count == 0) {
            sum += 0;
        } else if (count == 1) {
            sum += 10;
        } else {
            sum += 20;
        }
        //计算字母
        int count1 = 0;
        int count2 = 0;
        for (int i = 0; i < len; i++) {
            if (ch[i] >= 'a' && ch[i] <= 'z' ) {
                count1++;//小写字母
            } else if (ch[i] >= 'A' && ch[i] <= 'Z') {
                count2++;//大写的
            }
        }
        if (count1 == 0 && count2 == 0) {
            sum += 0;
        } else if (count1 != 0 && count2 != 0 ) {
            sum += 20;
        } else {
            sum += 10;
        }

        //计算符号
        int count3 = 0;
        for (int i = 0; i < len; i++) {
            if (ch[i] >= 0x21 && ch[i] <= 0x2F || ch[i] >= 0x3A && ch[i] <= 0x40
                    || ch[i] >= 0x5B && ch[i] <= 0x60  || ch[i] >= 0x7B && ch[i] <= 0x7E ) {
                count3++;
            }
        }
        if (count3 == 0) {
            sum += 0;
        } else if (count3 == 1) {
            sum += 10;
        } else {
            sum += 25;
        }
        //奖励


        if ((count1 > 0 && count2 > 0) && count > 0 && count3 > 0) {
            sum += 5;
        } else if (count > 0 && (count1 != 0 || count2 != 0) && count3 > 0) {
            sum += 3;
        } else if (count > 0 && (count1 != 0 || count2 != 0)) {
            sum += 2;
        }

        return sum;

    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        int sum = score(str);
        if (sum >= 90) {
            System.out.println("VERY_SECURE");
        } else if (sum >= 80 && sum < 90) {
            System.out.println("SECURE");
        } else if (sum >= 70 && sum < 80) {
            System.out.println("VERY_STRONG");
        } else if (sum >= 60 && sum < 70) {
            System.out.println("STRONG");
        } else if (sum >= 50 && sum < 60) {
            System.out.println("AVERAGE");
        } else if (sum >= 25 && sum < 50) {
            System.out.println("WEAK");
        } else {
            System.out.println("VERY_WEAK");
        }

    }
}

3.选择题

1. 下列运算符合法的是（A ）
   A &&
   B <>
   C if
   D :=

<>这是这个是定义泛型的
if判断语句的关键字

2.下面代码运行结果是（C）

public class Test{
public int add(int a,int b){
  try {
         return a+b;
     }
  catch (Exception e) {
  System.out.println("catch语句块");
}
  finally{
   System.out.println("finally语句块");
}
    return 0;
}
  public static void main(String argv[]){
  Test test =new Test();
  System.out.println("和是："+test.add(9, 34));
  }
}

A catch语句块 和是：43
B 编译异常
C finally语句块 和是：43
D 和是：43 finally语句块

我们调用的是add方法，返回值是43，但是没有产生异常就不会执行catch语句，不过会执行finally语句，因为finally语句始终会被执行。
所以先输出finally语句的内容，在输出值

3.下列Java代码中的变量a、b、c分别在内存的____存储区存放。（C）
class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
A 堆区、堆区、堆区
B 堆区、栈区、堆区
C 堆区、栈区、栈区
D 堆区、堆区、栈区
E 静态区、栈区、堆区
F 静态区、栈区、栈区

类对象都是在堆区上的，因为b和c都是局部变量，因此在栈区上

4. 以下声明合法的是（B）
   A default String s
   B public final static native int w( )
   C abstract double d
   D abstract final double hyperbolicCosine( )

default不是权限修饰符
final修饰的不能被重写，但是接口就是来被继承重写，所以不能一起使用

5. 在使用super 和this关键字时，以下描述正确的是（A）
   A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一
   行，否则编译不通过
   B super（）和this（）不一定要放在构造方法内第一行
   C this（）和super（）可以同时出现在一个构造函数中
   D this（）和super（）可以在static环境中使用，包括static方法和static语句块

构造方法中，this和supper都必须在第一行，因此不能同时出现，并且不能再static环境中使用。

6.下面代码的输出结果是什么？（D）
public class ZeroTest {
public static void main(String[] args) {
try{
int i = 100 / 0;
System.out.print(i);
}catch(Exception e){
System.out.print(1);
throw new RuntimeException();
}finally{
System.out.print(2);
}
System.out.print(3);
}
}
A 3
B 123
C 1
D 12

因为0不能当被除数，所以会报错，因此先执行catch语句，输出1，并且抛出异常，但是后面还有finally语句，所以会先执行完finally语句，输出2，在抛出异常，然后就输

7.关于下面代码片段叙述正确的是（C）
有代码片段如下：
byte b1=1,b2=2,b3,b6;
final byte b4=4,b5=6;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);
A 输出结果：13
B 语句：b6=b4+b5编译出错
C 语句：b3=b1+b2编译出错
D 运行期抛出异常

原本b1 和b2是byte类型的，但是赋值给·int类型，所以b1和b2就变为int类型的但是b3还是byte类型的，所以b3=(b1+b2);报错

8.以下java程序代码，执行后的结果是（A）
public class Test {
public static void main(String[] args) {
Object o = new Object() {
public boolean equals(Object obj) {
return true;
}
};
System.out.println(o.equals(“Fred”));
A Fred
B true
C 编译错误
D 运行时抛出异常
}
}

Object是所有类的父类，重写了equals方法，直接返回true。

9.执行以下程序后的输出结果是（D）
public class Test {
public static void main(String[] args) {
StringBuffer a = new StringBuffer(“A”);
StringBuffer b = new StringBuffer(“B”);
operator(a, b);
System.out.println(a + “,” + b);
}
public static void operator(StringBuffer x, StringBuffer y) {
x.append(y); y = x;
}
}

10.下面所示的java代码，运行时，会产生（）类型的异常（D）
int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);

A ArithmeticException
B NullPointException
C IOException
D ArrayIndexOutOfBoundsException

数组越界异常，一共长度为10，下表为0-9