Paytm面试经历 | 18套（2年经验）

简介

Paytm是印度最大的数字支付公司之一，由One97通讯公司于2010年推出。Paytm提供了多种支付方式，包括电子钱包、UPI付款、银行转账等等。

面试经历

我有着2年的程序员工作经验，在Paytm面试时，我参加了18轮技术面试。这些面试主要是针对我的技术核心知识、项目经验、工作思维和解决问题的能力进行的。

以下是我在Paytm面试中遇到的问题和解决方案：

程序设计和数据结构

Paytm对程序员的编程和数据结构技能要求很高，因此他们在面试中经常问一些问题，以确保我们有足够的技术能力。

在其中一轮面试中，我被要求设计一个具有以下特性的数据结构：

• 快速插入
• 快速删除
• 快速查找中位数

我采用了平衡二叉树的方案，因为它提供了时间复杂度为O(log n)的平均查找、插入和删除；而且在它上面进行中位数查找也比较容易。

实现代码如下：

class AVLTree:
    class Node:
        def __init__(self, value):
            self.value = value
            self.left = None
            self.right = None
            self.height = 1

    def __init__(self):
        self.root = None
        self.size = 0

    def _height(self, node):
        return node.height if node else 0

    def _get_balance(self, node):
        return self._height(node.left) - self._height(node.right)

    def _left_rotate(self, node):
        r_child = node.right
        rl_child = r_child.left

        r_child.left = node
        node.right = rl_child

        node.height = max(self._height(node.left), self._height(node.right)) + 1
        r_child.height = max(self._height(r_child.left), self._height(r_child.right)) + 1

        return r_child

    def _right_rotate(self, node):
        l_child = node.left
        lr_child = l_child.right

        l_child.right = node
        node.left = lr_child

        node.height = max(self._height(node.left), self._height(node.right)) + 1
        l_child.height = max(self._height(l_child.left), self._height(l_child.right)) + 1

        return l_child

    def _insert(self, node, value):
        if not node:
            return self.Node(value)

        if value < node.value:
            node.left = self._insert(node.left, value)
        else:
            node.right = self._insert(node.right, value)

        node.height = max(self._height(node.left), self._height(node.right)) + 1

        balance = self._get_balance(node)

        if balance > 1 and value < node.left.value:
            return self._right_rotate(node)

        if balance < -1 and value > node.right.value:
            return self._left_rotate(node)

        if balance > 1 and value > node.left.value:
            node.left = self._left_rotate(node.left)
            return self._right_rotate(node)

        if balance < -1 and value < node.right.value:
            node.right = self._right_rotate(node.right)
            return self._left_rotate(node)

        return node

    def insert(self, value):
        self.root = self._insert(self.root, value)
        self.size += 1

    def _delete(self, node, value):
        if not node:
            return None

        if value < node.value:
            node.left = self._delete(node.left, value)
        elif value > node.value:
            node.right = self._delete(node.right, value)
        else:
            if not node.left and not node.right:
                node = None
            elif not node.left or not node.right:
                if node.left:
                    node = node.left
                else:
                    node = node.right
            else:
                min_node = node.right
                while min_node.left:
                    min_node = min_node.left
                node.value = min_node.value
                node.right = self._delete(node.right, min_node.value)

        if not node:
            return None

        node.height = max(self._height(node.left), self._height(node.right)) + 1

        balance = self._get_balance(node)

        if balance > 1 and self._get_balance(node.left) >= 0:
            return self._right_rotate(node)

        if balance < -1 and self._get_balance(node.right) <= 0:
            return self._left_rotate(node)

        if balance > 1 and self._get_balance(node.left) < 0:
            node.left = self._left_rotate(node.left)
            return self._right_rotate(node)

        if balance < -1 and self._get_balance(node.right) > 0:
            node.right = self._right_rotate(node.right)
            return self._left_rotate(node)

        return node

    def delete(self, value):
        self.root = self._delete(self.root, value)
        self.size -= 1

    def _get_median_node(self, node):
        if not node:
            return None

        n = (self.size - 1) // 2

        if n < self._size(node.left):
            return self._get_median_node(node.left)
        elif n > self._size(node.left):
            return self._get_median_node(node.right)
        else:
            return node

    def get_median(self):
        node = self._get_median_node(self.root)
        return node.value if node else None

代码复杂度和性能

在另一轮的面试中，我被问及如何调试一段不好的代码并提出提高它的性能的建议。我可以说我是代码复杂度和性能优化的忠实拥护者，因此我尽可能地详细回答了问题。

我的建议如下：

• 按照小块的方式调试代码，确保每一个小块的代码都能正常运行。
• 对代码进行基准测试，评估程序存在因素。
• 根据评估结果对代码进行优化，减少程序的复杂度，并尽可能地减少循环的使用。
• 避免使用全局变量，因为全局变量会增加代码的复杂度以及代码的可读性。
• 使用缓存或memoization技术提高程序的性能。
• 避免使用Recursive算法，使用迭代算法代替。

面向对象编程

在Paytm技术面试中，我还受到了一些关于面向对象编程的问题。在其中一轮面试中，我被要求说说继承和接口之间的区别。

我的回答如下：

• 继承是一种类与类之间的关系，子类会继承父类的属性和方法，并且能够重写父类的方法。
• 接口是一组规范，它只定义了属性和方法，并没有具体实现，接口可以用来描述类的行为和特征，任何实现该规范的类都可以被实例化和调用接口的方法。

另外，Paytm的面试官还会经常询问我们在项目中如何使用面向对象编程。我的一些建议如下：

• 使用面向对象编程的思想来划分模块和组成部分，它们之间应该有清晰的接口和依赖关系。
• 使用接口来定义模块的公共行为和方法。
• 使用leaner的结构，并避免类中重复的代码。
• 使用多态性来代替复杂的逻辑和条件语句，并使代码更加简单和可读。

总结

Paytm的面试过程是相当严格和具有挑战性的，但我认为这些经验对于我的技术发展和成长都是很有益的。在面试过程中，我发现他们对于面试者的技术信仰和工作思维能力尤为重视，这些对于开发高质量的代码、创建高性能的系统和维护长期稳定的系统都是至关重要的。

如果你也想在Paytm工作，并参加他们的面试，请为自己做好充分准备。我希望我的经验可以为你提供一些有用的启示，并帮助你成功地通过面试过程。