昨天做了微软的在线笔试，那叫一个惨啊！
- 第一题目是全英文(我是很爱国好吗)
- 该死的输入，半天搞不定
，吐槽完毕，下面开始整理
题目
输入：
样例：1
2
3
4
5
6
7
8
9
10
115 5
allow 1.2.3.4/30
deny 1.1.1.1
allow 127.0.0.1
allow 123.234.12.23/3
deny 0.0.0.0/0
1.2.3.4
1.2.3.5
1.1.1.1
100.100.100.100
219.142.53.100
- 第一行两个数字n,m
- n:输入n个规则
- m:输入m个ip
描述：
用输入的ip去匹配每个规则，如果匹配，则判断是allow还是deny。根据这个得出结论，时候被允许通过。
匹配规则：
每个ip都可以写为32个二进制，斜线后面的数字k，是子网掩码的数量。（如果没有就默认32，全部匹配才可以）。
用ip和规则的前k位一一比对，如果符合，则说明匹配，否则不匹配。
在程序中的判断：
if(是allow && 匹配成功) 输出YES
其他情况全都是NO
上代码：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202/*
* testString.java
*
* Created on: 2016年4月6日 下午11:31:47
* Author: Wayne 13186259527@163.com
*/
import java.util.Scanner;
public class testString {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
/**
* n:输入的规则数 m:输入的ip数
*/
int n = sc.nextInt();
int m = sc.nextInt();
/**
* rule的结构 rule[][0]:allow||deny rule[][1]:ip rule[][2]:mask
*/
String rule[][] = new String[n][3];
/**
* 数组r、in存放rule和ip的以数字形式存储的ip(分为4段，方便后面转换为二进制)
*/
int r[][] = new int[n][4];
int in[][] = new int[m][4];
/**
* 数组ip存放，输入的m个ip
*/
String ip[] = new String[m];
/**
* 循环输入rule的每一行中的三项元素，如果没有子网掩码位数（即没有斜线后面的数字），
* 等价于，子网掩码位数为32（即全部匹配才行）。
*/
for (int i = 0; i < n; i++) {
rule[i][0] = sc.next();
rule[i][1] = sc.next();
if (rule[i][1].contains("/")) {
String[] split = rule[i][1].split("/");
rule[i][1] = split[0];
rule[i][2] = split[1];
} else {
rule[i][2] = "32";
}
}
/**
* 循环键入ip地址
*/
for (int i = 0; i < m; i++) {
ip[i] = sc.next();
}
/**
* 测试输出rule
*/
System.out.println("以下是测试输出rule");
PrintRule(rule);
/**
* 把rule的IP用“.”来拆开，放入r数组中
*/
r = SplitRuleIP(rule);
/**
* 测试输出整数型的rule的ip
*/
System.out.println("以下是测试输出整数型的rule的ip");
PrintIP(r);
/**
* 把ip的IP用“.”来拆开，放入r数组中
*/
in = SplitIP(ip);
System.out.println("以下是测试输出整数型的ip的ip");
PrintIP(in);
/**
* 上面已经将规则IP和IP都以整数的形式存入int数组中。r和in 下面进行二进制转化
* ruleBin,ipBin表示rule和ip的IP的二进制数值
*/
int ruleBin[][] = new int[r.length][32];
int ipBin[][] = new int[in.length][32];
ruleBin = CovertoBin(r);
ipBin = CovertoBin(in);
System.out.println("=====ruleBin==========");
PrintBin(ruleBin);
System.out.println("=====ipBin==========");
PrintBin(ipBin);
System.out.println("=====result==========");
getResult(ipBin, ruleBin, rule);
}
}
private static void PrintRule(String[][] rule) {
for (int i = 0; i < rule.length; i++) {
System.out.print("rule: " + rule[i][0]);
System.out.print(" ip " + rule[i][1]);
System.out.print(" mask " + rule[i][2]);
System.out.print("\n");
}
System.out.println("==========================");
}
private static int[][] SplitRuleIP(String[][] rule) {
int r[][] = new int[rule.length][4];
for (int i = 0; i < rule.length; i++) {
String[] split = rule[i][1].split("\\.");
for (int j = 0; j < 4; j++) {
r[i][j] = Integer.parseInt(split[j]);
}
}
return r;
}
private static void PrintIP(int[][] r) {
for (int i = 0; i < r.length; i++) {
for (int j = 0; j < 4; j++) {
System.out.print(" " + r[i][j] + " ");
}
System.out.print("\n");
}
System.out.println("==========================");
}
private static int[][] SplitIP(String[] ip) {
int in[][] = new int[ip.length][4];
for (int i = 0; i < ip.length; i++) {
String[] split = ip[i].split("\\.");
for (int j = 0; j < split.length; j++) {
in[i][j] = Integer.parseInt(split[j]);
}
}
return in;
}
private static int[][] CovertoBin(int[][] r) {
int Bin[][] = new int[r.length][32];
for (int i = 0; i < Bin.length; i++) {
for (int j = 0; j < 32; j++) {
Bin[i][j] = 0;
}
}
for (int i = 0; i < r.length; i++) {
int k = 31;
for (int j = 3; j >= 0; j--) {
for (int s = 0; s < 8; s++) {
if (r[i][j] != 0) {
Bin[i][k--] = r[i][j] % 2;
r[i][j] /= 2;
} else {
k--;
}
}
}
}
return Bin;
}
private static void PrintBin(int[][] ruleBin) {
for (int i = 0; i < ruleBin.length; i++) {
for (int j = 0; j < 32; j++) {
if (j % 8 == 0) {
System.out.print(" ");
}
System.out.print(ruleBin[i][j]);
}
System.out.print("\n");
}
}
private static void getResult(int[][] ipBin, int[][] ruleBin,
String[][] rule) {
String type = null;
// i循环每个ip
for (int i = 0; i < ipBin.length; i++) {
// j循环每个ruleip
boolean get = false;
for (int j = 0; j < ruleBin.length; j++) {
// accord = false;
boolean isAccord = true;
// 判断每一个ip和每一个rule的ip的符合情况
type = rule[j][0];
for (int k = 0; k < Integer.parseInt(rule[j][2]); k++) {
if (ipBin[i][k] != ruleBin[j][k]) {
isAccord = false;
break;
}
}
if (isAccord) {
get = true;
break;
}
}
/**
* 这里的if判断，原本写的是if(type=="allow"){} ,不管怎么搞都不对。 都快崩溃了！！！
* 百度之，发现原来是这个原因： 用“==”运算符，该运算符表示指向字符串的引用是否相同
* 后来用了equals方法，该方法比较的是字符串的内容是否相同
*/
System.out.print("第"+(i+1)+"个ip是否可以通过：");
if (type.equals("allow")) {
if (get) {
System.out.println("YES");
}else{
System.out.println("NO");
}
} else {
System.out.println("NO");
}
}
}
}
p.s 这里输入搞得有点麻烦，以后再来改良