zoukankan      html  css  js  c++  java

  • python面试算法题

    1
    2
    3
    		 
    def num():
              return [lambda x: i*x for i in range(4)]
    print([m(2) for m in num()])     # 输出: [6, 6, 6, 6]

    思路：

    这题涉及到了闭包延时绑定，当循环执行完了之后才会执行传参，循环四次，每一次循环完 i=3 然后再和x相乘 所以结果是6，6，6，6。 如果把 [ lambda x: ix for i in range(4) ] 改成 （ lambda x: ix for i in range(4) ）这样就变成了一个生成器 自动实现迭代器协议，一边循环一边计算的机制， 这样结果就是 0，2，4，6.

    两数之和

    1
    2
    3
    		 
    给定 nums = [2, 7, 11, 15], target = 9
    因为 nums[0] + nums[1] = 2 + 7 = 9
    所以返回 [0, 1]

    思路：

    这里可以使用字典来解题，通过enumerate方法遍历获取数据的下标包括对应值，然后以key，value形式把该数据的下标和对应值存入字典，然后再出通过enumerate方法遍历数据，每一次获取数据就从字典拿出一个值，用目标值减去从字典拿出的这个值得到一个结果值，如果结果值存在字典当中，那么返回两个数的下标，如果为None，说明字典中没有这个值。

    实现代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    		 
    def get_index_list(nums, target):

        # Todo 作为一个方法来实现，批量解决这个获取索引的问题
        """
        :params nums：传的参数的列表
        :params target: 目标值
        :return: 返回索引
        """

        dic = {}

        for a, b in enumerate(nums):  # a是下标 b是对应值

            dic[b] = a  # 对应值存入字典

        for i, b in enumerate(nums):

            j = dic.get(target-b)  # 从字典中拿出对应值 用目标值减去对应值

            if j is not None:  # 判断如果减去的对应值不为空，则返回下标

                return [i, j]

    数组中重复的数字

    示例：

    1
    2
    3
    		 
    输入:
    [2,3,1,0,2,5,3]
    输出: 2 或 3

    思路：

    这道题想到的是，使用列表中的count方法，定义一个空列表，遍历数据然后进行判断，如果数据值出现个数大于或等于2，说明该数据是重复的，然后把重复的筛取出来之后存入空列表，再进行返回输出。

    实现代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    		 
    def get_number(nums):
        """
        :params nums：传的参数的数组
        :return: 返回重复数字
        """
        nub = []

        for i in nums:
            if nums.count(i) >= 2:
                if str(i) not in nub:
                    nub.append(str(i))

        print('或'.join(nub))


    if __name__ == "__main__":
        get_number([2, 3, 1, 0, 2, 5, 3])

    队列实现一个栈

    思路：

    使用一个队列，实现栈的一些基本操作，栈（后进先出）的特性。

    实现代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    		 
    # 队列实现一个栈 （栈：后进先出）
    class Stack(object):

        def __init__(self):
            # 定义一个队列
            self.lst = []

        def is_None(self):
            # 判断栈是否为空 返回 ture false
            return self.lst == []

        def push(self, i):
            # 加入元素
            self.lst.append(i)

        def pop(self):
            # 出栈
            return self.lst.pop()

        def stack_top(self):
            # 返回栈顶元素
            return self.lst[-1]

        def size(self):
            # 栈的大小
            return len(self.lst)


    if __name__ == "__main__":

        stack = Stack()
        print(stack.is_None())
        stack.push(1)
        stack.push(2)
        stack.push(3)
        print(stack.lst)
        print(stack.pop())
        print(stack.stack_top())
        print(stack.size())

    回文数

    判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

    示例1：

    1
    2
    		 
    输入: 121
    输出: true

    示例2：

    1
    2
    3
    		 
    输入: -121
    输出: false
    解释: 从左向右，为 -121 。 从右向左读，为121- 。 因此它不是一个回文数

    示例3：

    1
    2
    3
    		 
    输入: 10
    输出: false
    解释: 从右向左读，为 01 。 因此它不是一个回文数

    思路：

    这题可以使用字符串 双指针的方法 将数据转化为字符串 首先定义好第一个元素下标和最后一个元素下标，while循环 只要条件不满足 一直循环 循环判断第一个和最后一个元素是否相等 不相等返回false 相等继续循环，如果循环条件满足之后都相等，返回 false

    实现代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    		 
    def palindromic_number(x):

        """
        :params x：传的参数的列表
        :return: 返回Ture False
        """

        lst = list(str(x))
        print(lst)
        L, R = 0, len(lst)-1

        while L <= R:
            print(L, R)
            if lst[L] != lst[R]:
                return False

            L += 1
            R -= 1
        return True


    if __name__ == "__main__":
        print(palindromic_number(1231))

    分别用生成器和迭代器生成斐波那契数列

    示例：

    1
    		 
    输出: 1 1 2 3 5 8 13
    		 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    		 
    # 使用迭代器生成斐波那契数列
    class Fibonacii(object):
        def __init__(self,all_num):
            self.all_num = all_num
            self.cur_idx = 0
            self.a = 0  
            self.b = 1
        
        def __iter__(self):
            return self
        
        def __next__(self):
            if self.cur_idx >= self.all_num:
                raise StopIteration
            ret = self.a
            
            self.a, self.b = self.b, self.a + self.b
            self.cur_idx += 1
            return ret
     
    fibo = Fibonacii(10)
    for i in fibo:
        print(i)
    		 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    		 
    # 使用生成器生成斐波那契数列
    def fibnacii(count):
        num = 0
        a, b = 0, 1
        while num < count:
            yield a
            a, b = b, a+b
            num += 1


    fi = fibnacii(10)
    for i in fi:
        print(i)

    反转字符数组

    思路：

    直接使用反转

    实现代码：

    1
    2
    3
    4
    5
    6
    7
    8
    		 
    # 反转字符串
    def reverseString(s):
        s[0::] = s[::-1]
        print(s)


    if __name__ == "__main__":
        reverseString(['b', '', 'a', 'r'])
  • 相关阅读:
    TCP,IP,HTTP,SOCKET区别和联系
    添加Nginx为系统服务(设置开机启动)
    设计模式大全
    linux 命令行 光标移动技巧等
    Linux中ping命令
    TCP/IP协议 三次握手与四次挥手【转】
    Node 出现 uncaughtException 之后的优雅退出方案
    Google Protocol Buffers简介
    关于绝对路径和相对路径
    node定时任务——node-schedule模块使用说明
  • 原文地址：https://www.cnblogs.com/anle123/p/13365439.html
Copyright © 2011-2022 走看看