1. 分机号
X老板脾气古怪，他们公司的电话分机号都是3位数，老板规定，所有号码必须是降序排列，且不能有重复的数位。比如：
751,520,321 都满足要求，而，
766,918,201 就不符合要求。
现在请你计算一下，按照这样的规定，一共有多少个可用的3位分机号码？
请直接提交该数字，不要填写任何多余的内容。
解析：
直接三层循环暴力
package A;
public class Main {
public static void main(String[] args) {
int sum = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10 && i > j; j++) {
for (int k = 0; k < 10 && j > k; k++) {
if (i != j && i != k && j != k) {
System.out.println(i + " " + j + " " + k);
sum++;
}
}
}
}
System.out.println(sum);
}
}
我的答案：120
2. 五星填数
如【图1.png】的五星图案节点填上数字：1~12，除去7和11。
要求每条直线上数字和相等。
如图就是恰当的填法。
请你利用计算机搜索所有可能的填法有多少种。
注意：旋转或镜像后相同的算同一种填法。
请提交表示方案数目的整数，不要填写任何其它内容。
解析：
这种题就是暴力搜索，将所有可能搜出来，然后判断符合解的情况，最后再除以旋转和镜像的情况
就拿一维数组填充比较方便，旋转5种情况所以 120/5 = 24， 这24种里包含镜像的情况，所以再除2，24/2 = 12
答案等于12种。
package B;
public class Main {
static boolean[] vis = new boolean[15];
static int[] a = new int[15];
static int sum = 0;
static void dfs(int n) {
if (n == 11) {
int t = a[2] + a[3] + a[4] + a[5];
if (t != a[1] + a[3] + a[6] + a[9]) return ;
if (t != a[1] + a[4] + a[7] + a[10]) return ;
if (t != a[2] + a[6] + a[8] + a[10]) return ;
if (t != a[5] + a[7] + a[8] + a[9]) return ;
sum++;
return ;
}
for (int i = 1; i <= 12; i++) {
if (i == 7 || i == 11) continue;
if (vis[i] == false) {
vis[i] = true;
a[n] = i;
dfs(n+1);
vis[i] = false;
}
}
}
public static void main(String[] args) {
for(int i = 0; i < 15; i++) {
vis[i] = false;
}
dfs(1);
System.out.println("一共有：" + (sum / 10 )+ "种");
}
}
我的答案：12
3. 显示二叉树
这道代码填空题还是比较容易的，我的答案是：buf[y+1][p2+i]=sv.charAt(i)
4. 穿越雷区
X星的坦克战车很奇怪，它必须交替地穿越正能量辐射区和负能量辐射区才能保持正常运转，否则将报废。
某坦克需要从A区到B区去（A，B区本身是安全区，没有正能量或负能量特征），怎样走才能路径最短？
已知的地图是一个方阵，上面用字母标出了A，B区，其它区都标了正号或负号分别表示正负能量辐射区。
例如：
A + - + -
- + - - +
- + + + -
+ - + - +
B + - + -
坦克车只能水平或垂直方向上移动到相邻的区。
数据格式要求：
输入第一行是一个整数n，表示方阵的大小， 4<=n<100
接下来是n行，每行有n个数据，可能是A，B，+，-中的某一个，中间用空格分开。
A，B都只出现一次。
要求输出一个整数，表示坦克从A区到B区的最少移动步数。
如果没有方案，则输出-1
例如：
用户输入：
5
A + - + -
- + - - +
- + + + -
+ - + - +
B + - + -
则程序应该输出：
10
资源约定：
峰值内存消耗（含虚拟机） < 512M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
解析：
裸的BFS题，，稍微写麻烦了一点
package D;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.StringTokenizer;
public class Main {
static InputReader in = new InputReader(new BufferedInputStream(System.in));
static PrintWriter out = new PrintWriter(System.out);
static int[][] G = new int[200][200];
static boolean[][] vis = new boolean[200][200];
static int[] pmove = {0, 0, -1, 1};
static int[] qmove = {1, -1, 0, 0};
static Point[][] path = new Point[200][200];
static int n, sx, sy, ex, ey;
static class Point{
int x, y, cnt;
int ch;
public Point(int x, int y, int cnt, int ch) {
this.x = x;
this.y = y;
this.cnt = cnt;
this.ch = ch;
}
}
static boolean judge(int x, int y, int ch) {
if (x >= 0 && x < n && y >= 0 && y < n && vis[x][y] == false) {
// 必须走不相同的路
if (G[x][y] == ch) {
return false;
} else {
return true;
}
}
return false;
}
static void printPath(Point s) {
if (s.x == sx && s.y == sy) {
System.out.println("(0, 0)\n");
return ;
}
printPath(path[s.x][s.y]);
out.println(String.format("(%d, %d)", s.x, s.y));
}
static void BFS(Point s) {
ArrayDeque<Point> q = new ArrayDeque<Point>();
vis[s.x][s.y] = true;
q.offerLast(s);
while(!q.isEmpty()) {
Point tmp = q.pollFirst();
if (tmp.x == ex && tmp.y == ey) {
out.println(tmp.cnt);
out.flush();
out.close();
return ;
}
for (int i = 0; i < 4; i++) {
int nx = tmp.x + pmove[i];
int ny = tmp.y + qmove[i];
int ncnt = tmp.cnt + 1;
if (judge(nx, ny, tmp.ch)) {
vis[nx][ny] = true;
int ch = G[nx][ny];
s = new Point(nx, ny, ncnt, ch);
q.offerLast(s);
path[nx][ny] = tmp;
}
}
}
System.out.println("-1");
}
public static void main(String[] args) {
n = in.nextInt();
for (int i = 0; i < n; i++) {
String s = in.readLine();
int k = 0;
for (int j = 0; j < s.length(); j++) {
if (s.charAt(j) == ' ') continue;
if (s.charAt(j) == '+') {
G[i][k] = 1;
} else if (s.charAt(j) == '-') {
G[i][k] = 0;
} else if (s.charAt(j) == 'A') {
G[i][k] = -1;
sx = i;
sy = k;
} else if (s.charAt(j) == 'B') {
G[i][k] = -2;
ex = i;
ey = k;
}
k++;
}
}
BFS(new Point(sx, sy, 0, -1));
}
public static class InputReader {
public BufferedReader br;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
br = new BufferedReader(new InputStreamReader(stream), 32578);
tokenizer = null;
}
public String next() {
while(tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(br.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
public String readLine() {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return s;
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
5. 表格计算
某次无聊中， atm 发现了一个很老的程序。这个程序的功能类似于 Excel ，它对一个表格进行操作。
不妨设表格有 n 行，每行有 m 个格子。
每个格子的内容可以是一个正整数，也可以是一个公式。
公式包括三种：
- SUM(x1,y1:x2,y2) 表示求左上角是第 x1 行第 y1 个格子，右下角是第 x2 行第 y2 个格子这个矩形内所有格子的值的和。
- AVG(x1,y1:x2,y2) 表示求左上角是第 x1 行第 y1 个格子，右下角是第 x2 行第 y2 个格子这个矩形内所有格子的值的平均数。
- STD(x1,y1:x2,y2) 表示求左上角是第 x1 行第 y1 个格子，右下角是第 x2 行第 y2 个格子这个矩形内所有格子的值的标准差。
标准差即为方差的平方根。
方差就是：每个数据与平均值的差的平方的平均值，用来衡量单个数据离开平均数的程度。
公式都不会出现嵌套。
如果这个格子内是一个数，则这个格子的值等于这个数，否则这个格子的值等于格子公式求值结果。
输入这个表格后，程序会输出每个格子的值。atm 觉得这个程序很好玩，他也想实现一下这个程序。
「输入格式」
第一行两个数 n, m 。
接下来 n 行输入一个表格。每行 m 个由空格隔开的字符串，分别表示对应格子的内容。
输入保证不会出现循环依赖的情况，即不会出现两个格子 a 和 b 使得 a 的值依赖 b 的值且 b 的值依赖 a 的值。
「输出格式」
输出一个表格，共 n 行，每行 m 个保留两位小数的实数。
数据保证不会有格子的值超过 1e6 。
「样例输入」
3 2
1 SUM(2,1:3,1)
2 AVG(1,1:1,2)
SUM(1,1:2,1) STD(1,1:2,2)
「样例输出」
1.00 5.00
2.00 3.00
3.00 1.48
「数据范围」
对于 30% 的数据，满足： n, m <= 5
对于 100% 的数据，满足： n, m <= 50
资源约定：
峰值内存消耗（含虚拟机） < 512M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
解析：
这道题我是直接暴力循环做了，将表格用二维数组记录，有数字的就填入，将公式作为一个类，数据全部存到集合里，每次遍历集合，检查哪个公式可行，公式可行即更新表格
然后就一直循环~~，写的有些麻烦，用递归会更好些
package E;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Main {
static InputReader in = new InputReader(new BufferedInputStream(System.in));
static PrintWriter out = new PrintWriter(System.out);
static double[][] G = new double[105][105];
static boolean[][] vis = new boolean[105][105];
static class Node {
String name;
int posX, posY;
int x1, y1, x2, y2;
boolean flag; // 标记该公式是否被计算
public Node(String name, int posX, int posY, int x1, int y1, int x2, int y2, boolean flag) {
this.name = name;
this.posX = posX;
this.posY = posY;
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.flag = flag;
}
@Override
public String toString() {
return "Node [name=" + name + ", posX=" + posX + ", posY=" + posY + ", x1=" + x1 + ", y1=" + y1 + ", x2="
+ x2 + ", y2=" + y2 + "]";
}
}
static boolean judge(Node t) {
for (int i = t.x1; i <= t.x2; i++) {
for (int j = t.y1; j <= t.y2; j++) {
if (vis[i][j] == false) {
return false;
}
}
}
return true;
}
static double SUM(Node t) {
double s = 0;
for (int i = t.x1; i <= t.x2; i++) {
for (int j = t.y1; j <= t.y2; j++) {
s += G[i][j];
}
}
return s;
}
static double AVG(Node t) {
double s = 0;
for (int i = t.x1; i <= t.x2; i++) {
for (int j = t.y1; j <= t.y2; j++) {
s += G[i][j];
}
}
int a = t.x2 - t.x1 + 1;
int b = t.y2 - t.y1 + 1;
return s / (a*b);
}
static double STD(Node t) {
double avg = AVG(t);
double s = 0;
for (int i = t.x1; i <= t.x2; i++) {
for (int j = t.y1; j <= t.y2; j++) {
s += (G[i][j]-avg)*(G[i][j]-avg);
}
}
int a = t.x2 - t.x1 + 1;
int b = t.y2 - t.y1 + 1;
return Math.sqrt(s / (a*b));
}
public static void main(String[] args) {
int n = in.nextInt();
int m = in.nextInt();
ArrayList<Node> list = new ArrayList<Node>();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
String s = in.next();
if (s.indexOf("SUM") != -1) {
s = s.substring(4, s.length()-1);
String[] line = s.split(":");
String[] t1 = line[0].split(",");
String[] t2 = line[1].split(",");
int a = Integer.parseInt(t1[0]);
int b = Integer.parseInt(t1[1]);
int c = Integer.parseInt(t2[0]);
int d = Integer.parseInt(t2[1]);
list.add(new Node("SUM", i, j, a, b, c, d, false));
} else if (s.indexOf("AVG") != -1) {
s = s.substring(4, s.length()-1);
String[] line = s.split(":");
String[] t1 = line[0].split(",");
String[] t2 = line[1].split(",");
int a = Integer.parseInt(t1[0]);
int b = Integer.parseInt(t1[1]);
int c = Integer.parseInt(t2[0]);
int d = Integer.parseInt(t2[1]);
list.add(new Node("AVG", i, j, a, b, c, d, false));
} else if (s.indexOf("STD") != -1) {
s = s.substring(4, s.length()-1);
String[] line = s.split(":");
String[] t1 = line[0].split(",");
String[] t2 = line[1].split(",");
int a = Integer.parseInt(t1[0]);
int b = Integer.parseInt(t1[1]);
int c = Integer.parseInt(t2[0]);
int d = Integer.parseInt(t2[1]);
list.add(new Node("STD", i, j, a, b, c, d, false));
} else {
G[i][j] = Double.parseDouble(s);
vis[i][j] = true;
}
}
}
int k = 0;
int cnt = 0;
while (k < list.size()) {
Node t = list.get(cnt);
// 判断 t公式所在的矩形均为数字，而且t公式没有被计算过
if (judge(t) && t.flag == false) {
if (t.name.equals("SUM")) {
G[t.posX][t.posY] = SUM(t);
} else if (t.name.equals("AVG")) {
G[t.posX][t.posY] = AVG(t);
} else if (t.name.equals("STD")) {
G[t.posX][t.posY] = STD(t);
}
t.flag = true;
vis[t.posX][t.posY] = true;
k++;
}
cnt++;
cnt = cnt % list.size();
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
out.print(String.format("%.2f ", G[i][j]));
}
out.println();
}
out.flush();
out.close();
}
static public class InputReader {
public BufferedReader br;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
br = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while(tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(br.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
public String nextLine() {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return s;
}
public int nextInt() {
return Integer.parseInt(next());
}
public Long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
}
6. 铺瓷砖
待更新。
扫一扫
498
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
