他说：”好可怕呀！”,

然后转身投入了战斗。

Reply

他说：”好可怕呀！”,

然后转身投入了战斗。

class Test(): def heap_sort(self, nums): i, l = 0, len(nums) self.nums = nums # 构造大顶堆，从非叶子节点开始倒序遍历，因此是l//2 -1 就是最后一个非叶子节点 for i in range(l//2-1, -1, -1): self.build_heap(i, l-1) print(nums) # 上面的循环完成了大顶堆的构造，那么就开始把根节点跟末尾节点交换，然后重新调整大顶堆 for j in range(l-1, -1, -1): nums[0], nums[j] = nums[j], nums[0] self.build_heap(0, j-1) return nums def build_heap(self, i, l): """构建大顶堆""" nums = self.nums left, right = 2*i+1, 2*i+2 ## 左右子节点的下标 large_index = i if left <= l and nums[i] < nums[left]: large_index = left if right <= l and nums[left] < nums[right]: large_index = right # 通过上面跟左右节点比较后，得出三个元素之间较大的下标，如果较大下表不是父节点的下标，说明交换后需要重新调整大顶堆 if large_index != i: nums[i], nums[large_index] = nums[large_index], nums[i] self.build_heap(large_index, l)

For this problem, a height-balanced binary tree is defined as:

a binary tree in which the left and right subtrees of

everynode differ in height by no more than 1.

This problem is an easy-level at Leetcode. I probably did it more than five times, once and once again. Just like a muscle memory.

However, I found an interesting solution today, which literally changed my mind about Python…

Here is the code:

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: def isBalanced(self, root: TreeNode, h = 1) -> bool: if not root: return h l = self.isBalanced(root.left, h + 1) r = self.isBalanced(root.right, h + 1) return abs(l - r) <= 1 and max(l, r)

I am very confused at the last line, the max(l, r) part.

I thought that max(l, r) should be converted as a bool value even it returns a integer type value, because as the second component of the operation AND, max(l, r) should represent as a bool variable.

Following by my worst idea, I supposed that the function isBalanced would return either 1 (True) or 0 (False). However, I found a crazy truth after experiments, that Python executor actually return a integer value (the maximum value of l and r) if abs(l – r) <= 1 is matched.

So, it really makes sense. Gain new knowledge of Python 🙂

There are two methods to calculate the median of an interval [low, high].

- m = ( l + h ) / 2
- m = l + ( h – l ) / 2

l + h may have addition overflow, but h-l will not. Therefore, it is best to use the second method of calculation.

This week, I welcomed a new apartment-mate, who was a brilliant theoretical physicist/ Product Manager/ Programmer/etc. In one word, he is amazing!

After a cheerful chat with him, I got known that he has extremely abundant experience spans many fields. He was used to be a postgraduate student at UCAS majored in theoretical physics, and RA at sustech, and be PM at MeiTuan (A Chinese take-away services pioneer), and be visit student at MPI.

And, you can’t imagine that, he is a very good programmer at BtyeDance currently XD.

Back to our points, I’d grasp this opportunity to learn some very fundamental knowledge about Quantum Computing. Speaking of which, I really wanna figure out the Shor’s Algorithm.

The most important concept of the Shor’s Algorithm should be how to find the period, in which we can take advantages of Quantum Computing.

Fine, my mentor calls me back… I will do this article lately. STAY TUNED!

Great appreciate GFW (National Firewall) lifted me out!!! XD

How highly productive I am…

I just recently completed this post on an online Latex editor, that has a really impressive AI inference formula system. It is pretty good except that I don’t know how to elegantly export content as SVG~

Recently, I found that my lovely website server got busted by Chinese National Firewall (aka. GFW), Maybe because of the ShadowSocks proxy running on this server. I tried to snapshot this server to other servers a couple of times, but the visit speed was really sick. I suppose it related with my domestic DNS binding.

Due to the epidemic outbreak, I am impressively working from home for almost three month. Although I still need to work, but you know at home, I can spend more time on my personal interestings, like machine learning, music and reading. (Hope my mentor will never find this article out)

Attached is a probably boring illustration about transformer architecture. Almost every BERT-ish paper would like to describe it with a bunch of paragraphs. Ironically, I have never carefully looked through this structure. So today I eventually decided to dive deeply into this structure in a precious weekend afternoon.

I could have completed this post in the last month, however I was too exhausted to write this article yesterday (the last day of Feb).

Recently, I am addicted in Probability & Statistics theorem and calculus. I found there is a lot of interesting formula derivation about Normal Distribution (aka Gaussian Distribution), so I’d like to proof it by myself. Here are several methods I tried:

The first formula is the expected value of lognormal distribution. We know, for a continuous function:

And the Probability Density Function (PDF) of lognormal distribution function is:

Hence, we have:

Because of,

Continue readingCredit to reminder – My sweet piggy

Today is the last day of January. It would be my last chance to complete this blog, otherwise I will miss this lovely month.

In this month, I have went to a new company as a FTE, and simultaneously happened to meet an epic epidemic that overwhelming in Mainland China. The government suggests citizens stay at home, so I am suddenly aware of that I can enjoy this great time at home and read some books.

Semigroup is a fancy concept in math and programming. Let’s say there is a set S and a binary operation ✕ on this set: S ✕ S ➞ S, if ✕ meets the binding law, that is ∀ x, y, z ∈ S, (x ✕ y) ✕ z = x ✕ (y ✕ z). Then the ordered pair (S, ✕) is called a semigroup.

For example, S = {1,2,3,4,5, …}, (2 + 3) + 4 = 2 + (3 + 4) = 9.

infix operator <> : AdditionPrecedence protocol Semigroup { static func <> (lhs: Self, rhs: Self) -> Self }

Protocol semigroup declares a calculation method of that two arguments and the return value achieve an identical semigroup type. We called this method as Append. Following is the specific achievements of String and Array.

extension String: Semigroup { static func <> (lhs: String, rhs: String) -> String { return lhs + rhs } } extension Array: Semigroup { static func <> (lhs: [Element], rhs: [Element]) -> [Element] { return lhs + rhs } } func test() { let hello = "Hello " let world = "world" let helloWorld = hello <> world let one = [1,2,3] let two = [4,5,6,7] let three = one <> two }

Next, we are moving to the Monoid part.

Monoid is a kind of semigroup, with an extra attribute named Identity, that is an element E on the set S of the semigroup. Any element A in the set S conforms to A ✕ E = E ✕ A = A.

e.g. 0 + x = x in the natural number set.

protocol Monoid: Semigroup { static var empty: Self { get } } extension String: Monoid { static var empty: String { return "" } } extension Array: Monoid { static var empty: [Element] { return [] } } func test() { let str = "Hello world" <> String.empty // Always "Hello world" let arr = [1,2,3] <> [Int].empty // Always [1,2,3] }

This article is not finish, stay tuned.