这个选择结构是算不出来的吧。如果有别的思路，如循环和数组，大家也请指出，能解出来也行。
-
等级
本版专家分：135结帖率 100% -
java书上选择结构章节后，有一个课后习题，题目描述是下面这样的：
这个选择结构是算不出来的吧。如果有别的思路，如循环和数组，大家也请指出，能解出来也行。展开阅读全文
-
等级
本版专家分：4710勋章
-
- 签到新秀
-
- 红花 2018年9月 Oracle大版内专家分月排行榜第一
-
- 黄花 2018年11月 Oracle大版内专家分月排行榜第二
-
-
首先要注意每一个人包含两条信息，一个对的，一个错的。
然后做一个全排列组合，标识出每一个人的第一个回答是否正确，就像这样
11111
11110
11100... 一共5!个
之后可以用set之类的简化操作，查看每个人认为对的里面是否包含全部5个省份，再用认为错误的里面进行校验。
用眼睛去看，结果应该是这样的
A 2-陕 5-甘 ---> 5-甘
B 2-湖 4-山 ---> 2-湖
C 1-山 5-吉 ---> 1-山
D 3-湖 4-吉 ---> 4-吉
E 2-甘 3-陕 ---> 3-陕
-
等级
本版专家分：427
-
看看你能理解吗？
public class GuessProvinces {
private static Map<Integer, String> answerMap =
new HashMap<>();
private static Map<String,List<String>> guessesMap = new HashMap<>();
private static Map<Integer, String> SA = new HashMap<>();
private static Map<Integer, String> SB = new HashMap<>();
private static Map<Integer, String> SC = new HashMap<>();
private static Map<Integer, String> SD = new HashMap<>();
private static Map<Integer, String> SE = new HashMap<>();
static {
SA.put(2, "SHANXI");
SA.put(5, "GANSU");
SB.put(2, "HUBEI");
SB.put(4, "SHANDONG");
SC.put(1, "SHANDONG");
SC.put(5, "JILIN");
SD.put(3, "HUBEI");
SD.put(4, "JILIN");
SE.put(2, "GANSU");
SE.put(3, "SHANXI");
}
public static void main(String[] args) {
String StudentA_1 = "01000"; //0
String StudentA_2 = "00001"; //1
List<String> StudentA = new ArrayList<>();
StudentA.add(StudentA_1);
StudentA.add(StudentA_2);
String StudentB_1 = "01000"; //2
String StudentB_2 = "00010"; //3
List<String> StudentB = new ArrayList<>();
StudentB.add(StudentB_1);
StudentB.add(StudentB_2);
String StudentC_1 = "10000"; //4
String StudentC_2 = "00001"; //5
List<String> StudentC = new ArrayList<>();
StudentC.add(StudentC_1);
StudentC.add(StudentC_2);
String StudentD_1 = "00100"; //6
String StudentD_2 = "00010"; //7
List<String> StudentD = new ArrayList<>();
StudentD.add(StudentD_1);
StudentD.add(StudentD_2);
String StudentE_1 = "01000"; //8
String StudentE_2 = "00100"; //9
List<String> StudentE = new ArrayList<>();
StudentE.add(StudentE_1);
StudentE.add(StudentE_2);
guessesMap.put("A", StudentA);
guessesMap.put("B", StudentB);
guessesMap.put("C", StudentC);
guessesMap.put("D", StudentD);
guessesMap.put("E", StudentE);
List<String> guesses = guessesMap.values()
.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
int charPosition = 0;
while(answerMap.size() != 5){
if (charPosition > 4){
charPosition = 0;
}
guesses = guessesMap.values()
.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
int oneCounter = 0;
String guessHit = null;
for(String guess : guesses){
if(guess.charAt(charPosition) == '1'){
oneCounter++;
guessHit = guess;
}
}
if(oneCounter == 1){
removeInvalidGuess(guessHit);
}else{
checkAgainstAnswerMap();
}
charPosition ++;
System.out.println(answerMap);
}
System.out.println("Comparison is done");
}
private static void removeInvalidGuess(String guessHit){
for(Map.Entry<String, List<String>> entry : guessesMap.entrySet()){
if(entry.getValue().contains(guessHit)){
guessesMap.put(entry.getKey(), Arrays.asList(guessHit));
updateAnswerMap(entry.getKey(), guessHit);
}
}
}
private static void updateAnswerMap(String student, String answers){
int answerIndex = answers.indexOf("1") + 1;
switch (student){
case "A":
answerMap.put(answerIndex, SA.get(answerIndex));
break;
case "B":
answerMap.put(answerIndex, SB.get(answerIndex));
break;
case "C":
answerMap.put(answerIndex, SC.get(answerIndex));
break;
case "D":
answerMap.put(answerIndex, SD.get(answerIndex));
break;
case "E":
answerMap.put(answerIndex, SE.get(answerIndex));
break;
}
}
private static void checkAgainstAnswerMap(){
for(Map.Entry<String, List<String>> studentGuess : guessesMap.entrySet()){
String student = studentGuess.getKey();
List<String> answers = studentGuess.getValue();
if (answers.size() == 1){
return;
}
switch (student){
case "A":
for(String answer: answers){
int answerKey = answer.indexOf("1") + 1;
String studentAnswer = SA.get(answerKey);
Integer correctAnswerKey = (getKey(answerMap, studentAnswer));
if(correctAnswerKey!= null && answerKey != correctAnswerKey.intValue()){
guessesMap.get(student).remove(answer);
break;
}
}
break;
case "B":
for(String answer: answers){
int answerKey = answer.indexOf("1") + 1;
String studentAnswer = SB.get(answerKey);
Integer correctAnswerKey = (getKey(answerMap, studentAnswer));
if(correctAnswerKey!= null && answerKey != correctAnswerKey.intValue()){
guessesMap.get(student).remove(answer);
break;
}
}
break;
case "C":
for(String answer: answers){
int answerKey = answer.indexOf("1") + 1;
String studentAnswer = SC.get(answerKey);
Integer correctAnswerKey = (getKey(answerMap, studentAnswer));
if(correctAnswerKey!= null && answerKey != correctAnswerKey.intValue()){
guessesMap.get(student).remove(answer);
break;
}
}
break;
case "D":
for(String answer: answers){
int answerKey = answer.indexOf("1") + 1;
String studentAnswer = SD.get(answerKey);
Integer correctAnswerKey = (getKey(answerMap, studentAnswer));
if(correctAnswerKey!= null && answerKey != correctAnswerKey.intValue()){
guessesMap.get(student).remove(answer);
break;
}
}
break;
case "E":
for(String answer: answers){
int answerKey = answer.indexOf("1") + 1;
String studentAnswer = SE.get(answerKey);
Integer correctAnswerKey = (getKey(answerMap, studentAnswer));
if(correctAnswerKey!= null && answerKey != correctAnswerKey.intValue()){
guessesMap.get(student).remove(answer);
break;
}
}
break;
}
}
}
public static <K, V> K getKey(Map<K, V> map, V value)
{
return map.entrySet()
.stream()
.filter(entry -> value.equals(entry.getValue()))
.map(Map.Entry::getKey)
.findFirst().orElse(null);
}
}
最后结果
{1=SHANDONG, 2=HUBEI, 3=SHANXI, 4=JILIN, 5=GANSU}
-
等级
本版专家分：427
-
从给的答案，很容易判断1和5是哪个省份。然后再根据1和5的值去排除其他的错误答案。
-
等级
本版专家分：76 -
用选择结构没有问题，就是用选择结构列出了所有可能的情况，然后每个情况判断是否合理，合理就继续走，不合理就返回，执行另外的分支，把所有条件都走一遍就是了
if(A的第一句是对的){
if(B的第一句是对的){
if(C的第一句是对的){
if(D的第一句是对的){
if(E的第一句是对的){
//验证合理性
}else{ //E的第二句的是对的
//验证合理性
}
}else{ //D的第二句的是对的
}
}else{ //C的第二句的是对的
}
}else{ //A的第二句是对的
}
}else{ //A的第二句是对的
}
-
等级
本版专家分：4710勋章
-
- 签到新秀
-
- 红花 2018年9月 Oracle大版内专家分月排行榜第一
-
- 黄花 2018年11月 Oracle大版内专家分月排行榜第二
-
-
尴尬，高中数学竟然算错了，应该是2^5
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Test03 {
public static void main(String[] args) {
String[][] src = {
{"2", "陕", "5", "甘"},
{"2", "湖", "4", "山"},
{"1", "山", "5", "吉"},
{"3", "湖", "4", "吉"},
{"2", "甘", "3", "陕"},
};
List<String> list1 = Arrays.asList("1", "0");
List<List<String>> list = new ArrayList();
list.add(list1);
list.add(list1);
list.add(list1);
list.add(list1);
list.add(list1);
List<List<String>> result = new ArrayList<List<String>>();
descartes(list, result, 0, new ArrayList<String>());
Map<String, String> map = new HashMap();
Set<String> set = new HashSet();
a: for(List<String> res: result){
map = new HashMap();
set = new HashSet();
for(int i = 0; i < res.size(); i++){
if("1".equals(res.get(i)))
map.put(src[i][0], src[i][1]);
else
map.put(src[i][2], src[i][3]);
}
if(map.size() < 5)
continue;
set.addAll(map.values());
if(set.size() < 5)
continue;
for(int i = 0; i < res.size(); i++){
if("0".equals(res.get(i))){
if(map.get(src[i][0]).equals(src[i][1])){
continue a;
}
}else{
if(map.get(src[i][2]).equals(src[i][3])){
continue a;
}
}
}
prt(src, res);
}
}
private static void prt(String[][] src, List<String> list){
for(int i = 0; i < list.size(); i++){
if("1".equals(list.get(i)))
System.out.print(src[i][0] + "-" + src[i][1] + ", ");
else
System.out.print(src[i][2] + "-" + src[i][3] + ", ");
}
System.out.println();
}
private static void descartes(List<List<String>> dimvalue, List<List<String>> result, int layer, List<String> curList) {
if (layer < dimvalue.size() - 1) {
if (dimvalue.get(layer).size() == 0) {
descartes(dimvalue, result, layer + 1, curList);
} else {
for (int i = 0; i < dimvalue.get(layer).size(); i++) {
List<String> list = new ArrayList<String>(curList);
list.add(dimvalue.get(layer).get(i));
descartes(dimvalue, result, layer + 1, list);
}
}
} else if (layer == dimvalue.size() - 1) {
if (dimvalue.get(layer).size() == 0) {
result.add(curList);
} else {
for (int i = 0; i < dimvalue.get(layer).size(); i++) {
List<String> list = new ArrayList<String>(curList);
list.add(dimvalue.get(layer).get(i));
result.add(list);
}
}
}
}
}
-
等级
本版专家分：560勋章
-
- 签到新秀
-
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* A、B、C、D、E 五位同学
* 1、2、3、4、5 五个省份
* <p>
* A: 2 -> 陕西 5 -> 甘肃
* B: 2 -> 湖北 4 -> 山东
* C: 1 -> 山东 5 -> 吉林
* D: 3 -> 湖北 4 -> 吉林
* E: 2 -> 甘肃 3 -> 陕西
* <p>
* 每位同学答对一个省份，并且每个编号只有一位同学答对，问1-5号省份对应的名称
*/
public class Reasoning {
/**
* 同学
*/
private static List<String> students = new ArrayList<>(5);
/**
* 城市
*/
private static Map<Integer, String> citys = new HashMap<>(5);
/**
* 证词
*/
private static Map<String, Map<Integer, String>> testimony = new HashMap<>();
public static void main(String[] args) {
Reasoning reasoning = new Reasoning();
reasoning.prove();
System.out.println("最终得出：" + citys);
}
public Reasoning() {
students = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));
Map<Integer, String> A = new HashMap<>();
A.put(2, "陕西");
A.put(5, "甘肃");
testimony.put("A", A);
Map<Integer, String> B = new HashMap<>();
B.put(2, "湖北");
B.put(4, "山东");
testimony.put("B", B);
Map<Integer, String> C = new HashMap<>();
C.put(1, "山东");
C.put(5, "吉林");
testimony.put("C", C);
Map<Integer, String> D = new HashMap<>();
D.put(3, "湖北");
D.put(4, "吉林");
testimony.put("D", D);
Map<Integer, String> E = new HashMap<>();
E.put(2, "甘肃");
E.put(3, "陕西");
testimony.put("E", E);
}
/**
* 开始证明
* <p>
* 1.假设 A 答对 第一句
*/
private void prove() {
boolean check = true;
for (String student : students) {
Map<Integer, String> city = testimony.get(student);
boolean flag = false;
for (Integer cityCode : city.keySet()) {
String tempCityName = city.get(cityCode);
if (checkCity(student, cityCode, tempCityName)) {
flag = true;
break;
}
}
if (!flag) {
check = false;
System.out.println("学生" + student + "证词" + city + "没有得到验证。");
break;
}
}
// 冲突，前面假设出错
if (!check) {
citys.clear();
System.out.println("前期猜想出错，重新开始！");
revisionStu();
prove();
}
}
/**
* 验证猜想
*
* @param student 学生
* @param cityCode 城市代码
* @param tempCityName 城市名称
* @return 是否符合验证
*/
private boolean checkCity(String student, Integer cityCode, String tempCityName) {
String cityName = citys.get(cityCode);
if ((cityName == null || cityName.equals(tempCityName)) && !citys.containsValue(tempCityName)) {
citys.put(cityCode, tempCityName);
System.out.println("学生" + student + "证词：" + cityCode + "是" + tempCityName);
return true;
}
return false;
}
/**
* 调整学生顺序
*/
private void revisionStu() {
String stu = students.get(0);
students.remove(stu);
students.add(stu);
}
}
-
等级
本版专家分：285
-
这道题简单并不难，这里我使用Kotlin语言实现，不懂kotlin也没关系，看完我的思路之后，你自己用Java代码来实现一次完全可以的，这时你会发现java实现起来比kotlin的代码要多很多，这就是为什么Google在2017年的时候把Kotlin当成Android开发的官方语言了，大家有时间也应该学习一下Kotlin，只要是使用java开发的（比如后端开发），都可以使用kotlin来替换的，因为Kotlin最终编译后也是class字节码，底层其实就是java。我的实现代码没多少，我写了很多注释，还有空行，看起来多，其实重点只有 findAllRightAnswers() 函数，大概13行代码左右，看懂此函数就相当于整个题都懂了，代码如下
// 定义一个Answer类来表示一个答案
data class Answer(val number: Int, val name: String)
// 定义一个Student类来表示一个同学
data class Student(val first: Answer, val second: Answer)
fun main() {
// 定义A、B、C、D、E五个同学
val A = Student(Answer(2, "陕西"), Answer(5, "甘肃"))
val B = Student(Answer(2, "湖北"), Answer(4, "山东"))
val C = Student(Answer(1, "山东"), Answer(5, "吉林"))
val D = Student(Answer(3, "湖北"), Answer(4, "吉林"))
val E = Student(Answer(2, "甘肃"), Answer(3, "陕西"))
// 定义一个集合，保存未知正确答案的所有同学
var unknownAnswerStudentList = mutableListOf(A, B, C, D, E)
// 定义保存正确答案的集合
val rightAnswerList = mutableListOf<Answer>()
// 假设第一个人的第一个答案是正确答案，保存到正确答案集合中
rightAnswerList.add(A.first)
// 因为找到A同学的正确答案了，所以把A同学从集合中移除
unknownAnswerStudentList.remove(A)
// 找到所有正确答案
findAllRightAnswers(unknownAnswerStudentList, rightAnswerList, unknownAnswerStudentList.size)
if (rightAnswerList.size == 5) {
println("第一次假设就找到了正确答案，如下：")
} else {
println("第一次假设找不到正确答案，第二次肯定是正确答案，如下：")
// 没找齐5个答案，说明最初假设的答案是错的，则另一个必定是正确答案，重新找
unknownAnswerStudentList = mutableListOf(A, B, C, D, E)
rightAnswerList.clear()
rightAnswerList.add(A.second) // 假设另一个为正确答案
unknownAnswerStudentList.remove(A)
findAllRightAnswers(unknownAnswerStudentList, rightAnswerList, unknownAnswerStudentList.size)
}
// 打印正确答案
rightAnswerList.forEach(System.out::println)
}
fun findAllRightAnswers(unknownAnswerStudentList: MutableList<Student>, rightAnswerList: MutableList<Answer>, findCount: Int) {
// 遍历每一个同学，使用iterator是因为在遍历集合的同时还要删除集合的元素。
val iterator = unknownAnswerStudentList.iterator()
while (iterator.hasNext()) {
val student = iterator.next()
// 通过正确答案找正确答案
if (rightAnswerList.any { student.first.number == it.number || student.first.name == it.name }) {
// 如果第一个答案的编号或名称与正确答案的相同，根据"每个编号只有一个人答对"说明这个是错误答案，则第二个答案可能是正确答案
if (rightAnswerList.any { student.second.number == it.number || student.second.name == it.name }) {
// 如果第二个答案的编号或名称与正确答案相同，说明这个也是错误答案，说明我们的假设是错误的，无解，退出循环
break
}
rightAnswerList.add(student.second) // 找到了正确答案
iterator.remove() // 此学生已找到正确答案，可以从集合中移除掉了
} else if (rightAnswerList.any { student.second.number == it.number || student.second.name == it.name }) {
// 如果第二个答案的编号与正确答案的相同，根据"每个编号只有一个人答对"说明这个是错误答案，则第一个答案可能是正确答案
if (rightAnswerList.any { student.first.number == it.number || student.first.name == it.name }) {
// 如果第一个答案的编号或名称与正确答案相同，说明这个也是错误答案，说明我们的假设是错误的，无解，退出循环
break
}
rightAnswerList.add(student.first) // 找到了正确答案
iterator.remove() // 此学生已找到正确答案，可以从集合中移除掉了
}
}
if (unknownAnswerStudentList.size > 0 && findCount - 1 > 0) {
// 如果还有同学没找到正确答案，且没有超过查找次数，则递归循环去找
// 设定查找次数是因为如果你假设的答案是错误的，则永远也找不齐5个正确答案造成死循环
findAllRightAnswers(unknownAnswerStudentList, rightAnswerList, findCount - 1)
}
}
运行结果如下：
第一次假设找不到正确答案，第二次肯定是正确答案，如下：
Answer(number=5, name=甘肃)
Answer(number=1, name=山东)
Answer(number=3, name=陕西)
Answer(number=2, name=湖北)
Answer(number=4, name=吉林)
觉得难的同学都是Java基础不扎实造成的，大家可以关注我的博客，多多交流：https://blog.csdn.net/android_cai_niao
我也是第一次看到这道题，刚看到题时确实觉得有点难，但是当把题目审清楚理解清楚之后就很简单了，写代码的时候再使用面向对象的方式去写就非常的简单，比如一个学生用Student表示，而答案是一个学生的属性；一个答案用Answer表示，编号和省份是Answer的属性，大家一定要经常面向对象去写代码，不然你可能虽然有思路了，但是总感觉代码一写就觉得怎么没那么简单了！那是因为你的代码是面向过程的，不是面向对象的。
这里给大家讲一下我对题目的理解：每个同学都有两个答案，且肯定有一个是对的，有一个是错的，而且这个同学的正确答案肯定在另一个同学里有错误答案，这样才能推出这个同学的正确答案，比如：
A同学 2-陕西，5-甘肃
E同学 2-甘肃，3-陕西
我们就只看这两个同学，假设A同学的2-陕西是正确答案，根据"每个编号只有一个同学答对"的规则，可知2-甘肃是错的，因为2号只会对应到一个正确的省份陕西，反过来，陕西对应到了2号，则3-陕西也是错误答案了，什么？E同学的两个答案都是错误的？没错，就是这样的，存在这种情况是因为我们随便假设了一个答案为真，出现一个同学两答案都不正确的话，说明我们的假设出错了，出现了无解，此时再假设另一个答案为正确答案肯定就是对的了，因此，细节就是，通过一个正确答案的编号或省份名称都可以找到错误的答案，然后通过错误答案另一个自然就是正确答案了。
说了这么多，简单总结一下思路就是：随便假设一个是正确答案，我们可以通过一个正确答案找到错误答案，通过此错误答案又得到另一个正确答案，再通过这个正确答案再找错误答案，一直循环找就行了 ，总体思路是很简单的，就是细节上代码逻辑容易写错，慢慢调试就好了，关键总体思路不能乱！
最后再提醒一点，写代码一定要面向对象去写，很重要哦！
-
等级
本版专家分：135
-
感谢各位的热心回复
，我这段时间得静下心，好好学习了。
-
等级
本版专家分：135
-
首先感谢你的回答，你的答案，我研究了半天，觉得有点小问题，那就是如果每个人的第一个答案都不正确（理论上有可能），就会陷入无限循环。
还有，假设第一个人的第一个答案正确，后面验证不通过，也并不能说明第一个人的第一个答案是错误的，因为后面验证不通过，也可能是其它几个人的回答自相矛盾的问题。
你的代码，我改了下，用的LinkedHashMap（以方便记住顺序），把每个人的答案顺序调了下（答案内容不变），即正确答案都是后面第二个（或者大多数都在后面第二个），就陷入递归层次太多，内存溢出了。
改动代码如下：
package chapter4;
import java.util.*;
/**
* A、B、C、D、E 五位同学
* 1、2、3、4、5 五个省份
* <p>
* A: 2 -> 陕西 5 -> 甘肃
* B: 2 -> 湖北 4 -> 山东
* C: 1 -> 山东 5 -> 吉林
* D: 3 -> 湖北 4 -> 吉林
* E: 2 -> 甘肃 3 -> 陕西
* <p>
* 每位同学答对一个省份，并且每个编号只有一位同学答对，问1-5号省份对应的名称
*/
public class Reasoning {
/**
* 同学
*/
private static List<String> students = new ArrayList<>(5);
/**
* 城市
*/
private static Map<Integer, String> citys = new HashMap<>(5);
/**
* 证词
*/
private static Map<String, Map<Integer, String>> testimony = new HashMap<>();
public static void main(String[] args) {
Reasoning reasoning = new Reasoning();
reasoning.prove();
System.out.println("最终得出：" + citys);
}
public Reasoning() {
students = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));
Map<Integer, String> A = new LinkedHashMap<>();
A.put(2, "陕西");
A.put(5, "甘肃");
testimony.put("A", A);
Map<Integer, String> B = new LinkedHashMap<>();
B.put(4, "山东");
B.put(2, "湖北");
testimony.put("B", B);
Map<Integer, String> C = new LinkedHashMap<>();
C.put(5, "吉林");
C.put(1, "山东");
testimony.put("C", C);
Map<Integer, String> D = new LinkedHashMap<>();
D.put(4, "吉林");
D.put(3, "湖北");
testimony.put("D", D);
Map<Integer, String> E = new LinkedHashMap<>();
E.put(2, "甘肃");
E.put(3, "陕西");
testimony.put("E", E);
}
/**
* 开始证明
* <p>
* 1.假设 A 答对 第一句
*/
private void prove() {
boolean check = true;
for (String student : students) {
Map<Integer, String> city = testimony.get(student);
boolean flag = false;
for (Integer cityCode : city.keySet()) {
String tempCityName = city.get(cityCode);
if (checkCity(student, cityCode, tempCityName)) {
flag = true;
break;
}
}
if (!flag) {
check = false;
System.out.println("学生" + student + "证词" + city + "没有得到验证。");
break;
}
}
// 冲突，前面假设出错
if (!check) {
citys.clear();
System.out.println("前期猜想出错，重新开始！");
revisionStu();
prove();
}
}
/**
* 验证猜想
*
* @param student 学生
* @param cityCode 城市代码
* @param tempCityName 城市名称
* @return 是否符合验证
*/
private boolean checkCity(String student, Integer cityCode, String tempCityName) {
String cityName = citys.get(cityCode);
if ((cityName == null || cityName.equals(tempCityName)) && !citys.containsValue(tempCityName)) {
citys.put(cityCode, tempCityName);
System.out.println("学生" + student + "证词：" + cityCode + "是" + tempCityName);
return true;
}
return false;
}
/**
* 调整学生顺序
*/
private void revisionStu() {
String stu = students.get(0);
students.remove(stu);
students.add(stu);
}
}
- 为什么你学过Java却忘光了——记第一次助教同学见面会，java开发面试笔试题
我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。 扫描二维码加VX好友，拉你进【程序员面试学习交流群】免费领取。也欢迎各位一起在群里探讨技术。 大约...
- Java面试复习大纲2.0（持续更新）
02-26 奋斗蒙 Java帮帮面试复习大纲（Java帮帮总结）【人事】31道，不准备就掉坑的问题【简历】1年简历模板一【简历】2年简历模板一【简历】3年简历模板一【面试】面试练习题大集合（持续更新中...欢迎问题投稿）...
- 百度+京东+美团Java面经合集
http://www.importnew.com/22083.html http://www.importnew.com/22087.html http://ifeve.com/questions/?sort=views 作者：Hjyilu 链接：...amp;amp;amp;amp;order=3&......
- 五年Java外包转型大数据架构，就是这么霸气
前言乔二爷(化名)是我学习群的元老，我们去年就认识，他是五年Java经验的老鸟。去年年底他刚开始学大数据的时候给我打过电话，咨询一些学习路线上的问题，那时刚转型大数据的我...
- 一个月拿到阿里字节拼多多美团offer总结
我安琪拉回来了，很久都没更新文章了，原因嘛那就是安琪拉刚入职蚂蚁，忙着培训，熟悉业务和项目的技术框架，不过你们嘱咐我写的面经不敢忘记，跳票了好几次，现在趁着周末一波，趁着还能记起一些立刻呈现给大家，也...
- 五年Java外包转型大数据架构
乔二爷(化名)是我学习群的元老，我们去年就认识，他是五年Java经验的老鸟。去年年底他刚开始学大数据的时候给我打过电话，咨询一些学习路线上的问题，那时刚转型大数据的我给了他几点不太成熟的建议，今年年初就成功...
- 一个半月拿到阿里字节拼多多美团offer总结
〇. 战况蚂蚁：一轮笔试+五轮技术+一轮HR ????饿了么：三轮技术面 + 一轮HR 面 ????抖音：三轮技术面 + 一轮HR 面 ...
- 峰哥读者一个半月拿到阿里字节拼多多美团offer总结
点击上方 "大数据肌肉猿"关注,星标一起成长后台回复【加群】，进入高质量学习交流群2021年大数据肌肉猿公众号奖励制度〇. 战况蚂蚁：一轮笔试+五轮技术+一轮HR ...
- 一个半月拿到阿里字节拼多多美团 offer 总结
本篇为一位读者的投稿，来自他去年社招的经历，写的相当全面。希望这篇文章能对大家求职有帮助，愿大家都能加入自己心仪的公司！战况 蚂蚁：一轮笔试 + 五轮技术面（其中二轮跨部门交叉面） + 一...
- 初学Java （不要再删了！！！）
有个朋友请教Java内容。我就把作业给她看，备她使用，并一同学习。现在放到这里，也是一同学习的意思。发表自己的想法和学习内容，很爽的！第一篇，试水作业。第二篇boolean数据类型用法运算符【逻辑运算符、关系...
- 合工大java机试_2016合工大机械初试+复试心得
学弟学妹们大家好，本人合工大本部机械已经拟录取，考前说过想回馈论坛，但时过境迁，人在改变，刚好昨晚好几个学弟找我问经验，趁着热情还在，赶紧动手完成，希望能帮到大家。今年工科数学考得难，自己辛辛苦苦准备...
- 为什么你学过Java却忘光了——记第一次助教同学见面会
但随着日子临近，我请教了周筠老师，周筠老师和我谈到福州大学的两个助教都是来自深圳的工程师，他们分别被老师请到学校里和同学们交流，然后周老师提示我，说，可以思考如下问题： “这些同学的作业你已经看了一...
- 超硬核十万字！全网最全 数据结构 代码，随便秒杀老师/面试官，我说的
本文代码实现基本按照《数据结构》课本目录顺序，外加大量的复杂算法实现，一篇文章足够。能换你一个收藏了吧？
- 超硬核！数据结构学霸笔记，考试面试吹牛就靠它
上次发操作系统笔记，很快浏览上万，这次数据结构比上次硬核的多哦，同样的会发超硬核代码，关注吧。
- 请叫我面霸！面试拼多多，从一面到入职，我只用了35天！
总体耗时基本在一个月左右，除了蚂蚁流程比较慢，体检背调就花了二周，大体在一个半月定下来，期间发生了很多有趣的事情，后面慢慢跟大家说。 下面按着这样的节奏来介绍： 个人介绍； 写一份不被扔垃圾桶的简历； ...
- 程序员-人事面试题、包含缺点、优点、自我介绍、范文
【解答思路】：建议大家用2分钟得自我介绍，面试官较喜欢的自我介绍1、有亮点，每一小段都有一个亮点，而不是平铺直叙2、有互动，每一小段都会和面试官互动，而不是自说自话，但是切记，这种互动并不需要面试官配合...
- 程序员修炼之路（四）走近腾讯 走进腾讯（一个关于面试准备的记录）
关于准备面试，自己也有很多感触，当初在大三面试失利的时候，也有3个月左右的时间强化突击基础知识，每天花费8到11个小时，学的东西比我前面3年学的都多，但是和下面这位前辈（因为这是一篇比较老的文章）比起来，...
- 9.1 一切让代码行数说话——《逆袭大学》连载
返回到【全文目录】 9.1 一切让代码行数说话...有业内人士描述：当你写过一百行代码的时候，对编程有了一个朦胧、感性的认识；当你编码的行数达到一千的时候，差不多掌握了编程的基本结构；当你写过一万行代码的时...
- 面试经验之：蚂蚁饿了么抖音美团等多家面试问题！简历优化等
蚂蚁：一轮笔试+五轮技术+一轮HR ???? 饿了么：三轮技术面 + 一轮HR 面 ???? 抖音：三轮技术面 + 一轮HR 面 ???? 拼多多：三轮技术面 + 一轮HR 面 ???? 美团：三轮技术面 + 一轮HR 面 ???? 比心：三轮技术面 + 一轮...
- 熬夜写的数据结构与算法学习指南，可能是最适合新手的了！（附赠资料）
1、你需要的不是一个参考2、不要钻牛角尖3、一定要多交流4、你得多动手（不是让你找人打架）那么针对数据结构与算法该怎么学习？我们需要学习哪些知识点？（附有思维导图）基础中的基础复杂度基础的数据结构那些需要...
- 应届生必看的职场建议
应届生必看的职场建议前言职业发展学习方法篇为人处事篇情绪管理篇 前言 最近这段时间，帮很多准应届生、应届生、毕业3年内的小伙伴解答过很多疑惑。我耐心地看着他们发给我的个人经历与面临的问题，悉数为他们提供...
- 8w 字，给程序员的职场第一课（上篇）
同时，文章里面给出了一些我的职场经历，希望能够让大家对程序员这个圈子有所深入理解。总计 30 讲，这一篇是上篇，目录清单： 前言：关于职场，你需要不断拼搏 大学最重要的 8 件事 大公司...
- 京东面试官：从求职者到面试官的心路历程
一、说在前面 本篇文章主要介绍自己面试的心得以及工作后怎么在人才济济部门脱颖而出，去尝试作为技术骨干做技术输出，并且有机会参与人才招聘和培养计划的，不是用来教你如何去准备面试，是想要你明白我们怎么做才...
- C++经典书籍推荐
C++是一门广泛用于工业软件研发的大型语言。它自身的复杂性和解决现实问题的能力，使其极具学术研究价值和工业价值。和C语言一样，C++已经在...也许C++与C合为一体永远都是一个梦想，也许Java和C#的狂潮终将迫使C++回归
- Java面试题大全（备战2021）
这本面试手册包含了Java基础、Java集合、JVM、Spring、Spring Boot、Spring Cloud、Mysql、Redis、RabbitMQ、Dubbo、Netty、分布式及架构设计等方面的技术点。内容难度参差，满足初中高级Java工程师的面试需求。
- 波士顿房价预测数据及代码
本资源包含数据，代码，解释，相应的文件。代码是练习用的，文章中的代码都可以运行出来，是很好的一个练手项目。
- 以太坊ETH挖矿图文教程2.0
本教程页数不多，7页，主要描述如何使用以太坊ETH挖矿，图文并茂的展示和流程细节的体现，基本看了一遍就肯定能够学会了。
- OpenGL-实现视频播放(FFMpeg)
课程采用FFMpeg作视频解码，采用OpenGL实现视频的渲染，从RGB数据的绘制，到直接渲染YUV数据，实现三路YUV数据单纹理的输入，提升系统性能，接着采用PBO方式优化内存到显存的传输，实现DMA传输，解放CPU,将解码和渲染分离到不同的线程中，极大的提升了系统的性能。后介绍视频特效的实现。 介绍如何采用OpenGL渲染视频帧数据，从固定管线到可编程管线一次实现，采用PBO实现DMA数据传输处理，以及简单的视频特效的实现。
- python大作业--爬虫（完美应付大作业）.zip
python大作业分享--30多个项目任你选（由于上传大小限制分多个文件上传。爬虫：https://download.csdn.net/download/weixin_43960044/12533382小游戏：https://download.csdn.net/download/weixin_43960044/12533379），应付大作业完全没问题。内涵30多个项目，随意挑选。爬虫（爬抖音视频、下载B站视频、怕天气预报等）小游戏（五子棋、坦克大战、贪吃蛇、拼图等）。
- LABVIEW入门与实战开发100例.pdf
LABVIEW入门与实战开发100例，从基础到入门的基本实例。