vivo笔试题（含答案）
Posted 程序dunk
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了vivo笔试题（含答案）相关的知识，希望对你有一定的参考价值。
总结不易，如果对你有帮助，请点赞关注支持一下
微信搜索程序dunk，关注公众号，定期分享Java笔试、面试题
目录
编译依赖问题(90% -> AC)
一个完整的软件项目往往会包含很多由代码和文档组成的源文件。编译器在编译整个项目的时候，可能需要按照依赖关系来依次编译每个源文件。比如，A.cpp 依赖 B.cpp，那么在编译的时候，编译器需要先编译 B.cpp，才能再编译 A.cpp。 假设现有 0，1，2，3 四个文件，0号文件依赖1号文件，1号文件依赖2号文件，3号文件依赖1号文件，则源文件的编译顺序为 2,1,0,3 或 2,1,3,0。现给出文件依赖关系，如 1,2,-1,1，表示0号文件依赖1号文件，1号文件依赖2号文件，2号文件没有依赖，3号文件依赖1号文件。请补充完整程序，返回正确的编译顺序。注意如有同时可以编译多个文件的情况，按数字升序返回一种情况即可，比如前述案例输出为：2,1,0,3
输入例子1:
"1,2,-1,1"
输出例子1:
"2,1,0,3"
自己的做法
比较迷，看到这道题第一反应，这不是并查集吗，奥不对，并查集是只能找到最顶级的依赖，这个题明显不是这个意思，然后自己做了一个多叉树吧，应该叫字典树吧，每个节点保存当前信息和所有依赖它的节点信息，用一个list集合存放所有的顶级节点，最终dfs输出就行，只通过了90%
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* 编译顺序
* @param input string字符串
* @return string字符串
*/
StringBuilder builder = new StringBuilder();
public String compileSeq (String input) {
// write code here
Map<Integer, DependTree> map = new HashMap();
List<Integer> res = new ArrayList<>();
String[] depends = input.split(",");
for (int i = 0; i < depends.length; i++) {
int child = i;
int parent = Integer.parseInt(depends[i]);
if (parent == -1) {
res.add(child);
if (!map.containsKey(child))
map.put(child, new DependTree(child));
continue;
}
if (map.containsKey(parent)) {
DependTree PT = map.get(parent);
DependTree CP = null;
if (map.containsKey(child)) {
CP = map.get(child);
} else {
CP = new DependTree(child);
map.put(child, CP);
}
PT.child.add(CP);
} else {
DependTree PT = new DependTree(parent);
map.put(parent, PT);
DependTree CP = null;
if (map.containsKey(child)) {
CP = map.get(child);
} else {
CP = new DependTree(child);
map.put(child, CP);
}
PT.child.add(CP);
}
}
for (int i = 0; i < res.size(); i++) {
dfs(map.get(res.get(i)));
}
return builder.toString().substring(0, builder.length() - 1);
}
private void dfs(DependTree dependTree) {
builder.append(dependTree.val + ",");
for(DependTree sub : dependTree.child) {
dfs(sub);
}
}
}
class DependTree {
public int val;
public List<DependTree> child = new ArrayList<>();
public DependTree(int val) {
this.val = val;
}
}
分析一下错误
您的代码已保存
答案错误:您提交的程序没有通过所有的测试用例
case通过率为90.00%
用例:
“8,2,7,4,6,-1,5,5,6”
对应输出应该为:
“5,6,4,3,7,2,1,8,0”
你的输出为:
“5,6,4,3,8,0,7,2,1”
画一下依赖树
发现问题，没有满足按数字升序返回一种情况即可
改进（AC）
使用优先队列
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* 编译顺序
* @param input string字符串
* @return string字符串
*/
StringBuilder builder = new StringBuilder();
public String compileSeq (String input) {
// write code here
Map<Integer, DependTree> map = new HashMap();
List<Integer> res = new ArrayList<>();
String[] depends = input.split(",");
for (int i = 0; i < depends.length; i++) {
int child = i;
int parent = Integer.parseInt(depends[i]);
if (parent == -1) {
res.add(child);
if (!map.containsKey(child))
map.put(child, new DependTree(child));
continue;
}
if (map.containsKey(parent)) {
DependTree PT = map.get(parent);
DependTree CP = null;
if (map.containsKey(child)) {
CP = map.get(child);
} else {
CP = new DependTree(child);
map.put(child, CP);
}
PT.child.add(CP);
} else {
DependTree PT = new DependTree(parent);
map.put(parent, PT);
DependTree CP = null;
if (map.containsKey(child)) {
CP = map.get(child);
} else {
CP = new DependTree(child);
map.put(child, CP);
}
PT.child.add(CP);
}
}
PriorityQueue<DependTree> queue = new PriorityQueue<DependTree>(Comparator.comparingInt(o -> o.val));
res.sort(Integer::compareTo);
for (int i = 0; i < res.size(); i++) {
queue.offer(map.get(res.get(i)));
while (!queue.isEmpty()) {
DependTree cur = queue.poll();
for(DependTree sub : cur.child) {
queue.offer(sub);
}
builder.append(cur.val + ",");
}
}
return builder.toString().substring(0, builder.length() - 1);
}
}
class DependTree {
public int val;
public List<DependTree> child = new ArrayList<>();
public DependTree(int val) {
this.val = val;
}
}
回文字符串(AC)
回文字符串就是正读和反读都一样的字符串，如“viv”、“nexen”、“12321”、“qqq”、“翻身把身翻” 等。
给定一个非空字符串 str，在最多可以删除一个字符的情况下请编程判定其能否成为回文字符串；如果可以则输出首次删除一个字符所能得到的回文字符串，如果不行则输出字符串 “false” 。
输入描述:
一个非空字符串
输出描述:
一个回文字符串，或者 "false" 字符串（如果无法构造出回文字符串的话）
输入z子1:
abda
输出例子1:
ada
例子说明1:
删除字符串"abda"中的一个字符 ‘b’ 后，得到 "ada"是一个回文字符串；删除一个字符 ‘d’ 后，得到 "aba"也是一个回文字符串；所以最终输出为 "ada"。
有点懵逼，明明是最多删除一个字符的情况，但是不删除的情况是错的
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String input = in.next();
int index = 0;
for (int i = 0; i < input.length(); i++) {
StringBuilder builder = new StringBuilder(input);
builder.delete(i, i + 1);
if (isPalindrome(builder.toString())) {
System.out.println(builder.toString());
return;
}
}
System.out.println(false);
}
private static boolean isPalindrome(String input) {
int l = 0;
int r = input.length() - 1;
while (l <= r) {
if (input.charAt(l) != input.charAt(r)) return false;
l++;
r--;
}
return true;
}
}
游戏地图路径(AC)
vivo游戏中心的运营小伙伴最近接到一款新游戏的上架申请，为了保障用户体验，运营同学将按运营流程和规范对其做出分析评估。经过初步了解后分析得知，该游戏的地图可以用一个大小为 n*n 的矩阵表示，每个元素可以视为一个格子，根据游戏剧情设定其中某些格子是不可达的(比如建筑、高山、河流或者其它障碍物等)，现在请你设计一种算法寻找从起点出发到达终点的最优抵达路径，以协助运营小伙伴评估该游戏的可玩性和上手难度。
输入描述:
第一行表示矩阵大小 n，5 <n < 10000
第二行表示起点和终点的坐标
第三行起是一个用矩阵表示的游戏地图，其中#或者@表示障碍物，其他字母、非0数字、以及符号+、-、* 等等均表示普通可达格子，共有 n 行 n 列
输出描述:
输出最优路径的长度；若无法到达，则输出-1
输入例子1:
15
0 7 7 7
*5#++B+B+++++$3
55#+++++++###$$
###$++++++#+*#+
++$@$+++$$$3+#+
+++$$+++$+4###+
A++++###$@+$++A
+++++#++$#$$+++
A++++#+5+#+++++
+++$$#$++#++++A
+++$+@$###+++++
+###4+$+++$$+++
+#+3$$$+++$##++
+#*+#++++++#$$+
$####+++++++$##
3$+++B++B++++#5
输出例子1:
13
记忆化搜索
import java.util.*;
public class Main {
static int N, endX, endY;
static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
static int[][] map;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
N = in.nextInt();
int startY = in.nextInt();
int startX = in.nextInt();
endY = in.nextInt();
endX = in.nextInt();
int[][] grid = new int[N][N];
for (int i = 0; i < N ; i++) {
String line = in.next();
for (int j = 0; j < N; j++) {
if (line.charAt(j) == '#' || line.charAt(j) == '@') {
grid[i][j] = -1;
}
}
}
map = new int[N][N];
/*for (int[] res : map) {
System.out.println(Arrays.toString(res));
}
System.out.println();*/
for (int i = 0; i < map.length; i++)
Arrays.fill(map[i], Integer.MAX_VALUE);
dfs(startX, startY, 0, grid);
if (map[endX][endY] == Integer.MAX_VALUE) {
System.out.println(-1);
} else {
System.out.println(map[endX][endY]);
}
}
private static void dfs(int startX, int startY, int count, int[][] grid) {
if (startX < 0 || startX >= N
|| startY < 0 || startY >= N
|| grid[startX][startY] == -1
|| count >= map[startX][startY])
return;
map[startX][startY] = count;
for (int[] dir : dirs) {
int curX = startX + dir[0];
int curY = startY + dir[1];
dfs(curX, curY, count + 1, grid);
}
}
}
2021/6/6更新
手机屏幕解锁模式(60% -> AC)
现有一个 3x3 规格的 android 智能手机锁屏程序和两个正整数 m 和 n ，请计算出使用最少m 个键和最多 n个键可以解锁该屏幕的所有有效模式总数。
其中有效模式是指：
1、每个模式必须连接至少m个键和最多n个键；
2、所有的键都必须是不同的；
3、如果在模式中连接两个连续键的行通过任何其他键，则其他键必须在模式中选择，不允许跳过非选择键（如图）；
4、顺序相关，单键有效（这里可能跟部分手机不同）。
输入：m,n
代表允许解锁的最少m个键和最多n个键
输出：满足m和n个键数的所有有效模式的总数
输入例子1:
1,2
输出例子1:
65
例子说明1:
输入m=1，n=2，表示最少1个键，最多2个键，符合要求的键数是1个键和2个键，其中1个键的有效模式有9种，两个键的有效模式有56种，所以最终有效模式总数是9+56=65种，最终输出65。
60%
思路：没得说，递归吧
import java.util.*;
public class Solution {
/**
* 实现方案
* @param m int整型 最少m个键
* @param n int整型 最多n个键
* @return int整型
*/
int min, max;
int sum;
public int solution (int m, int n) {
// write code here
if(m > n) return 0;
this.min = m;
this.max = n;
sum = 0;
字节笔试题（含答案）