weixin_39257042的博客

def Diffie_Hellman_exchange_algorithm(p,g, SA_assign,SB_assign): print(f"p = {p}, g = {g}") SA = SA_assign SB = SB_assign print(f"Let SA = {SA}, SB = {SB}") TA = g**SA % p TB = g**SB % p print(f"TA = g^SA mod p = {TA} = {g}^{SA}

def calculate(p,q,m): print(f"1: p: {p} q: {q} M: {m}") n = p*q print(f"2: n = p*q {p} *{q} = {n}") temp = (p-1)*(q-1) print(f"3: (p-1)*(q-1) = {p-1} *{q-1} = {temp}") e = 1 print(f"4:e should be less than n and relatively pri.

需求构建链表，并完成一下功能：设置链表的头（head）和尾部（tail），也就是将其中的某个元素直接变成头和尾在一个节点的特定位置（前/后）插入一个node，或者在一个特定的位置插入节点，假设head节点的位置为1移除具有特定值的node搜索具有特定值的nodeSolution# 节点包括本身的值和前后关系class Node: def __init__(self, value): self.value = value self.prev = No

定义一种河流大小的方式，在一个二维数中，如下所示：样例输入[ [1, 0, 0, 1, 0], [1, 0, 1, 0, 0], [0, 0, 1, 0, 1], [1, 0, 1, 0, 1], [1, 0, 1, 1, 0]]1代表河流，0代表陆地。相邻的一团1代表一个河流，这里的相邻不包括对角线相邻。写一个函数，输入是这样的一张地图，返回一个array，里面代表了所有河流的size样例输出：[2, 1, 5, 2, 2]Solutiontest_case

输入一个二维数组，并对这个数组进行螺旋遍历样例输入test_case = [ [1, 2, 3, 4], [12, 13, 14, 5], [11, 16, 15, 6], [10, 9, 8, 7]]样例输出[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]Solution考虑边界条件直观上直接按照从左到右，从上到下在从右到左然后从下往上即可但是这只是矩阵为方阵的特殊情况，如果要使用非方阵的矩阵则需要考

输入一个array，返回这个array中元素的所有排列组合情况。样例输入：[1,2,3]样例输出：[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]Solution首先初始化一个排列组合记录器然后写一个helper函数permutations_help(array,currentPermutaion = [],permutations)，输入原始数组array，当前枚举的结果currentPermutaion和

输入一个array，返回这个array中元素的所有排列组合情况。样例输入：[1,2,3]样例输出：[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]Solution解释部分待续def getPermutations(array): permutations_rec =[] permutations_help(array,[],permutations_rec) return permuta

目标，实现入栈pushing 和出站popping查看堆栈顶部的值随时能获取矩阵的最大值和最小值样例输入:见solution样例输出:见solutionSolutionclass MinMaxStack: def __init__(self): self.minMaxStack =[] self.stack = [] #返回顶部的数 #Time: O(1)| space: O(1) def peek(self):

一个BST可以用一个array来代替。我们可以将一个array的数从左到右insert到一个BST中形成一个BST。目标：写一个函数，输入一个array。假设说这个array对应一个BST。那么输出的array应该是一个与输入array长度相同的array。其中output[i]指的是在input[i]的右侧有output[i]个数比input[i]小。复习一下BST的性质，BST的一个节点严格大于所有左侧节点，小于或等于所有右侧的节点。样例输入:[8, 5, 11, -1, 3, 4, 2]

一个BST可以用一个array来代替。我们可以将一个array的数从左到右insert到一个BST中形成一个BST。目标：写一个函数，输入两个array，并比较这两个array是不是一样的。复习一下BST的性质，BST的一个节点严格大于所有左侧节点，小于或等于所有右侧的节点。样例输入arrayOne[10, 15, 8, 12, 94, 81, 5, 2, 11]arrayTwo[10, 8, 5, 15, 2, 12, 11, 94, 81]样例输出True原因是这两个array

首先复习下先序遍历。先序遍历指的是在BST中：1：先访问根节点2：再访问左节点3：最后访问右侧节点样例输入[10, 4, 2, 1, 5, 17, 19, 18]样例输出 10 / \ 4 17 / \ \ 2 5 19 / / 1 18输入一个树的先序遍历的结果，写一个函数根据这个结果重建BST并返回这个BST的根节点。Solution# This is an input class. D

函数的输入是一个二叉搜索树（BST）和一个正整数k， 返回这个BST中第K大的数字。样例输入 15 / \ 5 20 / \ / \ 2 5 17 22 / \ 1 3 k = 3样例输出:17(17是第三大的数)Solution首先需要使用中序遍历对树进行处理，中序遍历(In-Order Traversal)中序遍历指先访问左（右）子树，然后访问根，最后访问右（左）子树的遍历方式，这样如果是先

写一个函数，输入一个非空的已排序的数组，数组的每个元素都是不一样的。根据这个数组构建一个BST。返回这个BST的根节点。样例输入：[1, 2, 5, 7, 10, 13, 14, 15, 22]此时会得到以下这个BST 10 / \ 2 14 / \ / \ 1 5 13 15 \ \ 7 22显然此时根节点为10于是，函数返回10样例输出：10Solution由于此时数组已经是

写一个函数，函数的输入是一个二叉搜索树BST和一个array。函数可以按照要求将便利的结果放进array中，然后进行输出。有一个树状结构： 10 / \ 5 15 / \ \ 2 5 22 / 1遍历方法中序遍历：[1,2,5,5,10,15,22] 指先访问左（右）子树，然后访问根，最后访问右（左）子树的遍历方式前序遍历：[10, 5, 2, 1, 5, 15, 22]指先访问根，然后访问子

一个有效的二叉搜索树（Validate Binary Search Tree)的定义是每一个节点一定大于左边的所有节点，并且小于等于右边的节点。一个模拟BST的网站：https://www.cs.usfca.edu/~galles/visualization/BST.htmlSolution基本的思路是基于有效BST的基本性质，以当前节点作为出发节点，左右进行比较。比较的退出条件是当前的子tree为空，此时认为当前比较的子tree是有效的。如果整棵树是一个有效的BST那么必须满足：向左走，数字会

首先定义一个”深度“的概念，[]----深度为1[[]]----深度为2[[[]]]----深度为3…于是[x,y]的product_sum = x+y[x,[y,z]]的product_sum = x+[y+z]*2[x,[y,[z]]]的product_sum = x+2(y+3z)使用递归写一个函数，输入为包含这种深度规则的数组，返回一个product_sum。样例输入：[5, 2, [7, -1], 3, [6, [-13, 8], 4]]样例输出：12Solution使

有一个二叉树，长这样 1 / \ 2 3 / \ / \ 4 5 6 7 / \ / \ / \ / \8 9 . . . . . .写一个函数，返回所有节点深度值的和。其中节点深度是一个节点到根节点的距离，在这里举个例子，根节点是1 ，那么值为2 的节点到根节点的距离是1.此时应该得到的sum的结果是16。Solution:可以使用一个堆栈结构，首先将根节点以及他的深度depth的键值

广度优先搜索树：A/ | \B C. D|\ /\E. F G H​ |\ \​ I. J K遍历结果：ABCDEFGHIJKSolution：#build treeclass Node: def __init__(self, name): self.children = [] self.name = name def addChild(self, name): self.children.appen

得到一个数组，先打算从头到尾进行访问，但是满足一定规则。例如得到的数组是：[2, 3, 1, -4, -4, 2]先访问2，此时访问的是下标为0的元素。接下来访问的是下标为0+2也就是元素1（下标为2，第三个元素）由于此时的数字是1，接下来访问下标为2+1 = 3的元素也就是-4，依次类推。如果执行到最后，发现所有的元素都恰好被访问了一次，那么程序返回True，否则，返回false。样例输入：[2, 3, 1, -4, -4, 2]样例输出：trueSolution一个基本的想法是，如

给定一个链表，移除链表中的重复项样例链表：1->2->2->2->3->4->5->6->6->7->8输出链表：1->2->3->4->5->6->7->8Solution# This is an input class. Do not edit.class LinkedList: def __init__(self, value): self.value = value self

给定一个链表，移除链表中的重复项样例链表：1->2->2->2->3->4->5->6->6->7->8输出链表：1->2->3->4->5->6->7->8Solution# This is an input class. Do not edit.class LinkedList: def __init__(self, value): self.value = value self

斐波那契数列：第一个数是0，第二个数是1，从此以后，每一个数都是前两个数的和。输入一个整数n，返回斐波那契数列的第n个数。样例输入：n = 2样例输出：1样例输入：n = 6样例输出：5Solution 1:def getNthFib(n): global call print(f"call = {call}") call+= 1 if n == 1: return 0 elif n == 2: return 1 else: return getNthFib

给定一个非空数组，数组中的每个元素代表一个操作的等待时间，假设得到了一个数组为[1,4,5]表示三个任务的等待时间分别为1，4，5.如果按照[5,1,4]的顺序进行查询，那么总的等待时间将为(0)+(5)+(5+1) = 11.这是应为等待时间为5的任务第一个执行时，他的等待时间自动计算为0。第二个执行的任务不得不等待第一个执行完毕，也就是五秒之后才能执行。样例输入：[3,2,1,2,6]样例输出：17Solution想要等待时间最小，需要先执行消耗时间较短的任务。可以先将数组进行从小到大的排

找到数组中最大的三个数，并从小到大进行排列输出。样例输入：[141, 1, 17, -7, -17, -27, 18, 541, 8, 7, 7]样例输出：[18, 141, 541]Solutiontest_array = [141, 1, 17, -7, -17, -27, 18, 541, 8, 7, 7]def findThreeLargestNumbers(array): #构建用于存储最大的三个数的记录器 three_largest = [None, None,None]

输入一个已经排好序的算法，和一个目标数值，使用二叉搜索的方法确定这个target number在这个数组中的哪个位置，这个位置是这个数对应的下标值。样例输入：[0, 1, 21, 33, 45, 45, 61, 71, 72, 73]33Solutiontest_array = [0, 1, 21, 33, 45, 45, 61, 71, 72, 73]target_num = 33def binarySearch(array, target): # Write your code

输入一个数组，返回一个排好序的数组。需要使用插入排序算法样例输入：[8, 5, 2, 9, 5, 6, 3]整个过程类似于在头部开始建立一个不断增加的子数组，如果组数组后边的元素比子数组末尾的元素小，就把这个元素向前进行交换，直到这个元素比子数组中所有的元素都要小为止。样例输出：[2, 3, 5, 5, 6, 8, 9]Solution:test_array = [8, 5, 2, 9, 5, 6, 3]def insertionSort(array): # Write your

输入一个数组，输出他的最大“范围”，也就是最大的连续值的范围。这个范围的左边是最小的数字，右边是最大的数字。样例输入：[1, 11, 3, 0, 15, 5, 2, 4, 10, 7, 12, 6]样例输出：[0,7]这是因为[0,1,2,3,4,5,6,7]是在这个数组中范围最大的连续部分（类似于一个子集）有两种解题方法可以将这个数组映射到一个哈希表中。key是这个数字，value是True的话就是包含在里面（写循环判断会比较方便）从第一个数开始，比如1，然后找比他小的数，如果存在将这个数

输入一个至少由两个整数组成的数组。返回一个数组，内容是在将源输入数组变为有序（升序）数组的过程中需要进行交换操作的最小的数组。样例输入：[1, 2, 4, 7, 10, 11, 7, 12, 6, 7, 16, 18, 19]样例输出：[3,9]假设有一个数是无序的，那么至少有两个数是无序的。Solutiontest_array = [1, 2, 4, 7, 10, 11, 7, 12, 6, 7, 16, 18, 19]def subarraySort(array): # Write

输入一个非空数组和一个目标值targetsum。如果数组中有四个数的和等于目标值，则返回这四个数的左右可能的组合，否则返回一个空数组。样例输入：[7, 6, 4, -1, 1, 2]targetsum = 16样例输出：[[7, 6, 4, -1], [7, 6, 1, 2]]解决这道题的虽简单的方法是暴力搜索，但是时间复杂度将达到惊人的O(n4)O(n^4)O(n4)。实际上有更好的办法。先设定一个哈希表，也就是python中的字典，用来存储 {和-两个数} 这样的组合，这样在遍历所有其他

输入一个数组，长度为n，数组中的数字是[1,n]之间的整数，返回第一个重复的数，如果没有，则返回-1.注意，这个重复值的下标必须是所有重复值中下标最小的。这是个看似简单的问题，但是要达到最佳的时间和空间复杂度指标还是有一定的技巧可以使用的。详见Solution 3样例1 ：输入：[2, 1, 5, 3, 3, 2, 4]输出：3尽管2与2是重复的，但是重复的3比重复的2有更好的下标。Solution 1:test_input = [2, 1, 5, 2, 3, 3, 4]def f

输入一个数组input = [5, 1, 4, 2]返回一个数组，这个数组的每一个元素output[i]都是input中除了input[i]的所有数字的乘积不能使用除法。样例输出：[8, 40, 10, 20]Solution1：遍历当前数组，进行第二层遍历比较下标，将内层遍历时的下标与外层遍历的下标不相等的元素一次累乘。inputarray = [5, 1, 4, 2]def arrayOfProducts(array): # Write your code here.

定义一个山峰的概念。一座山至少有三个数，首先是单调递增的，然后有一个拐点，之后单调递减，这个拐点就是山峰。比如[2,3,10,2]是一座山，从2，2，10是单调递增的，10是一个拐点，之后变为2要求输入一个数组，返回”最长的山的山峰“样例输入：[1, 2, 3, 3, 4, 0, 10, 6, 5, -1, -3, 2, 3]样例输出：6Solution 1:一个直观的做法是分离主体任务1：首先先通过逐个比较找到山峰，从第二个开始到倒数第二个。比较左右两边的数字是否严格小于中间的数。

要求： 检验一个数组是否是单调的输入：[-1, -5, -10, -1100, -900, -1101, -1102, -9001]输出：FalseSolution 1:先确定一个方向，然后遍历这个数组，看看是否破坏之前的方向。def isMonotonic(array): up_down = 0; if len(array)<=2: return True direction = array[1]-array[0] for _ in

Alpha###因子的定义是特定资产的一种指标，比如**市净率 市盈率**。一个因子是对应资产的一种**定价指标**。问题：一些普通的因子如何变成一种**可投资**的指标？量化投资从2012年进入大陆，量化投资—中后台部门。国能衍生品市场还不够健全，只有沪深三百 中证500 上证40 等股指期货期权。大陆的投资方法应该基于**统计，而非向海外一样基于定价**。因子：对应资产的一种定价指标。（好比食品的营养成分）（例子）避险因子的构造（基于美元和黄金）美元和黄金的走势存在一个低相关性。这

读取数据到一个数据框架中，dataframe = pd.read_csv(file_path,index_col = [‘交易日期’],error_bad_lines = False)1.常见参数指定编码方式encoding = ‘gbk’跳过第一行数据Skiprows = 1,将某一列的数据作为下标索引index_col = ['交易日期']仅读取前n行数据n_rows = n只读取特定的列usecols = ['股票代码'，'收盘价']忽略存在空值的错误的行，erro

读取数据到一个数据框架中，dataframe = pd.read_csv(file_path,index_col = [‘交易日期’],error_bad_lines = False)1.常见参数指定编码方式encoding = ‘gbk’跳过第一行数据Skiprows = 1,将某一列的数据作为下标索引index_col = ['交易日期']仅读取前n行数据n_rows = n只读取特定的列usecols = ['股票代码'，'收盘价']忽略存在空值的错误的行，erro

此处将实现一个模拟进行股票交易，对异常情况进行处理的过程。具体的buy（）函数需根据券商提供的接口实现。处理异常的目的：防止程序直接崩溃。（程序出错后代码给出一个解决方案，而不是崩溃了事）例如网络不稳定产生的异常（HttpError），而非程序本身。异常的抛出方法：if #条件: #执行操作else: #抛出异常 raise ValueError(f"BOUGHT of {quantity} share(s) of stock {stock_code} FAIL!")以

Move Element to End问题，将数组中特定相同的数移动到最后样例输入：arr = [2, 1, 2, 2, 2, 3, 4, 2]number_toMove = 2把所有是2的值移动到数组的末尾，得到的结果为：[4, 1, 3, 2, 2, 2, 2, 2]solution 1：指定两个分别指向头部和尾部的指针 A和B。假设需要换测数字是SWhile(A<B):​ 如果A指向的数字和B指向的数字都=S。A不动，B前移一位​ 如果A指向的数字 = S，B指向的数字！=

Smallest Difference最小偏差，输入两个array，对比其中的元素，找到两个绝对值最接近于0的元素，并返回。样例输入：[-1, 5, 10, 20, 28, 3][26, 134, 135, 15, 17]样例输出：[28,26]Solution 1:使用两个for循环，将两个数组中的元素两两比较，采用贪心策略，差最小的就是需要返回的结果。arr_1 = [-1, 5, 10, 20, 28, 3]arr_2 = [26, 134, 135, 15, 17]de

Binary Search Tree （BST） 的增删查Binary Search Tree （BST）的目的是方便搜索，特点是一个节点（node）左边的value比节点的值小，右边的value比节点的值大或者等于。首先需要定义一个单独的节点类class BST: def __init__(self, value): self.value = value self.left = None self.right = None 这里一个节点包含