尊享面试100题

题目624:数组列表的最大距离(NO)

  • 解题思路:记录每个数组的最大最小值,循环判断最大距离。

给定 m 个数组,每个数组都已经按照升序排好序了。

现在你需要从两个不同的数组中选择两个整数(每个数组选一个)并且计算它们的距离。两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b| 。

返回最大距离。

cpp 复制代码
class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        //这题的做题思路其实就是遍历每个数组,记录数组的最大最小值

        //先记录第一组的最大最小值
        //.back()是获取最后一个值
        int max_value=arrays[0].back();
        int min_value=arrays[0][0];

        int max_Distance=0;

        //从第二个数组开始遍历
        //这里可以是可以进入for循环的,因为题目限制了
        //这里有个限制,最大最小值不能再同一个数组中
        for(int i=1;i<arrays.size();i++)
        {
            //当前数组的最大最小值
            int current_min=arrays[i][0];
            int current_max=arrays[i].back();

            max_Distance=max(max_Distance,abs(current_max-min_value));
            max_Distance=max(max_Distance,abs(current_min-max_value));

            //更新最大最小值
            max_value=max(current_max,max_value);
            min_value=min(current_min,min_value);

        }

        return max_Distance;


    }
};

题目280:摆动排序(YES)

  • 解题思路:这里有规律,排序后再指定位置插入。

给你一个的整数数组 nums, 将该数组重新排序后使 nums[0] <= nums[1] >= nums[2] <= nums[3]...

输入数组总是有一个有效的答案。

cpp 复制代码
class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        //我发现了其中的规律,他是排序后按位置插入的
        sort(nums.begin(),nums.end());
        vector<int>ans=nums;

        int size=ans.size();

        int count=0;
        for(int i=0;i<size;i++)
        {
            if(i%2==0)
            {
                //偶数的不用变
                nums[i]=ans[count];
            }else
            {
                //奇数要变
                nums[i]=ans[size-(count+1)];
                count++;
            }
            
        }


    }
};

题目1056:易混淆数(NO)

  • 解题思路:按照题目的思路,讲所有的数反转再进行比较。

给定一个数字 N,当它满足以下条件的时候返回 true:

原数字旋转 180° 以后可以得到新的数字。

如 0, 1, 6, 8, 9 旋转 180° 以后,得到了新的数字 0, 1, 9, 8, 6 。

2, 3, 4, 5, 7 旋转 180° 后,得到的不是数字。

易混淆数 (confusing number) 在旋转180°以后,可以得到和原来不同的数,且新数字的每一位都是有效的。

cpp 复制代码
class Solution {
public:
    bool confusingNumber(int n) {
        //这题的解题思路是按照题目的意思走,比较旋转反转后是否相同

        //用哈希表来表示旋转后的数
        unordered_map<char,char>map=
        {
            {'0','0'},
            {'1','1'},
            {'9','6'},
            {'8','8'},
            {'6','9'}
        };
        string ret=to_string(n);
        string ans="";//最终结果

        for(char c:ret)
        {
            if(map.find(c)==map.end())
            {
                //存在不能反转的返回false
                return false;
            }
            ans=map[c]+ans;//反转的数放在最前面
        }

        return ans!=ret;

        

    }

};

题目1427:字符串的左右移(YES)

  • 解题思路:根据题目的思路,模拟出来就行。

给定一个包含小写英文字母的字符串 s 以及一个矩阵 shift,其中 shift[i] = [direction, amount]:

direction 可以为 0 (表示左移)或 1 (表示右移)。

amount 表示 s 左右移的位数。

左移 1 位表示移除 s 的第一个字符,并将该字符插入到 s 的结尾。

类似地,右移 1 位表示移除 s 的最后一个字符,并将该字符插入到 s 的开头。

对这个字符串进行所有操作后,返回最终结果。

cpp 复制代码
class Solution {
public:
    string stringShift(string s, vector<vector<int>>& shift) {
        //这种最常规的方法就是根据题目的思路进行移动
        for(int i=0;i<shift.size();i++)
        {
            for(int j=0;j<shift[i][1];j++)
            {
                //移动的位数
                if(shift[i][0]==0)
                {
                    //左移
                    char c=s[0];
                    //从0位置开始删除1个
                    s.erase(0,1);
                    s=s+c;
                }else
                {
                    //右移
                    char c=s[s.size()-1];
                    s.erase(s.size()-1,1);
                    s=c+s;
                }
            }
        }

        return s;
    }
};

题目161:相隔为1的编辑距离(NO)

  • 解题思路:这题也是要迎合这题目的思路,首先就是要将情况分清楚,大于1的必然不行,后面就是对长度差等于0和等于1的情况进行单独的处理就行。方法其实是相似的。

给定两个字符串 s 和 t ,如果它们的编辑距离为 1 ,则返回 true ,否则返回 false 。

字符串 s 和字符串 t 之间满足编辑距离等于 1 有三种可能的情形:

往 s 中插入 恰好一个 字符得到 t

从 s 中删除 恰好一个 字符得到 t

在 s 中用 一个不同的字符 替换 恰好一个 字符得到 t

cpp 复制代码
class Solution {
public:
    bool isOneEditDistance(string s, string t) {

        //这题的难点在于你要将情况分析清楚
        //1.长度差大于1的必然是不行的
        //2.长度差等于1或者为0这是两种可能可以编辑的情况

        //这里全局默认s<t
        int len_s=s.size();
        int len_t=t.size();

        if(abs(len_s-len_t)>1)
        {
            return false;
        }

        //这里筛选下来的都是有可能的,先切换
        if(len_s>len_t)
        {
            swap(s,t);
            swap(len_s,len_t);
        }

        if(len_s==len_t)
        {
            //相等的情况
            bool check=false;
            for(int i=0;i<len_s;i++)
            {
                if(s[i]!=t[i])
                {
                    if(check)
                    {
                        //再次出现不相等就是错误的
                        return false;
                    }
                    //出现一个不相等
                    check=true;
                }
            }

            return check;
        }else
        {
            //差值为1的情况

            //其实和上面的非常相似,就是要找到一个不相等的
            int i=0;
            int j=0;
            for(;i<len_s&&j<len_t;)
            {
                if(s[i]==t[j])
                {
                    //都相等的情况
                    i++;
                    j++;
                }else
                {
                    //头一次找到不相等的
                    if(i==j)
                    {
                        //第一次不相等是允许的
                        j++;
                    }else
                    {
                        return false;
                    }
                }
            }

            return true;
        }

    }
};

题目186:反转字符串中的单词(NO)

  • 解题思路:先反转整体,再反转单个单词。

给你一个字符数组 s ,反转其中 单词 的顺序。

单词 的定义为:单词是一个由非空格字符组成的序列。s 中的单词将会由单个空格分隔。

必须设计并实现 原地 解法来解决此问题,即不分配额外的空间。

cpp 复制代码
class Solution {
public:
     void reverseWords(vector<char>& s) {  
        // 1. 反转整个字符数组  
        reverseRange(s, 0, s.size() - 1);  
        
        // 2. 逐个反转每个单词  
        int start = 0;  
        while (start < s.size()) {  
            int end = start;  
            // 找到单词的结束位置  
            while (end < s.size() && s[end] != ' ') {  
                end++;  
            }  
            // 反转当前单词  
            reverseRange(s, start, end - 1);  
            // 移动到下一个单词  
            start = end + 1;  
        }  
    }  
    
private:  
    void reverseRange(vector<char>& s, int start, int end) {  
        while (start < end) {  
            swap(s[start], s[end]);  
            start++;  
            end--;  
        }  
    } 
};
相关推荐
workflower2 小时前
单元测试-例子
java·开发语言·算法·django·个人开发·结对编程
MicroTech20254 小时前
微算法科技(MLGO)研发突破性低复杂度CFG算法,成功缓解边缘分裂学习中的掉队者问题
科技·学习·算法
墨染点香4 小时前
LeetCode 刷题【126. 单词接龙 II】
算法·leetcode·职场和发展
aloha_7895 小时前
力扣hot100做题整理91-100
数据结构·算法·leetcode
Tiny番茄5 小时前
31.下一个排列
数据结构·python·算法·leetcode
挂科是不可能出现的5 小时前
最长连续序列
数据结构·c++·算法
_Aaron___5 小时前
List.subList() 返回值为什么不能强转成 ArrayList
数据结构·windows·list
前端小L6 小时前
动态规划的“数学之魂”:从DP推演到质因数分解——巧解「只有两个键的键盘」
算法·动态规划
RTC老炮6 小时前
webrtc弱网-ReceiveSideCongestionController类源码分析及算法原理
网络·算法·webrtc
21号 16 小时前
9.Redis 集群(重在理解)
数据库·redis·算法