程序员面试金典16.*

最新推荐文章于 2024-10-20 17:51:39 发布

xxx量化研究方法

最新推荐文章于 2024-10-20 17:51:39 发布

阅读量797

点赞数

文章标签：面试算法职场和发展

本文链接：https://blog.csdn.net/pH2002/article/details/130551254

版权

16.01 交换数字

在这里插入图片描述
方式一：在原有的基础修改 a = a + b; b = a - b; a = a - b;

方式二：异或 a = a ^ b; b = a ^ b; a = a ^ b;

16.02单词频率

一个HashMap就行

16.03交点

数学题，太恶心了，算了。

16.04 井字游戏

在这里插入图片描述
这个题就直接模拟就好。
这个题判断赢用的是(int)‘X’ * length,不过可能会出小问题，用0和1应该会好一点,不过此时还要考虑当遇到" " 的时候返回什么。

class Solution {
    public String tictactoe(String[] board) {

        int length = board.length;
        int heng = 0; //横的和
        int zong = 0; //纵的和
        int left = 0; //左斜线
        int right = 0; //右斜线
        boolean flag = false; //记录有没有空格

        for (int i = 0; i < length; i++) {

            heng = 0; zong = 0;

            for (int j = 0; j < length; j++) {

                heng = heng +  (int) board[i].charAt(j);
                
                zong = zong + (int) board[j].charAt(i);

                if(board[i].charAt(j) == ' ') flag = true;

            }

            //横纵检查
            if (heng == (int)'X' * length || zong == (int)'X' * length) return "X";
            
            if (heng == (int)'O' * length || zong == (int)'O' * length) return "O";

            //两条斜线上的相加
            left = left + (int)board[i].charAt(i);
            right = right + (int)board[i].charAt(length - i - 1);

        }

        //两条斜线检查
        if (left == (int)'X' * length || right == (int)'X' * length) return "X";
        if (left == (int)'O' * length || right == (int)'O' * length) return "O";

        if (flag) return "Pending";
        return "Draw";

    }
}

16.05 阶乘尾数

在这里插入图片描述
0 是由 *10 得到的，而 10 是由 2 * 5 得到的
因此我们求 n！过程中存在多少个 2 * 5
因为 2 的个数必定比 5 的个数多，因此我们只求 5 的个数
n! = 1 * 2 * 3 * 4 * (1 * 5) * … * (2 * 5) * … * (3 * 5) …
当然因为存在25和125这类数，所以
count = n / 5 + n / 25 + n / 125 + …
因此可以转换为一个循环 n=n/5; count+=n;

16.06 最小差

排序，然后双指针。

16.07 最大数值

了解一下位运算，移位操作。比较一下符号位即可

16.08 整数的英文表示

没啥意思

16.09 运算

挺无语的，不用做。

16.10 生存人数

在这里插入图片描述
差分数组的思想
birth那里+1， death的下一位 -1
再对差分数组求和，求最大值即可

16.11 跳水板

太简单了，pass

16.13 平分正方形

在这里插入图片描述
求过两个正方形中心的直线即可，如果两者中心重合，取垂直于x轴的直线。再根据斜率判断与正方形哪条边相交。题目简化了很多，模拟就好。

16.14 最佳直线（待定）

对于特定的一组直线AX+BY+C=0,去求最大

16.15珠玑妙算

用一个哈希表就行

16.16部分排序

在这里插入图片描述

你可以直接排序，然后原数组与排序数组比较。也可以用下面的思路遍历一遍。

首先虽然题目没说，但是实际运行下来数列是单调递增的，所以我们下面默认数列是递增的。

那么对于元素 a[i] 来说，如果它左边存在大于 a[i] 的元素，那么 a[i] 是一定要参与到排序里去的。或者说如果它右边存在小于 a[i] 的元素，那么 a[i] 也是要参与到排序里去的。

所以我们只需要寻找最靠右的那个数（满足左边存在大于它的数），和最靠左的那个数（满足右边存在小于它的数），那么这两个数之间就是要排序的区间了。

为什么最靠右的那个（满足左边存在大于它的数）数一定能保证右边没有更小的数了呢？因为如果右边还有更小的数，那么那个更小的数才是更靠右的啊，这就矛盾了。

所以我们只需要从左到右扫描一遍，用一个变量维护一下最大值就行了，然后反向再遍历一遍，维护一个最小值。

class Solution {
    public int[] subSort(int[] array) {
        int size1=array.length;
        int minValue=Integer.MAX_VALUE;
        int maxValue=Integer.MIN_VALUE;
        int left=-1,right=-1;
        for(int i=0;i<size1;i++){
            if(maxValue<=array[i]) maxValue=array[i];
            else right=i;
        }
        if(right==-1) return new int[]{-1,-1};
        for(int i=size1-1;i>-1;i--){
            if(minValue>=array[i]) minValue=array[i];
            else left=i;
        }
        return new int[]{left,right};

    }
}

16.17连续数列

在这里插入图片描述

注意是先赋值给maxValue,再ans=0；主打一个贪心。

class Solution {
    public int maxSubArray(int[] nums) {
        int size1=nums.length;
        int ans=0;
        int maxValue=Integer.MIN_VALUE;
        for(int i=0;i<size1;i++){
            ans+=nums[i];
            if(ans>maxValue) maxValue=ans;
            if(ans<0) ans=0;    
        }
        return maxValue;

    }
}

16.18 模式匹配

这种题用python写好一点，别的语言好麻烦。

16.19水域大小

经典DFS
在这里插入图片描述

class Solution {
    public int[] pondSizes(int[][] land) {
        int aLength=land.length;
        int bLength=land[0].length;
        int count=0;
        ArrayList<Integer> array=new ArrayList<>();

        for(int i=0;i<aLength;i++){
            for(int j=0;j<bLength;j++){
                count=dfs(land,i,j);
                if(count!=0) array.add(count);
            }
        }

        int[] ans=new int[array.size()];
        for(int i=0;i<array.size();i++) ans[i]=array.get(i);
        Arrays.sort(ans);
        return ans;

    }

    public int dfs(int[][]land, int i, int j){
        if(i<0 || i>=land.length || j<0 || j>=land[0].length || land[i][j]!=0) return 0;
        land[i][j]=-1;
        int count=1;
        count+=dfs(land,i-1,j);
        count+=dfs(land,i-1,j-1);
        count+=dfs(land,i-1,j+1);
        count+=dfs(land,i,j-1);
        count+=dfs(land,i,j+1);
        count+=dfs(land,i+1,j-1);
        count+=dfs(land,i+1,j);
        count+=dfs(land,i+1,j+1);
        return count;

    }
}

16.20 T9键盘

用一个大数组先记录一下就行

16.21 交换和

排序后双指针就行

16.22 兰顿蚂蚁（未做）

题目读起来好费劲，不过应该就是一个模拟题

16.24 数对和

排序后双指针，或者用哈希表也行

16.25 LRU缓存

解决方案：链表（处理新老关系），哈希表（查询元素有没有）
用LinkedHashMap或者双向链表+哈希表
别人的博客
主要是实现一和实现三

16.26 计算器

在这里插入图片描述
用栈来模拟

class Solution {
    public int calculate(String s) {
        Deque<Integer> stack=new ArrayDeque<Integer>();
        char preSign = '+';
        int num = 0;
        int n = s.length();
        for(int i=0;i<n;i++){
            if(Character.isDigit(s.charAt(i))){
                num=num*10+s.charAt(i)-'0';
            }
            if((!Character.isDigit(s.charAt(i)) && s.charAt(i)!=' ')  || i==n-1){
                switch(preSign){
                    case '+':
                        stack.push(num);
                        break;
                    case '-':
                        stack.push(-num);
                        break;
                    case '*':
                        preSign = '*';
                        stack.push(num*stack.pop());
                        break;
                    case '/':
                        preSign = '/';
                        stack.push(stack.pop()/num);
                }
                num=0;
                preSign=s.charAt(i);

            }
        }
        int ans=0;
        while(!stack.isEmpty()){
            ans+=stack.pop();
        }
        return ans;

    }
}