没通知就降公积金的脉脉，面试考什么？

2023-12-23 11:20
文章标签 面试 通知 公积金 脉脉

本文主要是介绍没通知就降公积金的脉脉，面试考什么？，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

写在前面

刚过去的周末，又一家神奇公司映入眼帘：

alt

怎么说呢？自家的瓜出现在自家，至少说明脉脉没有跟微博似的限流。

自家做职场社交，就用自家帖子做全员通知，脉脉你就这么“降本”的吗？🤣

我再找了一下它们的 slogan：

alt

啊？是 ... 是这个意思吗？

作为一个每天都要想更新什么的勤劳型博主，怎能只吃瓜？

我马上去翻看了脉脉的题库，于是有了这篇推文

题目描述

平台：LeetCode

题号：61

给你一个链表的头节点 head，旋转链表，将链表每个节点向右移动 k 个位置。

示例 1： alt

输入：head = [1,2,3,4,5], k = 2

输出：[4,5,1,2,3]

示例 2： alt

输入：head = [0,1,2], k = 4

输出：[2,0,1]

提示：

  • 链表中节点的数目在范围 内

快慢指针

本质还是道模拟题，分步骤处理即可：

  • 避免不必要的旋转：与链表长度成整数倍的「旋转」都是没有意义的（旋转前后链表不变）
  • 使用「快慢指针」找到倒数第 k 个节点（新头结点），然后完成基本的链接与断开与断开操作

Java 代码：

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0) return head;
        // 计算有效的 k 值：对于与链表长度成整数倍的「旋转」都是没有意义的（旋转前后链表不变）
        int tot = 0;
        ListNode tmp = head;
        while (tmp != null && ++tot > 0) tmp = tmp.next;
        k %= tot;
        if (k == 0) return head;
        // 使用「快慢指针」找到倒数第 k 个节点（新头结点）：slow 会停在「新头结点」的「前一位」，也就是「新尾结点」
        ListNode slow = head, fast = head;
        while (k-- > 0) fast = fast.next;
        while (fast.next != null) {
            slow = slow.next;
            fast = fast.next;
        }
        // 保存新头结点，并将新尾结点的 next 指针置空
        ListNode nHead = slow.next;
        slow.next = null;
        // 将新链表的前半部分（原链表的后半部分）与原链表的头结点链接上
        fast.next = head;
        return nHead;
    }
}

C++ 代码：

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (head == NULL || k == 0) return head;
        // 计算有效的 k 值：对于与链表长度成整数倍的「旋转」都是没有意义的（旋转前后链表不变）
        int tot = 0;
        ListNode* tmp = head;
        while (tmp != NULL && ++tot > 0) tmp = tmp->next;
        k %= tot;
        // 使用「快慢指针」找到倒数第 k 个节点（新头结点）：slow 会停在「新头结点」的「前一位」，也就是「新尾结点」
        if (k == 0) return head;
        // 使用快慢指针找到倒数第 k 个节点
        ListNode* slow = head;
        ListNode* fast = head;
        while (k-- > 0) fast = fast->next;
        while (fast->next != NULL) {
            slow = slow->next;
            fast = fast->next;
        }
        // 保存新头结点，并将新尾结点的 next 指针置空
        ListNode* nHead = slow->next;
        slow->next = NULL;
        // 将新链表的前半部分（原链表的后半部分）与原链表的头结点链接上
        fast->next = head;
        return nHead;
    }
};

Python 代码：

class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        if not head or k == 0: return head
        # 计算有效的 k 值：对于与链表长度成整数倍的「旋转」都是没有意义的（旋转前后链表不变）
        tot, tmp = 0, head
        while tmp:
            tmp = tmp.next
            tot += 1
        k %= tot
        # 使用「快慢指针」找到倒数第 k 个节点（新头结点）：slow 会停在「新头结点」的「前一位」，也就是「新尾结点」
        if k == 0: return head
        # 使用快慢指针找到倒数第 k 个节点
        slow, fast = head, head
        while k > 0:
            fast = fast.next
            k -= 1
        while fast.next:
            slow = slow.next
            fast = fast.next
        # 保存新头结点，并将新尾结点的 next 指针置空
        nHead = slow.next
        slow.next = None
        # 将新链表的前半部分（原链表的后半部分）与原链表的头结点链接上
        fast.next = head
        return nHead

TypeScript 代码：

function rotateRight(head: ListNode | null, k: number): ListNode | null {
    if (head == null || k == 0) return head;
    // 计算有效的 k 值：对于与链表长度成整数倍的「旋转」都是没有意义的（旋转前后链表不变）
    let tot = 0, tmp = head;
    while (tmp !== null && ++tot > 0) tmp = tmp.next;
    k %= tot;
    // 使用「快慢指针」找到倒数第 k 个节点（新头结点）：slow 会停在「新头结点」的「前一位」，也就是「新尾结点」
    if (k == 0) return head;
    // 使用快慢指针找到倒数第 k 个节点
    let slow = head, fast = head;
    while (k-- > 0) fast = fast.next;
    while (fast.next !== null) {
        slow = slow.next;
        fast = fast.next;
    }
    // 保存新头结点，并将新尾结点的 next 指针置空
    let nHead = slow.next;
    slow.next = null;
    // 将新链表的前半部分（原链表的后半部分）与原链表的头结点链接上
    fast.next = head;
    return nHead;
};
  • 时间复杂度：
  • 空间复杂度：

闭合成环

另外一个做法是，先成环，再断开：

  • 找到原链表的最后一个节点，将其与原链表的头结点相连（成环），并统计链表长度，更新有效 k 值
  • 从原链表的头节点出发，找到需要断开的点，进行断开

Java 代码：

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0) return head;
        // 先将链表成环，并记录链表的长度
        // tmp 会记录住原链表最后一位节点
        int tot = 1;
        ListNode tmp = head;
        while (tmp.next != null && ++tot > 0) tmp = tmp.next;
        k %= tot;
        if (k == 0) return head;
        // 正式成环
        tmp.next = head;
        // 从原链表 head 出发，走 tot - k - 1 步，找到「新尾结点」进行断开，并将其下一个节点作为新节点返回
        k = tot - k - 1;
        while (k-- > 0) head = head.next;
        ListNode nHead = head.next;
        head.next = null;
        return nHead;
    }
}

C++ 代码：

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (head == NULL || k == 0) return head;
        // 先将链表成环，并记录链表的长度
        // tmp 会记录住原链表最后一位节点
        int tot = 1;
        ListNode* tmp = head;
        while (tmp->next != NULL && ++tot > 0) tmp = tmp->next;
        k %= tot;
        if (k == 0) return head;
        // 正式成环
        tmp->next = head;
        // 从原链表 head 出发，走 tot - k - 1 步，找到「新尾结点」进行断开，并将其下一个节点作为新节点返回
        k = tot - k - 1;
        while (k-- > 0) head = head->next;
        ListNode* nHead = head->next;
        head->next = NULL;
        return nHead;
    }
};

Python 代码：

class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        if not head or k == 0: return head
        # 先将链表成环，并记录链表的长度
        # tmp 会记录住原链表最后一位节点
        tot, tmp = 1, head
        while tmp.next:
            tmp = tmp.next
            tot += 1
        k %= tot
        if k == 0: return head
        # 正式成环
        tmp.next = head
        # 从原链表 head 出发，走 tot - k - 1 步，找到「新尾结点」进行断开，并将其下一个节点作为新节点返回
        k = tot - k - 1
        while k > 0:
            head = head.next
            k -= 1
        nHead = head.next
        head.next = None
        return nHead

TypeScript 代码：

function rotateRight(head: ListNode | null, k: number): ListNode | null {
    if (head == null || k == 0) return head;
    // 先将链表成环，并记录链表的长度
    // tmp 会记录住原链表最后一位节点
    let tot = 1, tmp = head;
    while (tmp.next !== null && ++tot > 0) tmp = tmp.next;
    k %= tot;
    if (k == 0) return head;
    // 正式成环
    tmp.next = head;
    k = tot - k - 1;
    while (k-- > 0) head = head.next;
    let nHead = head.next;
    head.next = null;
    return nHead;
};
  • 时间复杂度：
  • 空间复杂度：

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉

这篇关于没通知就降公积金的脉脉，面试考什么？的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/527852。

相关文章

字节面试 | 如何测试RocketMQ、RocketMQ？

字节面试 | 如何测试RocketMQ、RocketMQ？

字节面试：RocketMQ是怎么测试的呢？ 答： 首先保证消息的消费正确、设计逆向用例，在验证消息内容为空等情况时的消费正确性； 推送大批量MQ，通过Admin控制台查看MQ消费的情况，是否出现消费假死、TPS是否正常等等问题。（上述都是临场发挥，但是RocketMQ真正的测试点，还真的需要探讨） 01 先了解RocketMQ 作为测试也是要简单了解RocketMQ。简单来说，就是一个分
阅读更多...
秋招最新大模型算法面试，熬夜都要肝完它

秋招最新大模型算法面试，熬夜都要肝完它

💥大家在面试大模型LLM这个板块的时候，不知道面试完会不会复盘、总结，做笔记的习惯，这份大模型算法岗面试八股笔记也帮助不少人拿到过offer ✨对于面试大模型算法工程师会有一定的帮助，都附有完整答案，熬夜也要看完，祝大家一臂之力 这份《大模型算法工程师面试题》已经上传CSDN，还有完整版的大模型 AI 学习资料，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费
阅读更多...
java面试常见问题之Hibernate总结

java面试常见问题之Hibernate总结

1  Hibernate的检索方式 Ø  导航对象图检索（根据已经加载的对象，导航到其他对象。） Ø  OID检索（按照对象的OID来检索对象。） Ø  HQL检索（使用面向对象的HQL查询语言。） Ø  QBC检索（使用QBC(Qurey By Criteria)API来检索对象。 QBC/QBE离线/在线） Ø  本地SQL检索（使用本地数据库的SQL查询语句。） 包括Hibern
阅读更多...
贝壳面试：什么是回表？什么是索引下推？

贝壳面试：什么是回表？什么是索引下推？

尼恩说在前面 在40岁老架构师 尼恩的读者交流群(50+)中，最近有小伙伴拿到了一线互联网企业如得物、阿里、滴滴、极兔、有赞、希音、百度、网易、美团的面试资格，遇到很多很重要的面试题： 1.谈谈你对MySQL 索引下推 的认识？ 2.在MySQL中，索引下推 是如何实现的？请简述其工作原理。 3、说说什么是 回表，什么是 索引下推 ？ 最近有小伙伴在面试 贝壳、soul，又遇到了相关的
阅读更多...
毕业前第二次面试的感慨

毕业前第二次面试的感慨

距面试已经过去了有几天了，我现在想起来都有说多的恨感慨。 我一直都是想找刚刚起步的企业，因为这能让我学到更多的东西，然而正好有一家企业是刚起步的，而且他还有自己的产品专利，可以说这是一家，即是创业又是刚起步的公司，这家公司回复了我投给他的简历，这家企业想进一步了解我的情况，因为简历上我符合这家企业的基本要求，所以要进一步了解。 虽然面试的过程中，他给我的面试题，我做得并不是很理想，
阅读更多...
腾讯社招面试经历

腾讯社招面试经历

前提：本人2011年毕业于一个普通本科，工作不到2年。 　　15号晚上7点多，正在炒菜做饭，腾讯忽然打电话来问我对他们的Linux C++的职位是否感兴趣，我表达了我感兴趣之后，就开始了一段简短的电话面试，电话面试主要内容：C++和TCP socket通信的一些基础知识。之后就问我一道算法题：10亿个整数，随机生成，可重复，求最大的前1万个。当时我一下子就蒙了，没反应过来，何况我还正在烧
阅读更多...
完整的腾讯面试经过

完整的腾讯面试经过

从9月10号开始到现在快两个月了，两个多月中，我经历数次面试和笔试，在经历这些的同时积累了不少的经验，也学到了不少东西，在此把它记录下来，算是和一起找工作中的同学一起共勉吧。我是本校的学生，专业是机械制造及其自动化，找工作的主要目标是计算机软件类和机械制造方向的国内的企业，所以意向去外企的同学就不必浪费时间看这些面经啦，想去国内IT企业的同学可以继续看下去。本贴中我把最近的腾讯面试经过写下
阅读更多...
仕考网：结构化面试流程介绍

仕考网：结构化面试流程介绍

(一)结构化面试 结构化面试，也叫做标准化面试，考官按照预先设定好的一套试题以问答方式与应试者当面交谈，根据应试者的言语、行为表现，对其相关能力和个性特征作出相应评价。 （二）考试流程 抵达考场——审核抽签——面试候考——进入考场——面试答题——考生退场——计分审核 （三）答题技巧 1.声音洪亮，音量可以比平时说话声音大一点。 2.语速不要过快，语速快容易卡顿，而且不便于考官听清答
阅读更多...
嵌入式面试经典30问：二

嵌入式面试经典30问：二

1. 嵌入式系统中，如何选择合适的微控制器或微处理器？ 在嵌入式系统中选择合适的微控制器（MCU）或微处理器（MPU）时，需要考虑多个因素以确保所选组件能够满足项目的具体需求。以下是一些关键步骤和考虑因素： 1.1 确定项目需求 性能要求：根据项目的复杂度、处理速度和数据吞吐量等要求，确定所需的处理器性能。功耗：评估系统的功耗需求，选择低功耗的MCU或MPU以延长电池寿命或减少能源消耗。成本
阅读更多...
Leetcode面试经典150题-128.最长连续序列-递归版本另解

Leetcode面试经典150题-128.最长连续序列-递归版本另解

之前写过一篇这个题的，但是可能代码比较复杂，这回来个简洁版的，这个是递归版本 可以看看之前的版本，两个版本面试用哪个都保过 解法都在代码里，不懂就留言或者私信 class Solution {/**对于之前的解法，我现在提供一共更优的解，但是这种可能会比较难懂一些（思想方面）代码其实是很简洁的，总体思想如下：不需要排序直接把所有数放入map，map的key是当前数字，value是当前数开始的
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2