大三学生实习面试经历（1）

最近听了一位学长的建议，不能等一切都准备好再去开始，于是就开始了简历投递，恰好简历过了某小厂的初筛，开启了线上面试，记录了一些问题：

（通过面试也确实了解到了自己在某些方面确实做的还不够充分，需要继续努力）

1.思维题毒蘑菇

现在有1011种蘑菇，其中1种是毒蘑菇。人一旦吃了微量的毒蘑菇，就会在72小时后发作身亡。现在用松鼠做试验，从开始喂松鼠计时，要在72小时后马上找出毒蘑菇，问最少需要多少只松鼠?(需要给出解题过程)

要找出1011种蘑菇中的毒蘑菇，我当时回答的是使用二进制数的方法来减少所需的松鼠数量。具体过程如下：

1. 理解问题：我们有1011种蘑菇，且知道其中只有一种是毒蘑菇。我们的目标是在72小时后确定哪一种是毒蘑菇。

2. 二进制编码：我们可以将每一种蘑菇用一个二进制数来表示。由于我们有1011种蘑菇，我们需要找到一个足够的二进制位数，以便能够区分所有的蘑菇。

3. 计算所需的位数：我们需要找到满足 ( 2^n 大于等于 1011 ) 的最小整数 ( n )。

   • 计算 ( 2^{10} = 1024 )，而 ( 2^9 = 512 )。
   • 因此，10位二进制数可以表示从0到1023的数字，可以区分1011种蘑菇。

4. 分配松鼠：每一只松鼠可以对应二进制数中的一位：

   • 如果第 ( i ) 位为1，则该松鼠会吃掉对应的蘑菇；如果为0，则该松鼠不会吃。
   • 通过这种方式，每一只松鼠的生死情况（是否中毒）可以反映出对应的二进制位。

5. 结果：因为需要10位二进制数来标识每一种蘑菇，所以我们至少需要10只松鼠。

结论

最少需要10只松鼠来确定哪一种蘑菇是毒蘑菇。

2.Java编程题

1.给定一个List<string〉，编写一个方法删除所有重复的字符串，并保持原有顺序不变

测试数据:["apple","banana","apple","orange","banana","grape","grape"]

输出:["apple","banana","orange","grape"]

2.给定一个Map<string,Integer〉，其中键是名字，值是年龄。编写一个方法找出年龄最人的三个人的名字。

测试数据:{"John":35,"Bob":40,"Alice":30,"Tom":45,"Jerry": 50}

输出:[Jerry"，"TOm"""Bob"

3.编写一个方法，接收一个List，返回一个Map，其中键是列表中的字符串，值是该字符串在列表中出现的次数。

测试数据:["apple"，"banana"，"apple"，"orange","banana","grape","grape"

输出:{"apple":2，"banana":2,"orange":1."grape": 2}

4.给定一个List，其中的字符串可能包含数字和字母。编写一个方法，将列表中的字符串分为两个列表，一个包含只包含数字的字符串，另一个包含只包含字母的字符串。

测试数据:「"123"，"abc"，"456"，"def"."789""ghi"]

输出:数字列表:["123"，"456"，"789"]，字母列表:["abc"，"def"，"ghi"]

5.给定一个Map<string,List>，键是学生的名字，值是他们的成绩列表。编写一个方法，返回一个新的Map，键是学生的名字，值是他们的平均成绩。

测试数据:{"John":[85,90,95],"Bob":[80,85,90]，"Alice":[95，100，105]}

输出:f"John":90.0，"Bob":85.0，"Alice":180.0]

6.给定一个List<string〉，每个字符串都是一个山逗号分隔的名字和电子邮件地址(例如，"JohnDoe,john@doe.com")。编写一个方法，将这个列表转换为一个Map，其中键是电子邮件地址，值是对应的名字

测试数据:["John Doe,john@doe.com""Bob smith,bob@smith.com","Alice Johnson,alice@iohnson.com"

输出:{"john@doe.com":"John Doe"."bob@smith.com": "Bob Smith", "alice@iohnson.com": "Alice Johnson"}

下面是针对每个问题的重述、代码实现和思路分析

1. 删除所有重复的字符串，并保持原有顺序不变

题目重述：给定一个字符串列表，删除所有重复的字符串，并保持原有的顺序。

代码实现一：

import java.util.*;

public class RemoveDuplicates {
    public static List<String> removeDuplicates(List<String> strings) {
        Set<String> seen = new LinkedHashSet<>(strings);
        return new ArrayList<>(seen);
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("apple", "banana", "apple", "orange", "banana", "grape", "grape");
        List<String> output = removeDuplicates(input);
        System.out.println(output); // 输出: [apple, banana, orange, grape]
    }
}

思路：

• 使用 LinkedHashSet 来存储字符串，LinkedHashSet 保持插入顺序且不允许重复元素。
• 将输入列表传入 LinkedHashSet，然后转换回 ArrayList 以获得所需的输出格式。

代码实现二：

import java.util.*;

public class RemoveDuplicates {
    public static List<String> removeDuplicates(List<String> strings) {
        List<String> result = new ArrayList<>();
        for (String str : strings) {
            if (!result.contains(str)) {
                result.add(str);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("apple", "banana", "apple", "orange", "banana", "grape");
        List<String> output = removeDuplicates(input);
        System.out.println(output); // 输出: [apple, banana, orange, grape]
    }
}

思路：

• 创建一个新的列表 result 来存储不重复的字符串。
• 遍历输入列表，检查 result 中是否已包含当前字符串，如果没有，则添加它。

---

2. 找出年龄最小的三个人的名字

题目重述：给定一个映射，键是名字，值是年龄，找出年龄最小的三个人的名字。

代码实现一：

import java.util.*;

public class YoungestPeople {
    public static List<String> findYoungest(Map<String, Integer> ages) {
        return ages.entrySet()
                .stream()
                .sorted(Map.Entry.comparingByValue())
                .limit(3)
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        Map<String, Integer> input = new HashMap<>();
        input.put("John", 35);
        input.put("Bob", 40);
        input.put("Alice", 30);
        input.put("Tom", 45);
        input.put("Jerry", 50);
        
        List<String> output = findYoungest(input);
        System.out.println(output); // 输出: [Alice, John, Bob]
    }
}

思路：

• 将 Map 转换为流，按值（年龄）排序。
• 使用 limit(3) 选择前3个最小的值，并提取相应的键（名字）。
• 最后将结果收集到列表中。

代码实现二：

import java.util.*;

public class YoungestPeople {
    public static List<String> findYoungest(Map<String, Integer> ages) {
        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(ages.entrySet());
        entryList.sort(Map.Entry.comparingByValue());
        
        List<String> youngest = new ArrayList<>();
        for (int i = 0; i < Math.min(3, entryList.size()); i++) {
            youngest.add(entryList.get(i).getKey());
        }
        return youngest;
    }

    public static void main(String[] args) {
        Map<String, Integer> input = new HashMap<>();
        input.put("John", 35);
        input.put("Bob", 40);
        input.put("Alice", 30);
        input.put("Tom", 45);
        input.put("Jerry", 50);
        
        List<String> output = findYoungest(input);
        System.out.println(output); // 输出: [Alice, John, Bob]
    }
}

思路：

• 将 Map 转换为列表并排序。
• 选择前3个最小年龄的名字。

---

3. 计算字符串出现的次数

题目重述：给定一个字符串列表，返回一个映射，其中键是字符串，值是该字符串在列表中出现的次数。

代码实现一：

import java.util.*;

public class CountOccurrences {
    public static Map<String, Integer> countOccurrences(List<String> strings) {
        Map<String, Integer> countMap = new HashMap<>();
        for (String str : strings) {
            countMap.put(str, countMap.getOrDefault(str, 0) + 1);
        }
        return countMap;
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("apple", "banana", "apple", "orange", "banana", "grape", "grape");
        Map<String, Integer> output = countOccurrences(input);
        System.out.println(output); // 输出: {apple=2, banana=2, orange=1, grape=2}
    }
}

思路：

• 使用 HashMap 来存储每个字符串及其出现的次数。
• 遍历列表，对于每个字符串，更新其计数。
• 使用 getOrDefault 方法来处理未出现的字符串。

代码实现二：

import java.util.*;

public class CountOccurrences {
    public static Map<String, Integer> countOccurrences(List<String> strings) {
        Map<String, Integer> countMap = new HashMap<>();
        for (String str : strings) {
            countMap.put(str, countMap.getOrDefault(str, 0) + 1);
        }
        return countMap;
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("apple", "banana", "apple", "orange", "banana", "grape");
        Map<String, Integer> output = countOccurrences(input);
        System.out.println(output); // 输出: {apple=2, banana=2, orange=1, grape=1}
    }
}

思路：

• 使用 HashMap 来存储每个字符串及其出现的次数。
• 遍历列表，更新计数。

---

4. 将字符串分为数字和字母列表

题目重述一：给定一个字符串列表，将字符串分为两个列表，一个包含只包含数字的字符串，另一个包含只包含字母的字符串。

代码实现：

import java.util.*;

public class SeparateNumbersAndLetters {
    public static Map<String, List<String>> separate(List<String> strings) {
        List<String> numbers = new ArrayList<>();
        List<String> letters = new ArrayList<>();
        
        for (String str : strings) {
            if (str.matches("\\d+")) {
                numbers.add(str);
            } else if (str.matches("[a-zA-Z]+")) {
                letters.add(str);
            }
        }
        
        Map<String, List<String>> result = new HashMap<>();
        result.put("numbers", numbers);
        result.put("letters", letters);
        return result;
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("123", "abc", "456", "def", "789", "ghi");
        Map<String, List<String>> output = separate(input);
        System.out.println("数字列表: " + output.get("numbers")); // 输出: [123, 456, 789]
        System.out.println("字母列表: " + output.get("letters")); // 输出: [abc, def, ghi]
    }
}

思路：

• 遍历字符串列表，使用正则表达式 matches 方法来判断字符串是数字还是字母。
• 将对应的字符串添加到相应的列表中。
• 最终将两个列表放入一个映射中返回。

代码实现二：

import java.util.*;

public class SeparateNumbersAndLetters {
    public static Map<String, List<String>> separate(List<String> strings) {
        List<String> numbers = new ArrayList<>();
        List<String> letters = new ArrayList<>();
        
        for (String str : strings) {
            if (str.matches("\\d+")) {
                numbers.add(str);
            } else if (str.matches("[a-zA-Z]+")) {
                letters.add(str);
            }
        }
        
        Map<String, List<String>> result = new HashMap<>();
        result.put("numbers", numbers);
        result.put("letters", letters);
        return result;
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("123", "abc", "456", "def");
        Map<String, List<String>> output = separate(input);
        System.out.println("数字列表: " + output.get("numbers")); // 输出: [123, 456]
        System.out.println("字母列表: " + output.get("letters")); // 输出: [abc, def]
    }
}

思路：

• 遍历字符串列表，使用正则表达式 matches 方法来判断字符串是数字还是字母。
• 将对应的字符串添加到相应的列表中。

---

5. 计算学生的平均成绩

题目重述：给定一个映射，键是学生的名字，值是他们的成绩列表，返回一个新的映射，键是学生的名字，值是他们的平均成绩。

代码实现一：

import java.util.*;

public class AverageGrades {
    public static Map<String, Double> calculateAverages(Map<String, List<Integer>> grades) {
        Map<String, Double> averages = new HashMap<>();
        
        for (Map.Entry<String, List<Integer>> entry : grades.entrySet()) {
            String name = entry.getKey();
            List<Integer> scores = entry.getValue();
            double average = scores.stream().mapToInt(Integer::intValue).average().orElse(0.0);
            averages.put(name, average);
        }
        
        return averages;
    }

    public static void main(String[] args) {
        Map<String, List<Integer>> input = new HashMap<>();
        input.put("John", Arrays.asList(85, 90, 95));
        input.put("Bob", Arrays.asList(80, 85, 90));
        input.put("Alice", Arrays.asList(95, 100, 105));
        
        Map<String, Double> output = calculateAverages(input);
        System.out.println(output); // 输出: {John=90.0, Bob=85.0, Alice=100.0}
    }
}

思路：

• 遍历每个学生的成绩列表，使用流计算平均值。
• 将名字和对应的平均成绩存储在新的映射中。

代码实现二：

import java.util.*;

public class AverageGrades {
    public static Map<String, Double> calculateAverages(Map<String, List<Integer>> grades) {
        Map<String, Double> averages = new HashMap<>();
        
        for (Map.Entry<String, List<Integer>> entry : grades.entrySet()) {
            String name = entry.getKey();
            List<Integer> scores = entry.getValue();
            double total = 0;
            for (int score : scores) {
                total += score;
            }
            averages.put(name, total / scores.size());
        }
        
        return averages;
    }

    public static void main(String[] args) {
        Map<String, List<Integer>> input = new HashMap<>();
        input.put("John", Arrays.asList(85, 90, 95));
        input.put("Bob", Arrays.asList(80, 85, 90));
        input.put("Alice", Arrays.asList(95, 100, 105));
        
        Map<String, Double> output = calculateAverages(input);
        System.out.println(output); // 输出: {John=90.0, Bob=85.0, Alice=100.0}
    }
}

思路：

• 遍历每个学生的成绩列表，计算总分并求平均。
• 将名字和对应的平均成绩存储在新的映射中。

---

6. 将名字和电子邮件地址转换为映射

题目重述：给定一个字符串列表，每个字符串都是一个逗号分隔的名字和电子邮件地址，将这个列表转换为一个映射，其中键是电子邮件地址，值是对应的名字。

代码实现：

import java.util.*;

public class NameEmailMapping {
    public static Map<String, String> mapNamesToEmails(List<String> entries) {
        Map<String, String> emailMap = new HashMap<>();
        
        for (String entry : entries) {
            String[] parts = entry.split(",");
            if (parts.length == 2) {
                String name = parts[0].trim();
                String email = parts[1].trim();
                emailMap.put(email, name);
            }
        }
        
        return emailMap;
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("John Doe,john@doe.com", "Bob Smith,bob@smith.com", "Alice Johnson,alice@johnson.com");
        Map<String, String> output = mapNamesToEmails(input);
        System.out.println(output); // 输出: {john@doe.com=John Doe, bob@smith.com=Bob Smith, alice@johnson.com=Alice Johnson}
    }
}

思路：

• 遍历输入列表，使用 split 方法将每个字符串分为名字和电子邮件。
• 将电子邮件作为键，名字作为值存入映射中。

代码实现二：

import java.util.*;

public class NameEmailMapping {
    public static Map<String, String> mapNamesToEmails(List<String> entries) {
        Map<String, String> emailMap = new HashMap<>();
        
        for (String entry : entries) {
            String[] parts = entry.split(",");
            if (parts.length == 2) {
                emailMap.put(parts[1].trim(), parts[0].trim());
            }
        }
        
        return emailMap;
    }

    public static void main(String[] args) {
        List<String> input = Arrays.asList("John Doe,john@doe.com", "Bob Smith,bob@smith.com");
        Map<String, String> output = mapNamesToEmails(input);
        System.out.println(output); // 输出: {john@doe.com=John Doe, bob@smith.com=Bob Smith}
    }
}

思路：

• 遍历输入列表，使用 split 方法将每个字符串分为名字和电子邮件。
• 将电子邮件作为键，名字作为值存入映射中。

---