大家好，我是白露啊。

昨天端午在刷帖子的时候，看到一个让人哭笑不得的吐槽，忍不住要和大家分享一下。帖子的标题是：“阎王爷背上是不是纹的拼多多”，接着是一段满满都是血泪的控诉。

6.8 阎王爷背上是不是纹的拼多多？ - 图1

这哪里是工作，简直像是进“十八层地狱”。不仅工时长得吓人，每一分钟都被盯着，连喝水上厕所都成问题，忍不住感叹周扒皮遇到这种公司也会喊“祖师爷”！

这位小伙伴很显然是被拼多多的所谓“高薪”吸引进来的，但没想到进去后发现根本没时间花钱，简直后悔得肠子都青了。当时没有来得及等其他公司的offer，这位同学有点后悔了。

但是，可能去了其他公司，说不准又回后悔没有选工资更高的拼多多··？哎

最让人绝望的是，签了竞业协议，现在因为这个“约束”，想走也走不了，只能在这个“地狱”里继续煎熬。每想到此，真是让人无力又无奈，简直是在折磨员工的身心。

看了这位同学的故事，白露不得不说，当前的职场环境和激烈的竞争压力确实很大，不仅要拼命工作，还要应对各种限制和不合理的条款。

希望这位网友，以及所有在职场上苦苦挣扎的朋友们，能够找到一种方法让自己保持健康和心理平衡。毕竟健康和生活质量是无价的。

各位小伙伴们，有没有类似的职场经历或者被公司的各种“条条框框”搞得崩溃的经历？欢迎在评论区留言分享。好了，今天才上班我们就来看一篇轻松的算法题，如果不想看，可以直接跳转到文末，有惊喜哦～

开始面试

6.8 阎王爷背上是不是纹的拼多多？ - 图2

解题思路：

  1. 创建一个新的链表来存储结果，以及一个节点指针用于追踪当前操作的节点。
  2. 遍历两个输入的链表，直到两个链表都到达末尾。
  3. 在遍历的过程中，将两个链表当前节点的值相加，如果上一步有进位，也加上进位的值。
  4. 计算总和后，将总和的个位数作为新节点添加到结果链表的末尾，并计算是否有进位（即总和是否大于等于10）。
  5. 如果两个链表的长度不一致，继续遍历较长的链表，重复步骤3和4。
  6. 遍历完两个链表后，如果还有进位，将进位作为新节点添加到结果链表的末尾。
  7. 返回结果链表的头节点。

Java实现：

  1. class Solution {
  2.     public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
  3.         ListNode dummy = new ListNode(0);
  4.         ListNode curr = dummy;
  5.         int carry = 0;
  6.         while (l1 != null || l2 != null) {
  7.             int x = (l1 != null) ? l1.val : 0;
  8.             int y = (l2 != null) ? l2.val : 0;
  9.             int sum = carry + x + y;
  10.             carry = sum / 10;
  11.             curr.next = new ListNode(sum % 10);
  12.             curr = curr.next;
  13.             if (l1 != null) l1 = l1.next;
  14.             if (l2 != null) l2 = l2.next;
  15.         }
  16.         if (carry > 0) {
  17.             curr.next = new ListNode(carry);
  18.         }
  19.         return dummy.next;
  20.     }
  21. }

Go实现：

  1. type ListNode struct {
  2.     Val  int
  3.     Next *ListNode
  4. }
  6. func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
  7.     dummy := &ListNode{0, nil}
  8.     curr := dummy
  9.     carry := 0
  10.     for l1 != nil || l2 != nil {
  11.         x, y := 0, 0
  12.         if l1 != nil {
  13.             x = l1.Val
  14.             l1 = l1.Next
  15.         }
  16.         if l2 != nil {
  17.             y = l2.Val
  18.             l2 = l2.Next
  19.         }
  20.         sum := carry + x + y
  21.         carry = sum / 10
  22.         curr.Next = &ListNode{sum % 10, nil}
  23.         curr = curr.Next
  24.     }
  25.     if carry != 0 {
  26.         curr.Next = &ListNode{carry, nil}
  27.     }
  28.     return dummy.Next
  29. }

这两种实现避免了在输入链表末尾添加额外的零节点，而是直接在遍历过程中处理了长度不一致的情况，这样代码更加简洁易懂，同时也减少了不必要的操作。

咋样，你会了吗？