In this article, I will focus more on algorithms and theory, including neural network itself, activation function, gradient descent, learning rate, and loss function. And the next piece would discuss programming skills.

What are the steps of deep learning?
1. create a function (neural network)
2. evaluate the goodness of the function
3. pick the best function as the final question answer machine

What is a neural network?
Neural network simulates the ways human learn but is much simpler. It can be imagined as a function. When you feed it input, you are supposed to get an output. …

238. Product of Array Except Self

Given an array nums of n integers where n > 1, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].

### Reverse Product List: Time - O(n) / Space - O(n)
import numpy as np
length  = len(nums)
tableL = np.ones((length+1, ), dtype="int")
tableR = np.ones((length+1, ), dtype="int")for k in range(length):
    tableL[k+1] = tableL[k] * nums[k]
    tableR[length-k-2] = tableR[length-k-1] * nums[length-k-1]
return list(tableL * tableR)[:-1]

240. Search a 2D Matrix II

Write an efficient algorithm that searches for a target value in…

200. Number of Islands

Given an m x n 2d grid map of '1's (land) and '0's (water), return the number of islands.

An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

### Breadth First Search: Time - O(n**4) / Space - O(n**2)
def mark(pos):
    direction = [(1,0), (0,1), (-1,0), (0,-1)]
    stack = [pos]
    while stack:
        pos = stack.pop()
        grid[pos[0]][pos[1]] = "0"for k in range(4):
            tmp_pos =…

150. Evaluate Reverse Polish Notation

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Note:

• Division between two integers should truncate toward zero.
• The given RPN expression is always valid. That means the expression would always evaluate to a result and there won’t be any divide by zero operation.

### Stack: Time - O(n) / Space - O(n)
stack = []
for token in tokens:
    try:
        stack.append(int(token))
    except…

125. Valid Palindrome

Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

Note: For the purpose of this problem, we define empty string as valid palindrome.

### One Pass: Time - O(n) / Space - O(n)
palindrome = ""
for char in string:
    if char.isalnum(): palindrome += char.lower()
return palindrome == palindrome[::-1]

127. Word Ladder

A transformation sequence from word beginWord to word endWord using a dictionary wordList is a sequence of words such that:

• The first word in the sequence is beginWord.
• The last word in the sequence is endWord.
• Only one…

84. Largest Rectangle in Histogram

Given n non-negative integers representing the histogram’s bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

### Stack: Time - O(n**2) / Space - O(n)
heights.append(0)stack = [-1]
result = 0
for idx in range(len(heights)):
    while heights[idx] < heights[stack[-1]]:
        h = heights[stack[-1]]  # maximum height
        w = idx - 1 - stack[-2] # till the further idx (smaller than "h")
        stack.pop()
        result = max(result, w*h)
    stack.append(idx)
return result

88. Merge Sorted Array

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1…

49. Group Anagrams

Given an array of strings strings, group the anagrams together. You can return the answer in any order.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

### Sorting: Time - O(nklogk) / Space - O(nk)
result = {}
for string in strings:
    sort = tuple(sorted(string))
    if sort not in result:
        result[sort] = []
    result[sort].append(string)
return result.values()

50. Pow(x, n)

Implement pow(x, n), which calculates x raised to the power n (i.e. xn).

### Recursion: Time - O(logn) / Space…

21. Merge Two Sorted Lists

Merge two sorted linked lists and return it as a sorted list. The list should be made by splicing together the nodes of the first two lists.

### Loop: Time - O(m+n) / Space - O(1)
head = ListNode()
tail = headwhile l1 or l2:
    if   l2 is None or (l1 is not None and l1.val <= l2.val):
        tail.next = l1
        l1 = l1.next
    elif l1 is None or (l2 is not None and l1.val >= l2.val):
        tail.next = l2
        l2 = l2.next
    tail.next.next = None
    tail = tail.next
return head.next### Recursion
if l1…