面试算法题(shell/日志数据查询统计)

1，写一个shell脚本，实现mysql日志关键字查询，日志基于时间存放在不同的压缩包中

#!/bin/bash

# 设置 MySQL 日志文件夹路径
log_folder="/path/to/mysql/logs"

# 设置关键字
keyword="your_keyword_here"

# 遍历日志文件夹下的所有压缩包
for logfile in "$log_folder"/*.gz; do
    # 解压缩日志文件
    gunzip -c "$logfile" > /tmp/unzipped_log.log

    # 在解压后的文件中查找关键字
    if grep -q "$keyword" /tmp/unzipped_log.log; then
        echo "关键字 '$keyword' 在文件 '$logfile' 中找到。"
        # 可以在此处添加更多处理逻辑，例如将匹配的行写入输出文件等
    fi

    # 删除临时解压文件
    rm /tmp/unzipped_log.log
done

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2, 从9亿个数中找出中位数

import java.util.PriorityQueue;

public class FindMedian {

    public static double findMedian(int[] nums) {
        // 创建两个优先队列，一个最大堆和一个最小堆
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();

        for (int num : nums) {
            // 将元素插入最大堆，然后将最大堆中最大的元素移动到最小堆
            maxHeap.offer(num);
            minHeap.offer(maxHeap.poll());

            // 如果最小堆的大小超过最大堆，将最小堆中最小的元素移动到最大堆
            if (minHeap.size() > maxHeap.size()) {
                maxHeap.offer(minHeap.poll());
            }
        }

        // 如果数据量为奇数，中位数在最大堆的根元素
        if (maxHeap.size() > minHeap.size()) {
            return maxHeap.peek();
        } else { // 如果数据量为偶数，中位数为两个堆顶元素的平均值
            return (maxHeap.peek() + minHeap.peek()) / 2.0;
        }
    }

    public static void main(String[] args) {
        int[] nums = {3, 1, 4, 2, 5, 7, 6, 8};
        double median = findMedian(nums);
        System.out.println("中位数为: " + median);
    }
}

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

3,有10个文件，每个文件1G，每个文件的每一行都是用户的query，每个文件的query都可能重复，要求你按照query的频度排序。

import java.io.*;
import java.util.*;

public class QueryFrequencySorter {
    public static void main(String[] args) throws IOException {
        // 用于存储查询(query)及其频度的映射
        Map<String, Integer> queryFrequencyMap = new HashMap<>();

        // 读取所有文件
        for (int i = 1; i <= 10; i++) {
            String fileName = "file" + i + ".txt";
            BufferedReader reader = new BufferedReader(new FileReader(fileName));
            String line;
            
            while ((line = reader.readLine()) != null) {
                // 分割查询(query)，这里假设查询以空格分隔
                String[] queries = line.split(" ");
                
                // 遍历并更新查询(query)的频度
                for (String query : queries) {
                    queryFrequencyMap.put(query, queryFrequencyMap.getOrDefault(query, 0) + 1);
                }
            }
            
            reader.close();
        }

        // 将查询(query)按照频度降序排序
        List<Map.Entry<String, Integer>> sortedQueries = new ArrayList<>(queryFrequencyMap.entrySet());
        sortedQueries.sort((e1, e2) -> e2.getValue().compareTo(e1.getValue()));

        // 打印排序后的查询(query)
        for (Map.Entry<String, Integer> entry : sortedQueries) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

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