Add files using upload-large-folder tool

-Api_avec_python-master/ex2.py

@@ -0,0 +1,115 @@
+###########
+# IMPORTS #
+###########
+
+import requests
+
+# url va me servir à changer de page dans la boucle while
+url = "https://swapi.co/api/people/"
+
+print("Welcome to the Useless Star Wars Facts !")
+
+# Ce tableau contient les noms de certains personnages importants de Star Wars
+# qui n'apparaissent pas dans au moins 3 films, mais dont j'ai quand même envie
+# d'avoir les informations
+namesWeWant = ["Dooku", "Darth Maul", "Jar Jar Binks",
+"Grievous", "Jango Fett", "Qui-Gon Jinn", "Lando Calrissian",
+"Ackbar", "Greedo",]
+
+# Quand il n'y a plus de "page suivante", la page "next" sera égale à None
+# Donc, je boucle sur url tant qu'elle n'est pas égale à None :)
+while url is not None:
+
+	############################
+	# RÉCUPÉRATION DES DONNÉES #
+	############################
+
+	# Je fais la requête sur la page en cours, et je récupère la data
+	r = requests.get(url)
+	data = r.json() 
+
+	# C'est ici que je change l'url pour avoir la page d'après :)
+	url = data["next"]
+	# Ce tableau est la liste de tous les personnages
+	persosTab = data["results"]
+
+	###########################
+	# UTILISATION DES DONNÉES #
+	###########################
+
+	# Je fais ensuite une boucle qui parcourt tous les personnages
+	# et qui affiche plein d'infos sur eux :)
+	for perso in persosTab:
+		name = perso["name"]
+		
+		# Si le perso en cours n'est pas un des persos du tableau namesWeWant
+		# et n'apparaît pas dans au moins 3 films, on le passe et on continue
+		if name not in namesWeWant:
+			if len(perso["films"]) < 3:
+				continue
+
+		print("")
+
+		# Petite condition pour Jar Jar Binks, notre Dieu à tous
+		if name == "Jar Jar Binks":
+			name = "The Great and Mighty Jar Jar Binks, Emperor of the World"
+
+		# Condition spéciale qui ajoute une option au cas où cette info est inconnue
+		eyes = perso["eye_color"]
+		if eyes == "unknown" or eyes == "n/a":
+			eyes = "no-eyed"
+
+		# Ici, je récupère le lien de la race du perso en cours, et je fais une requête dessus
+		# Si le perso en cours n'a pas de race précisée, je lui donne la race "thing"
+		if len(perso["species"]) == 1:
+			speciesURL = perso["species"][0]
+			rSpecies = requests.get(speciesURL)
+			species = rSpecies.json()["name"]
+		else:
+			species = "thing"
+
+		# Petite condition spéciale pour Yoda, le plus grand des maîtres Jedi
+		if species == "Yoda's species":
+			species = "Jedi Master"
+
+		# Ici, je récupere le genre du perso en cours, et lui attribue son pronom
+		# Pour un homme, "He", pour une femme "she"
+		# Et pour les inconnus et les hermaphrodites (comme Jabba, no fake), "It"
+		gender = perso["gender"]
+		if gender == "unknown" or gender == "n/a":
+			gender = "It"
+		elif gender == "male":
+			gender = "He"
+		elif gender == "female":
+			gender = "She"
+		elif gender == "hermaphrodite":
+			gender = "It"
+
+		# Ici, je récupère la couleur des cheveux
+		hair = perso["hair_color"]
+		if hair == "unknown" or hair == "n/a" or hair == "none":
+			hair = "bald"
+		# Petite condition spéciale pour Darth Vader, brûlé au 66e degré
+		if name == "Darth Vader":
+			hair = "burnt"
+
+		# Ici, je récupère la taille en cm
+		height = perso["height"]
+
+		# Ici, je récupère le poids en kg
+		mass = perso["mass"]
+		if mass == "unknown":
+			mass = "0"
+
+		# Ici, je récupère la planète d'origine
+		homeworld = requests.get(perso["homeworld"])
+		homeworldName = homeworld.json()["name"]
+		if homeworldName == "unknown":
+			homeworldName = "an unknown planet"
+
+		# Et enfin, je fais mon méga print avec toutes les infos ! :)
+		print(name + " is a " + eyes + " eyed " + species + ". " 
+			+ gender + " is " + height + "cm tall, weighs " + mass
+			+ "kg, and has " + hair + " hair. " + gender + " comes from " + homeworldName + " ! :)")
+
+print("")

-QuQ--master/README.md

@@ -0,0 +1,50 @@
+# QuanSim
+**Founder:** [@quantumnewbie](https://github.com/zhangxin20121923)  <br/>
+**Contributors:** [@quantumnewbie](https://github.com/zhangxin20121923)  <br/>
+**Institution:** Key laboratory of CPS-DSC, Chongqing University
+## Introduction
+QuanSim is a platform of quantum programming, which consists of a quantum simulator and a suit of quantum program language. With the support of QuanSim, we can design and implement quantum algorithms and vertify the performance of algorithms. What's more, we can design quantum programming language on this platform. If you have any questions, please contact with zhang.x\@cqu.edu.cn.
+## QuanSim
+### Architecture
+QuanSim is developed by Python3 and the architecture of it is shown as follow.
+![](https://raw.githubusercontent.com/zhangxin20121923/QuanSim/master/pic/QuanSim-FrameWork.png) 
+We should point out that "Decohenerce Simulator", "Quantum Program Control-flow" and "Analysis and Verification of Quantum program" are still under development. And we will release them in the future.
+
+### Data Type
+There are four kinds of data types in QuanSim: Bit, Qubit, Qubits and Circuit. Bit means one classical bit, and the value of this type is either 0 or 1. Qubit is the most basic type in quantum computing, which can be in 0 and 1 simultaneously. Qubits will be generated when Qubit is entangled with other Qubit. And Circuit is the basic executable unit. Please note that each experiment and each circuit is a one-to-one correspondence.<br/>
+The relation of these data types are shown as follow.
+![](https://raw.githubusercontent.com/zhangxin20121923/QuanSim/master/pic/QuanSim-datatype.png) 
+
+### Quantum Gate
+For now, the supported quantum gates include: single-qubit gate (that is, H-gate, PauliX-gate, PauliY-gate, PauliZ-gate, S-gate, T-gate, Rx, Ry, Rz, $S^dagger$-gate and $T^dagger$-gate) and double-qubit gate (that is, CNOT). And it's clearly that the set of these gates are universal. <br/>
+
+## How to Use It
+### Start
+You can run QuanSim in the following two ways:<br/>
+* Pass the function name you want to run to *main.py*. The format of the function name should be *function()*. <br/>
+* Run *main.py* without parameter, then QuanSim will give you a list of all available functions. Type the id of the function you want to execute.<br/>
+
+### Executive Mode
+"simulator" and "theory" are two optional executive modes. The former will bring noise to experiments, but the latter will get the theoretical result of this experiment. And you can switch the mode by modifying *executeMode.cfg*.<br/>
+Please note that you can choose whether execute the circuit on IBMQX when it was generated successfully. If you want, you should fill in *IBMToken.cfg* with personal information first. And the personal information can be obtained from *[IBMQX](https://quantumexperience.ng.bluemix.net/qstage/)*.
+ 
+### Design Your Own Code
+Create a new file in *UserCode* folder and name it *\*\*.py*. Design an entry function in this file. Please note that the name of the entry function shouldn't be same with any existing funciton. Then add the name of the file and the entry function to *function.cfg*.
+
+### Package Dependency
+In order to taste all the features of QuanSim, the following Python package is compulsive:<br/>
+1.*matplotlib-2.1*<br/>
+2.*numpy-1.13.3*<br/>
+3.*pillow-4.2.1*<br/>
+4.*psutil-5.4.0*<br/>
+The following packsge is optional:<br/>
+1.*IBMQuantumExperience-1.8.16*
+
+## Development Plan
+We should point out that there are still some features that haven't been developed yet:
+* Due to the physical constraints, the QASM code generated by QuanSim  may not be able to execute on IBMqx successfully. We should continue optimizing the code so that it satisfies the requirement.<br/>
+2017.12.4----Add the optimizing module in QuanSim, and we can execute the QASM code which is under the constraint of IBM on IBM chip.<br/>
+* The analysis and verification of quantum program is an urgent requirement. <br/>
+* The quantum control-flow is still under development.<br/>
+* Some unknown bugs.<br/>
+

-QuQ--master/baseClass/DMO.py

@@ -0,0 +1,266 @@
+#!/usr/bin/python3
+from baseGate import *
+from Gate import *
+import copy
+#only X,Y,Z,I,H,S,Sd,T,Td,CNOT is allowed
+import re
+
+
+#delay measure opertor class used in DMif
+class DMO:
+	def __init__(self,ql,vl):
+		#storage the control-qubit list
+		self.DMOql = ql
+		self.split = SplitGate()
+		self.DMOvl = vl
+
+	#get the info about the function name and the line number
+	def get_curl_info(self):
+		try:
+			raise Exception
+		except:
+			f = sys.exc_info()[2].tb_frame.f_back
+		return [f.f_code.co_name, f.f_lineno]
+
+	#set the name of the control qubit gate:if there are 3 qubit in self.DMOql and vl = [1,0,1],
+	#then the full name should be c1-c0-c1-SingleQubitGate.
+	def __fullGName(self,gn:str,vl:list,ql:list):
+		name = ""
+		for i in range(0,len(ql)):
+			name += "c"
+			if len(vl) == 1:
+				j = 0
+			else:
+				j = i
+			if vl[j] == 0:
+				name += "0"
+			else:
+				name += "1"
+			name += "-"
+		cgn = name[0:len(name)-1]
+		return self.__setFullGName(cgn,gn)
+	#get the full name of the multi-controlled gate
+	def __setFullGName(self,cgn:str,gn:str):
+		return (cgn + "-" + gn)
+
+
+
+	#the "cq" is the control-qubit of the CNOT gate
+	def Operator(self,gateName:str,tq:Qubit,cq = None,angle = None):
+
+		ql = self.DMOql.copy()
+		vl = self.DMOvl.copy()
+
+		QASM = ""
+		if cq != None:
+			#CNOT gate call this function. We shoulde convert the format of CNOT
+			ql.append(cq)
+			vl.append(1)
+		fullGName = self.__fullGName(gateName,vl,ql)
+		#CNOT gate
+		if fullGName == "c1-X":
+			return CNOT(ql[0],tq)
+
+		#the return value is a list consisted of all the control-qubits and the target-qubit	
+		if re.match(r'^(c\d-){1}.{1,2}$',fullGName) != None:
+			#split the CU and execute the computation
+			return self.split.CU(fullGName,ql[0],tq,vl,angle,True)
+		else:
+			#split the MCU and execute the computation
+			return self.split.MCU(fullGName,ql,tq,vl,angle,True)
+
+
+	def X(self,q:Qubit):
+		gateName = "X"
+		return self.Operator(gateName,q)
+
+	def Y(self,q:Qubit):
+		gateName = "Y"
+		return self.Operator(gateName,q)
+
+	def Z(self,q:Qubit):
+		gateName = "Z"
+		return self.Operator(gateName,q)
+
+	def H(self,q:Qubit):
+		gateName = "H"
+		return self.Operator(gateName,q)
+
+	def S(self,q:Qubit):
+		gateName = "S"
+		return self.Operator(gateName,q)
+
+	def Sd(self,q:Qubit):
+		gateName = "Sd"
+		return self.Operator(gateName,q)
+
+	def T(self,q:Qubit):
+		gateName = "T"
+		return self.Operator(gateName,q)
+
+	def Td(self,q:Qubit):
+		gateName = "Td"
+		return self.Operator(gateName,q)
+
+	def CNOT(self,q1:Qubit,q2:Qubit):
+		gateName = "X"
+		return self.Operator(gateName,q2,q1)
+
+	def Rz(self,phi,q:Qubit):
+		gateName = "Rz"
+		return self.Operator(gateName,q,None,phi)
+
+	def Ry(self,phi,q:Qubit):
+		gateName = "Ry"
+		return self.Operator(gateName,q,None,phi)
+
+
+
+#measure operator class used in Mif and Qif
+class MO(DMO):
+	def __init__(self,ql,vl):
+		self.MOql = ql
+		self.MOvl = vl
+		self.header = ""
+		bitList = self.MO(ql,vl)
+		self.bool = True
+		
+		if len(vl) == 1:
+			for bit in bitList:
+				if bit.value != vl[0]:
+					self.bool = False
+					break
+		else:
+			for j in range(0,len(bitList)):
+				if bitList[j] != vl[j]:
+					self.bool = False
+					break
+
+
+	#this kind of measure is used in Mif;
+	#ql means the qubit list need be measured; and the vl stands for the target result of measurement
+	def MO(self,ql:list,vl:list):
+		if len(ql) != len(vl):
+			try:
+				raise CodeError("The element number of Qubit List should be same with Value List!")
+			except CodeError as ce:
+				info = get_curl_info()
+				funName = info[0]
+				line = info[1]
+				writeErrorMsg(ce,funName,line)
+		bitList = []
+		for q in ql:
+			bitList.append(M(q,False))
+
+		#construct the if statement
+		# ifstr = "if ("
+		# for i in range(0,len(ql)):
+		# 	c = str(ql[i].ids)
+		# 	tmp = "c[" + c + "]==" + str(vl[i])
+		# 	if i != len(ql)-1:
+		# 		tmp += " && "
+		# 	ifstr += tmp
+		# ifstr += "){}"
+		ifstr = ""
+		for v in vl:
+			ifstr += "M" + str(v) + "-"
+		self.header = ifstr
+
+		return bitList
+
+	def recordGate(self,gate:str,ql:list):
+		circuit = checkEnvironment()
+		maxL = 0
+		content = gate + " "
+		for i in range(0,len(ql)):
+			length = len(circuit.qubitExecuteList[ql[i]])
+			maxL = max(length,maxL)
+			content += str(ql[i].ids)
+			if i != len(ql)-1:
+				content += ','
+
+		for q in ql:
+			try:
+				while len(circuit.qubitExecuteList[q]) < maxL:
+					circuit.qubitExecuteList[q].append("NULL "+str(q.ids))
+				circuit.qubitExecuteList[q].append(content)
+				if circuit.withOD:
+					while len(circuit.qubitExecuteListOD[q]) < maxL:
+						circuit.qubitExecuteListOD[q].append("NULL "+str(q.ids))
+					circuit.qubitExecuteListOD[q].append(content)
+			except KeyError:
+				info = get_curl_info()
+				writeErrorMsg("Qubit: q" + str(q.ids) + " hasn't been stored in circuit.qubitExeucetList!\
+					" ,info[0],info[1])
+
+		# print(circuit.qubitExecuteList)
+		# print(circuit.qubitExecuteListOD)
+
+	#overwrite the operator method
+	def Operator(self,gateName:str,tq:Qubit,cq = None,angle = None):
+		if cq != None:
+			gateName = "c1-X"
+		fullGName = self.header + gateName
+
+		#no matter what's self.bool, record the Measure Operator in qubitExecuteList
+		if self.bool:
+			#if the last position of the full gate name is 1, then the gate is executed
+			fullGName += "1"
+		else:
+			#if the last position of the gate name is 0, then the gate isn't executed
+			fullGName += "0"
+		ql = self.MOql.copy()
+		if cq != None:
+			ql.append(cq)
+		ql.append(tq)
+		self.recordGate(fullGName,ql)
+
+		#execute the operator according to self.bool
+		if gateName == "c1-X":
+			gateName = "CNOT"
+		q = None
+		if self.bool:
+			#execute the gate function in Gate.py
+			if cq == None:
+				exeStr = "q = " + gateName + "(tq,False,True)"
+			else:
+				exeStr = "q = " + gateName + "(cq,tq,False,True)"
+			#print(exeStr)
+			exec(exeStr)
+		else:
+			#don't exeucte the gate
+			pass
+
+		return q
+
+	#the single gate operator and the double gate operator were inherited from DMO class
+	#def X
+	#def Y
+	#def Z
+	#def H
+	#def S
+	#def Sd
+	#def T
+	#def Td
+	#def CNOT
+	#def Rz
+	#def Ry
+	#def get_curl_info
+
+	
+		
+
+
+#delay measure operator class used in Qwhile
+class QWMO(DMO):
+	def __init__(self,ql,vl,angle):
+		DMO.__init__(ql,vl)
+		self.angle = angle
+
+	def end(self):
+		for q in ql:
+			Rx(angle,q)
+		if True:
+			return True
+		else:
+			return False

-QuQ--master/config/function.cfg

@@ -0,0 +1,6 @@
+{"fileName":"Grover","entryFunction":"grover()"}
+{"fileName":"Teleportation","entryFunction":"teleportation()"}
+{"fileName":"GroverLite","entryFunction":"groverLite()"}
+{"fileName":"Test","entryFunction":"u()"}
+{"fileName":"ExpWrong","entryFunction":"wrong()"}
+{"fileName":"UserSWAP","entryFunction":"SWAP()"}

-QuQ--master/results/README.md

@@ -0,0 +1 @@
+

-QuQ--master/userCode/Teleportation.py

@@ -0,0 +1,23 @@
+from header import *
+#the flow of this algorithm is designed as follow:
+#1.prepare the Bell state
+#2.implement the algorithm according to Nielsen and L.Chuang 
+def teleportation():
+	c = Circuit(True)
+	#store the unknow quantum state, the aim of this algorithm is teleporting the state of AliceQ to BobQ
+	AliceQ = Qubit()
+	#the two qubit is entanglement with each other
+	AliceQ2 = Qubit()
+	BobQ = Qubit()
+	H(AliceQ2)
+	CNOT(AliceQ2,BobQ)
+	CNOT(AliceQ,AliceQ2)
+	H(AliceQ)
+	CNOT(AliceQ2,BobQ)
+	#######Control-Z#########
+	H(BobQ)
+	CNOT(AliceQ,BobQ)
+	H(BobQ)
+	#########################
+	BobQ = M(BobQ)
+	c.execute(1024)

0617-audio_stream-master/model/__init__.py

@@ -0,0 +1 @@
+

0617-audio_stream-master/test.py

@@ -0,0 +1,67 @@
+import os
+from hyper import *
+from model.CPD_models import CPD_VGG
+from model.CPD_models import CPD_3DResNet
+from dataset import *
+import cv2
+import torch
+import torch.nn.functional as F
+
+max = 600
+name = 'model_cpd_250616_Adam_1e-05_20_BCEWithLogitsLoss_8.pth'
+checkpoint = './checkpoint/cpd_0616/' + name
+# checkpoint = './pre-trained/audio/model_cpd_300525_Adam_1.0000000000000002e-07_20_BCEWithLogitsLoss_29.pth'
+# checkpoint = 'C:/Users/MSI-PC/Desktop/cpd_wrs_2.21_导入参数后效果很好/train_weight/vgg_dfh1k_cpd/vgg.pth.10'
+model = CPD_3DResNet()
+model.load_state_dict(torch.load(checkpoint))
+
+print('\n', name, '\n')
+'''
+save_model = torch.load(checkpoint)
+now_model = model.state_dict()
+state_dict = {k: v for k, v in save_model.items() if k in now_model.keys()}
+now_model.update(state_dict)
+model.load_state_dict(now_model)
+'''
+
+model.cuda()
+model.eval()
+
+dir_num = 0
+img_num = 0
+
+for i in os.listdir(test_data_path):
+    test_frames = test_data_path + i + '/'
+    save_path = './test_result/' + checkpoint.split('/')[-1].split('.pth')[0] + '/' + i + '/'
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+
+    test_loader = LoadTestData(test_frames)
+
+    for j in range(test_loader.size):
+        image, name, index = test_loader.load_data()
+
+        image = image.reshape(1, image.size(0), image.size(1), image.size(2))
+        image = image.cuda()
+
+        ress = model(image)
+        h = 256
+        w = 320
+        
+        res = F.interpolate(ress, size=[h, w], mode='bilinear', align_corners=False)
+        res = res.sigmoid().data.cpu().numpy().squeeze()
+        res = (res - res.min()) / (res.max() - res.min() + 1e-8)
+        cv2.imwrite(save_path + name, res * 255)
+        img_num += 1
+        '''
+        if j == 150:
+         break
+        '''
+    print("===== {} finished !=====\n".format(i))
+    dir_num += 1
+    if dir_num == max:
+        exit(0)
+
+print("Total test images == {} == !\n".format(img_num))
+
+

0621_test-master/django_app/post/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class PostConfig(AppConfig):
+    name = 'post'

0621_test-master/django_app/post/models.py

@@ -0,0 +1,9 @@
+from django.contrib.auth.models import User
+from django.db import models
+
+
+class Post(models.Model):
+    author = User.objects.first()
+    comment = models.CharField(max_length=200)
+    created_date = models.DateTimeField(auto_now_add=True)
+    modify_date = models.DateTimeField(auto_now=True)

10-week-algorithm-excercise-master/OneQuestionPerDay/104/maximum_depth_of_binary_tree3.go

@@ -0,0 +1,24 @@
+package main
+
+func maxDepth3(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	stack := []*TreeNode{root}
+	level := 0
+
+	for len(stack) > 0 {
+		num := len(stack)
+		for i := 0; i < num; i++ {
+			if stack[i].Left != nil {
+				stack = append(stack, stack[i].Left)
+			}
+			if stack[i].Right != nil {
+				stack = append(stack, stack[i].Right)
+			}
+		}
+		stack = stack[num:]
+		level++
+	}
+	return level
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/15/3sum.go

@@ -0,0 +1,42 @@
+package main
+
+import "sort"
+
+func threeSum(nums []int) [][]int {
+	sort.Ints(nums)
+	res := make([][]int, 0)
+	for i := 0; i < len(nums)-2; i++ {
+		if nums[i] > 0 {
+			break
+		}
+		if i > 0 && nums[i] == nums[i-1] {
+			continue
+		}
+		j, k := i+1, len(nums)-1
+		for j < k {
+			s := nums[i] + nums[j] + nums[k]
+			if s == 0 {
+				res = append(res, []int{nums[i], nums[j], nums[k]})
+				j++
+				k--
+				for j < k && nums[j] == nums[j-1] {
+					j++
+				}
+				for j < k && nums[k] == nums[k+1] {
+					k--
+				}
+			} else if s > 0 {
+				k--
+				for j < k && nums[k] == nums[k+1] {
+					k--
+				}
+			} else {
+				j++
+				for j < k && nums[j] == nums[j-1] {
+					j++
+				}
+			}
+		}
+	}
+	return res
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/258/add_digits.py

@@ -0,0 +1,26 @@
+class Solution:
+    def addDigits(self, num: int) -> int:
+        while num > 9:
+            s = 0
+            while num > 0:
+                s += num % 10
+                num //= 10
+            num = s
+        return num
+
+    def test(self):
+        for num, target in [
+            (0, 0),
+            (1, 1),
+            (9, 9),
+            (10, 1),
+            (11, 2),
+            (19, 1),
+        ]:
+            ans = self.addDigits(num)
+            assert ans == target, f"target: {target}, ans: {ans}"
+        print("well done")
+
+
+if __name__ == "__main__":
+    Solution().test()

10-week-algorithm-excercise-master/OneQuestionPerDay/300/longest_increasing_subsequence2.go

@@ -0,0 +1,22 @@
+package main
+
+func lengthOfLIS2(nums []int) int {
+	tail := make([]int, 0)
+	for i := 0; i < len(nums); i++ {
+		if i == 0 || nums[i] > tail[len(tail)-1] {
+			tail = append(tail, nums[i])
+		} else {
+			left, right := 0, len(tail)
+			for left < right {
+				mid := (left + right) / 2
+				if tail[mid] < nums[i] {
+					left = mid + 1
+				} else {
+					right = mid
+				}
+			}
+			tail[left] = nums[i]
+		}
+	}
+	return len(tail)
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/300/longest_increasing_subsequence_test.go

@@ -0,0 +1,18 @@
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	tests := []struct {
+		nums   []int
+		target int
+	}{
+		{[]int{10, 9, 2, 5, 3, 7, 101, 18, 4, 8, 6, 12}, 5},
+	}
+
+	for _, tt := range tests {
+		if ans := lengthOfLIS2(tt.nums); ans != tt.target {
+			t.Fatalf("target: %d, ans: %d\n", tt.target, ans)
+		}
+	}
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/350/intersection_of_two_arrays_ii.py

@@ -0,0 +1,16 @@
+from typing import List, Dict
+from collections import defaultdict
+
+
+class Solution:
+    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        counter: Dict[int, int] = defaultdict(int)
+        for n in nums1:
+            counter[n] += 1
+
+        res = []
+        for n in nums2:
+            if counter[n] > 0:
+                res.append(n)
+                counter[n] -= 1
+        return res

10-week-algorithm-excercise-master/OneQuestionPerDay/387/first_unique_character_in_a_string.py

@@ -0,0 +1,12 @@
+class Solution:
+    def firstUniqChar(self, s: str) -> int:
+        arr = [0] * 26
+
+        for i, c in enumerate(s):
+            arr[ord(c) - ord('a')] = i
+
+        for i, c in enumerate(s):
+            if arr[ord(c) - ord('a')] == i:
+                return i
+            arr[ord(c) - ord('a')] = -1
+        return -1

10-week-algorithm-excercise-master/OneQuestionPerDay/412/fizz_buzz.go

@@ -0,0 +1,19 @@
+package main
+
+import "strconv"
+
+func fizzBuzz(n int) []string {
+	res := make([]string, n)
+	for i := 1; i <= n; i++ {
+		if i%15 == 0 {
+			res[i-1] = "FizzBuzz"
+		} else if i%5 == 0 {
+			res[i-1] = "Buzz"
+		} else if i%3 == 0 {
+			res[i-1] = "Fizz"
+		} else {
+			res[i-1] = strconv.Itoa(i)
+		}
+	}
+	return res
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/718/maximum_length_of_repeated_subarray.go

@@ -0,0 +1,29 @@
+package main
+
+func findLength(A []int, B []int) int {
+	m, n := len(A), len(B)
+	if m == 0 || n == 0 {
+		return 0
+	}
+	dp := make([][]int, m+1)
+	for i := 0; i < m; i++ {
+		dp[i] = make([]int, n+1)
+	}
+	res := 0
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if A[i] == B[j] {
+				dp[i+1][j+1] = dp[i][j] + 1
+				res = max(res, dp[i+1][j+1])
+			}
+		}
+	}
+	return res
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/718/maximum_length_of_repeated_subarray2.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    def findLength(self, A: List[int], B: List[int]) -> int:
+        def maxLength(addA: int, addB: int, length: int) -> int:
+            ret = k = 0
+            for i in range(length):
+                if A[addA + i] == B[addB + i]:
+                    k += 1
+                    ret = max(ret, k)
+                else:
+                    k = 0
+            return ret
+
+        n, m = len(A), len(B)
+        ret = 0
+        for i in range(n):
+            length = min(m, n - i)
+            ret = max(ret, maxLength(i, 0, length))
+        for i in range(m):
+            length = min(n, m - i)
+            ret = max(ret, maxLength(0, i, length))
+        return ret
+
+    def test(self):
+        a = [1, 2, 3, 2, 1]
+        b = [3, 2, 1, 4, 7]
+        ans = self.findLength(a, b)
+        print(ans)
+
+
+if __name__ == "__main__":
+    Solution().test()

10-week-algorithm-excercise-master/OneQuestionPerDay/83/remove_duplicates_from_sorted_list.py

@@ -0,0 +1,21 @@
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution:
+    def deleteDuplicates(self, head: ListNode) -> ListNode:
+        if head is None:
+            return head
+        elments = {head.val}
+        prev, cur = head, head.next
+        while cur is not None:
+            if cur.val not in elments:
+                elments.add(cur.val)
+                prev, cur = cur, cur.next
+            else:
+                prev.next = cur.next
+                cur = cur.next
+        return head

10-week-algorithm-excercise-master/OneQuestionPerDay/LCCI17/get_kth_magic_number.py

@@ -0,0 +1,17 @@
+class Solution:
+    def getKthMagicNumber(self, k: int) -> int:
+        dp = [1] * k
+        p3 = p5 = p7 = 0
+
+        for i in range(1, k):
+            f3 = 3 * dp[p3]
+            f5 = 5 * dp[p5]
+            f7 = 7 * dp[p7]
+            dp[i] = min(f3, f5, f7)
+            if f3 == dp[i]:
+                p3 += 1
+            if f5 == dp[i]:
+                p5 += 1
+            if f7 == dp[i]:
+                p7 += 1
+        return dp[k - 1]

10-week-algorithm-excercise-master/OneQuestionPerDay/LCCI17/get_kth_magic_number_test.go

@@ -0,0 +1,19 @@
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	tests := []struct {
+		k      int
+		target int
+	}{
+		{1, 1},
+		{5, 9},
+	}
+
+	for _, tt := range tests {
+		if ans := getKthMagicNumber2(tt.k); ans != tt.target {
+			t.Fatalf("target: %d, ans: %d\n", tt.target, ans)
+		}
+	}
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/LCOF5/replace_space.py

@@ -0,0 +1,9 @@
+class Solution:
+    def replaceSpace(self, s: str) -> str:
+        res = []
+        for c in s:
+            if c == " ":
+                res.append("%20")
+            else:
+                res.append(c)
+        return "".join(res)

10-week-algorithm-excercise-master/OneQuestionPerDay/LCOF59/max_sliding_window.go

@@ -0,0 +1,18 @@
+package main
+
+func maxSlidingWindow(nums []int, k int) []int {
+	var window, res []int
+	for i := 0; i < len(nums); i++ {
+		if len(window) > 0 && window[0] <= i-k {
+			window = window[1:]
+		}
+		for len(window) > 0 && nums[window[len(window)-1]] < nums[i] {
+			window = window[:len(window)-1]
+		}
+		window = append(window, i)
+		if i >= k-1 {
+			res = append(res, nums[window[0]])
+		}
+	}
+	return res
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/LCOF6/reverse_link_node.go

@@ -0,0 +1,20 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func reversePrint(head *ListNode) []int {
+	var res []int
+
+	for head != nil {
+		res = append(res, head.Val)
+		head = head.Next
+	}
+
+	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
+		res[i], res[j] = res[j], res[i]
+	}
+	return res
+}

10-week-algorithm-excercise-master/OneQuestionPerDay/LCOF6/reverse_link_node.py

@@ -0,0 +1,17 @@
+from typing import List
+
+
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution:
+    def reversePrint(self, head: ListNode) -> List[int]:
+        res = []
+
+        while head is not None:
+            res.append(head.val)
+            head = head.next
+        return res[::-1]

10-week-algorithm-excercise-master/Week_01/1/two_sum.py

@@ -0,0 +1,12 @@
+from typing import List
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        cache = {}
+        for i, n in enumerate(nums):
+            m = target - n
+            if m in cache:
+                return [cache[m], i]
+            cache[n] = i
+        return []

10-week-algorithm-excercise-master/Week_01/11/container_with_most_water.go

@@ -0,0 +1,18 @@
+package main
+
+func maxArea(height []int) int {
+	i, j, res, v := 0, len(height)-1, 0, 0
+	for i < j {
+		if height[i] <= height[j] {
+			v = height[i] * (j - i)
+			i++
+		} else {
+			v = height[j] * (j - i)
+			j--
+		}
+		if v > res {
+			res = v
+		}
+	}
+	return res
+}

10-week-algorithm-excercise-master/Week_01/11/container_with_most_water_test.go

@@ -0,0 +1,20 @@
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	tests := []struct {
+		heights []int
+		target  int
+	}{
+		{[]int{1, 1, 1, 1}, 3},
+		{[]int{1, 1}, 1},
+		{[]int{1, 8, 6, 2, 5, 4, 8, 3, 7}, 49},
+	}
+
+	for _, tt := range tests {
+		if ans := maxArea(tt.heights); ans != tt.target {
+			t.Fatalf("target : %d, ans: %d\n", tt.target, ans)
+		}
+	}
+}

10-week-algorithm-excercise-master/Week_01/141/linked_list_cycle.go

@@ -0,0 +1,19 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func hasCycle0(head *ListNode) bool {
+	seen := make(map[*ListNode]bool)
+	for head != nil {
+		if seen[head] {
+			return true
+		} else {
+			seen[head] = true
+		}
+		head = head.Next
+	}
+	return false
+}

10-week-algorithm-excercise-master/Week_01/141/linked_list_cycle3.go

@@ -0,0 +1,19 @@
+package main
+
+
+func hasCycle3(head *ListNode) bool {
+	if head ==  nil {
+		return false
+	}
+	prev, cur := head, head.Next
+	for cur != nil {
+		if cur == head {
+			return true
+		}
+		next := cur.Next
+		cur.Next = prev
+		prev = cur
+		cur = next
+	}
+	return false
+}

10-week-algorithm-excercise-master/Week_01/142/linked_list_cycle_ii.go

@@ -0,0 +1,27 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func detectCycle(head *ListNode) *ListNode {
+	slow := head
+	fast := head
+	for {
+		if fast == nil || fast.Next == nil {
+			return nil
+		}
+		fast = fast.Next.Next
+		slow = slow.Next
+		if fast == slow {
+			break
+		}
+	}
+	fast = head
+	for fast != slow {
+		fast = fast.Next
+		slow = slow.Next
+	}
+	return fast
+}

10-week-algorithm-excercise-master/Week_01/142/linked_list_cycle_ii.py

@@ -0,0 +1,22 @@
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        fast = slow = head
+        while True:
+            if fast is None or fast.next is None:
+                return None
+            fast = fast.next.next
+            slow = slow.next
+            if fast is slow:
+                break
+        fast = head
+
+        while fast is not slow:
+            fast = fast.next
+            slow = slow.next
+        return fast

10-week-algorithm-excercise-master/Week_01/15/3sum.go

@@ -0,0 +1,31 @@
+package main
+
+import "sort"
+
+type Element struct {
+	a, b, c int
+}
+
+func threeSum(nums []int) [][]int {
+	sort.Ints(nums)
+	var ret [][]int
+	elements := make(map[Element]bool)
+
+	for i := 0; i < len(nums)-2; i++ {
+		a := nums[i]
+		cache := map[int]int{}
+		for j := i + 1; j < len(nums); j++ {
+			c := nums[j]
+			b := - a - c
+			if _, ok := cache[b]; ok {
+				elements[Element{a, b, c}] = true
+			} else {
+				cache[c] = 1
+			}
+		}
+	}
+	for e := range elements {
+		ret = append(ret, []int{e.a, e.b, e.c})
+	}
+	return ret
+}

10-week-algorithm-excercise-master/Week_01/15/3sum_test.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	tests := []struct {
+		nums   []int
+		target [][]int
+	}{
+		{[]int{1,-1,-1,0}, [][]int{{-1,0,1}}},
+		{[]int{-1,0,1,2,-1,-4}, [][]int{{-1,-1,2},{-1,0,1}}},
+	}
+
+	for _, tt := range tests {
+		if ans := threeSum2(tt.nums); !reflect.DeepEqual(ans, tt.target) {
+			t.Fatalf("target: %v, ans %v\n", tt.target, ans)
+		}
+	}
+}

10-week-algorithm-excercise-master/Week_01/155/min_stack.py

@@ -0,0 +1,24 @@
+class MinStack:
+
+    def __init__(self):
+        """
+        initialize your data structure here.
+        """
+        self.stack = []
+        self.min_stack = []
+
+    def push(self, x: int) -> None:
+        self.stack.append(x)
+        if len(self.min_stack) == 0 or self.min_stack[-1] >= x:
+            self.min_stack.append(x)
+
+    def pop(self) -> None:
+        v = self.stack.pop()
+        if v == self.min_stack[-1]:
+            self.min_stack.pop()
+
+    def top(self) -> int:
+        return self.stack[-1]
+
+    def getMin(self) -> int:
+        return self.min_stack[-1]

10-week-algorithm-excercise-master/Week_01/189/rotate_array.go

@@ -0,0 +1,12 @@
+package main
+
+func rotate1(nums []int, k int) {
+	if len(nums) < 2 || len(nums) == k {
+		return
+	}
+	for i := 0; i < k; i++ {
+		tail := nums[len(nums)-1]
+		copy(nums[1:], nums[0:len(nums)-1])
+		nums[0] = tail
+	}
+}

10-week-algorithm-excercise-master/Week_01/189/rotate_array_test.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	tests := []struct {
+		nums   []int
+		k      int
+		target []int
+	}{
+		{[]int{1}, 0, []int{1}},
+		{[]int{1, 2}, 1, []int{2, 1}},
+		{[]int{1, 2, 3, 4, 5}, 2, []int{4, 5, 1, 2, 3}},
+		{[]int{1, 2, 3, 4, 5}, 3, []int{3, 4, 5, 1, 2}},
+	}
+
+	for _, tt := range tests {
+		if rotate(tt.nums, tt.k); !reflect.DeepEqual(tt.nums, tt.target) {
+			t.Fatalf("target %v, got %v\n", tt.target, tt.nums)
+		}
+	}
+}

10-week-algorithm-excercise-master/Week_01/20/valid_parentheses.go

@@ -0,0 +1,23 @@
+package main
+
+func isValid(s string) bool {
+	mapping := map[byte]byte{
+		')': '(',
+		'}': '{',
+		']': '[',
+	}
+	stack := make([]byte, 0)
+	for i := 0; i < len(s); i++ {
+		if v, ok := mapping[s[i]]; !ok {
+			stack = append(stack, s[i])
+		} else {
+			if len(stack) == 0 || stack[len(stack)-1] != v {
+				return false
+			} else {
+				stack = stack[:len(stack)-1]
+			}
+		}
+	}
+
+	return len(stack) == 0
+}

10-week-algorithm-excercise-master/Week_01/206/reverse_linked_list.go

@@ -0,0 +1,14 @@
+package main
+
+func reverseList0(head *ListNode) *ListNode {
+    if head == nil {
+        return head
+    }
+	headNew := head
+	for head.Next != nil {
+		next := head.Next
+		head.Next, next.Next = next.Next, headNew
+		headNew = next
+	}
+	return headNew
+}

10-week-algorithm-excercise-master/Week_01/21/merge_two_sorted_lists.go

@@ -0,0 +1,28 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+	dummy := &ListNode{}
+	cur := dummy
+	for l1 != nil && l2 != nil {
+		if l1.Val < l2.Val {
+			cur.Next = l1
+			l1 = l1.Next
+		} else {
+			cur.Next = l2
+			l2 = l2.Next
+		}
+		cur = cur.Next
+	}
+
+	if l1 != nil {
+		cur.Next = l1
+	} else {
+		cur.Next = l2
+	}
+	return dummy.Next
+}

10-week-algorithm-excercise-master/Week_01/239/sliding_window_maximum.py

@@ -0,0 +1,31 @@
+from typing import List
+from collections import deque
+
+
+class Solution:
+    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
+        dq = deque()
+        res = []
+        for i, n in enumerate(nums):
+            while dq and dq[0] <= i - k:
+                dq.popleft()
+            while dq and nums[dq[-1]] < n:
+                dq.pop()
+            dq.append(i)
+            if i >= k - 1:
+                res.append(nums[dq[0]])
+        return res
+
+    def test(self):
+        for nums, k, target in [
+            ([], 3, []),
+            ([1, 2], 1, [1, 2]),
+            ([1, 3, -1, -3, 5, 3, 6, 7], 3, [3, 3, 5, 5, 6, 7]),
+        ]:
+            ans = self.maxSlidingWindow(nums, k)
+            assert ans == target, f"target: {target}, ans: {ans}"
+        print("all done")
+
+
+if __name__ == "__main__":
+    Solution().test()

10-week-algorithm-excercise-master/Week_01/24/swap_nodes_in_pairs2.py

@@ -0,0 +1,51 @@
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+    def __repr__(self):
+        return f"[Node]{self.val}"
+
+
+class Solution:
+    def swapPairs(self, head: ListNode) -> ListNode:
+        dummy = ListNode(0)
+        dummy.next = head
+        prev = dummy
+
+        while head is not None and head.next is not None:
+            prev.next = head.next
+            prev = head
+            head.next.next, head.next = head, head.next.next
+            head = head.next
+        return dummy.next
+
+    def test(self):
+        node1 = ListNode(1)
+        node2 = ListNode(2)
+        node3 = ListNode(3)
+        node4 = ListNode(4)
+
+        node2.next = node1
+        node3.next = node2
+        node4.next = node3
+
+        ans = self.swapPairs(node1)
+        assert ans == node1
+
+        ans = self.swapPairs(node2)
+        assert ans == node1
+        #
+        ans = self.swapPairs(node1)
+        assert ans == node2
+
+        ans = self.swapPairs(node4)
+        assert ans == node3
+
+        print("success")
+
+
+if __name__ == "__main__":
+    Solution().test()
+
+

10-week-algorithm-excercise-master/Week_01/25/reverse_nodes_in_k_group.go

@@ -0,0 +1,33 @@
+package main
+
+type ListNode struct {
+     Val int
+     Next *ListNode
+}
+
+func reverseKGroup(head *ListNode, k int) *ListNode {
+	dummy := &ListNode{Next: head}
+	prev := dummy
+	slow, fast := head, head
+	for {
+		cnt := 1
+		for fast != nil && cnt < k {
+			fast = fast.Next
+			cnt++
+		}
+		if fast == nil {
+			break
+		}
+		prev.Next = fast
+		prev = slow
+		next := slow.Next
+		prev.Next = fast.Next
+
+		for next != prev.Next {
+			next, next.Next, slow = next.Next, slow, next
+		}
+		slow = prev.Next
+		fast = prev.Next
+	}
+	return dummy.Next
+}

10-week-algorithm-excercise-master/Week_01/26/remove_duplicates_from_sorted_array_test.go

@@ -0,0 +1,21 @@
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	tests := []struct {
+		nums   []int
+		target int
+	}{
+		{[]int{}, 0},
+		{[]int{1, 1}, 1},
+		{[]int{1, 1, 2}, 2},
+		{[]int{0,1,1,1,2,2,3,3,4}, 5},
+	}
+
+	for _, tt := range tests {
+		if ans := removeDuplicates(tt.nums); ans != tt.target {
+			t.Fatalf("target: %d, ans: %d\n", tt.target, ans)
+		}
+	}
+}

10-week-algorithm-excercise-master/Week_01/283/move_zeros_test.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	tests := []struct {
+		nums   []int
+		target []int
+	}{
+		{[]int{1, 2, 0}, []int{1, 2, 0}},
+		{[]int{1, 0, 0}, []int{1, 0, 0}},
+		{[]int{1, 0, 0, 2, 0}, []int{1, 2, 0, 0, 0}},
+	}
+
+	for _, tt := range tests {
+		if moveZeroes(tt.nums); !reflect.DeepEqual(tt.nums, tt.target) {
+			t.Fatalf("target: %v, nums: %v\n", tt.target, tt.nums)
+		}
+	}
+}

10-week-algorithm-excercise-master/Week_01/42/trapping_rain_water.go

@@ -0,0 +1,27 @@
+package main
+
+func trap(height []int) int {
+	stack := make([]int, 0)
+	res := 0
+
+	for i, h := range height {
+		for len(stack) > 0 && height[stack[len(stack)-1]] < h {
+			top := stack[len(stack)-1]
+			stack = stack[:len(stack)-1]
+			if len(stack) == 0 {
+				break
+			}
+			left := stack[len(stack)-1]
+			res += (i - left - 1) * (min(h, height[left]) - height[top])
+		}
+		stack = append(stack, i)
+	}
+	return res
+}
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}

10-week-algorithm-excercise-master/Week_01/README.md

@@ -0,0 +1,135 @@
+学习笔记
+
+
+|#|Title|Solutions|
+|---|---|------|
+|70|[climbing-stairs](https://leetcode-cn.com/problems/climbing-stairs) | 递推([Go](70/climbing_stairs.go),[Py](70/climbing_stairs.py))|
+|11|[container-with-most-water](https://leetcode-cn.com/problems/container-with-most-water) | 双指针([Go](11/container_with_most_water.go),[Py](11/container_with_most_water.py))|
+|283|[move-zeroes](https://leetcode-cn.com/problems/move-zeroes)| 统计0的个数([Go](283/move_zeros.go),[Py](283/move_zeros.py)), 快慢指针([Go](283/move_zeros.go))|
+|1|[two-sum](https://leetcode-cn.com/problems/two-sum)| 先排序后双指针夹逼([Go](1/two_sum.go)), 字典缓存差值的索引([Go](1/two_sum_2.go),[Py](1/two_sum.py))|
+|15|[3sum](https://leetcode-cn.com/problems/3sum)| 先排序后双指针夹逼([Go](15/3sum_2.go),[Py](15/3sum.py)), 字典缓存差值的索引([Go](15/3sum.go))|
+|206|[reverse-linked-list](https://leetcode-cn.com/problems/reverse-linked-list)| 迭代([Go](206/reverse_linked_list.go),[Py](206/reverse_linked_list.py)), 递归([Go](206/reverse_linked_list2.go),[Py](206/reverse_linked_list2.py))|
+|24|[swap-nodes-in-pairs](https://leetcode-cn.com/problems/swap-nodes-in-pairs)| 迭代([Go](24/swap_nodes_in_pairs2.go),[Py](24/swap_nodes_in_pairs2.py)), 递归([Go](24/swap_nodes_in_pairs.go),[Py](24/swap_nodes_in_pairs.py))|
+|21|[merge-two-sorted-lists](https://leetcode-cn.com/problems/merge-two-sorted-lists) | 迭代([Go](21/merge_two_sorted_lists.go), [Py](21/merge_two_sorted_lists.py)), 递归([Go](21/merge_two_sorted_lists2.go),[Py](21/merge_two_sorted_lists2.py))|
+|141|[linked-list-cycle](https://leetcode-cn.com/problems/linked-list-cycle) | 哈希([Go](141/linked_list_cycle.go), [Py](141/linked_list_cycle.py)), 快慢指针([Go](141/linked_list_cycle2.go),[Py](141/linked_list_cycle2.py)), 翻转链表([Go](141/linked_list_cycle3.go))|
+|142|[linked-list-cycle-ii](https://leetcode-cn.com/problems/linked-list-cycle-ii) | 快慢指针([Go](142/linked_list_cycle_ii.go), [Py](142/linked_list_cycle_ii.py))|
+|25|[reverse-nodes-in-k-group](https://leetcode-cn.com/problems/reverse-nodes-in-k-group) | 快慢指针([Go](25/reverse_nodes_in_k_group.go), [Py](25/reverse_nodes_in_k_group.py))|
+|20|[valid-parentheses](https://leetcode-cn.com/problems/valid-parentheses) | 栈([Go](20/valid_parentheses.go), [Py](20/valid_parentheses.py))|
+|155|[min-stack](https://leetcode-cn.com/problems/min-stack) | 双栈([Go](155/min_stack.go), [Py](155/min_stack.py))|
+|84|[largest-rectangle-in-histogram](https://leetcode-cn.com/problems/largest-rectangle-in-histogram) | 暴力法([Go](84/largest_rectangle_in_histogram.go)),暴力法优化([Go](84/largest_rectangle_in_histogram2.go)),单调栈([Go](84/largest_rectangle_in_histogram3.go), [Py](84/largest_rectangle_in_histogram3.py))|
+|239|[sliding-window-maximum](https://leetcode-cn.com/problems/sliding-window-maximum) | 单调递减队列([Go](239/sliding_window_maximum.go), [Py](239/sliding_window_maximum.py))|
+|641|[design-circular-deque](https://leetcode-cn.com/problems/design-circular-deque) | 双指针([Go](641/design_circular_deque.go)),双指针优化([Go](641/design_circular_deque2.go),[Py](641/design_circular_deque2.py))|
+|42|[trapping-rain-water](https://leetcode-cn.com/problems/trapping-rain-water) | 单调栈([Go](42/trapping_rain_water.go),[Py](42/trapping_rain_water.py))|
+|26|[remove-duplicates-from-sorted-array](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array) | 快慢指针([Go](26/remove_duplicates_from_sorted_array.go),[Py](26/remove_duplicates_from_sorted_array.py))|
+|189|[rotate-array](https://leetcode-cn.com/problems/rotate-array) | 暴力法([Go](189/rotate_array.go)), 三次翻转([Go](189/rotate_array2.go),[Py](189/rotate_array2.py))|
+|88|[merge-sorted-array](https://leetcode-cn.com/problems/merge-sorted-array) | 暴力法([Go](88/merge_sorted_array.go)), 双指针从后向前([Go](88/merge_sorted_array2.go),[Py](88/merge_sorted_array2.py))|
+
+
+
+## 题解
+
+### 11. Container With Most Water
+
+1. 暴力法：两层for循环
+2. 双指针：缩减搜索空间
+   对于i,j(i < j),如果h[i] <= h[j],那么任意的j1(i < j1 < j),必定会有h[i] * (j1 -i) < h[i] * (j-i)
+   
+   
+### 283. move-zeroes
+
+1. 统计0的个数，遇到非0时 nums[i-count] = nums[i] 
+2. 慢指针指向非0元素
+
+### 1. two-sum
+
+计算差值是否在字典里，如果是则已找到，否则将当前值存入字典
+
+### 15. 3sum
+
+先排序，然后快慢指指针夹逼，另外要注意去重
+
+
+### 206. reverse linked list
+
+1. 迭代法：使用一个指正指向最新的head
+2. 递归法：比较难以理解，`head.next.next = head; head.next = None`
+
+### 24. swap-nodes-in-pairs
+
+1. 迭代法：构造一个dummy node 当前置节点
+2. 递归法
+
+### 21. merge-two-sorted-lists
+
+1. 迭代法: 构造一个dummy node 当前置节点
+2. 递归法
+
+
+### 141. linked-list-cycle 
+
+1. 哈希表法: 用哈希表记录是否访问过
+2. 双指针法: 慢指针一次走一步，快指针一次走两步，如果没环，快指针会先指向nil
+3. 翻转链表法: 每走一步，将Next之前前置节点，如果有环，会重新回到head节点
+
+### 142. linked-list-cycle-ii 
+
+快慢指针法： 
+  - 假设环入口长度为a,环长度为b;则走a+ n * b步时在环入口处
+  - 第一次相遇时慢指针走的不步数s=nb(f == 2 * s == s + nb);
+  - 慢指指针再走a步即可到达环入口，让快指针按步长为1从head和slow同步移动，则再次相遇时即走了a步
+  
+  
+### 25. reverse-nodes-in-k-group
+
+快慢指针法：
+  - 快指针先试探能否走k步
+  - 若能依次翻转
+  - 从快指针的next继续下一轮
+
+
+### 20. valid-parentheses
+
+哈希表存映射，栈存左括号
+
+### 155. min stack
+
+双栈法：给最小值也建个栈
+
+### 84. largest-rectangle-in-histogram
+
+1. 暴力法: 以每个bar为高度基准，找到左右边界
+2. 暴力法优化: 左边界在height[i] <= height[i-1]时 bounder[i] = bounder[i-1],右边界同理
+3. 单调栈: 栈存每个bar的索引，如果新的bar height < heights[stack[-1]]时需要出栈
+
+
+### 239. sliding-window-maximum
+队列法：
+  - 移除旧窗口的元素
+  - 移除当前窗口比新元素小的
+  - 新元素入队
+  - 更新最大窗口集
+  
+### 641. design-circular-dequeue
+
+1. 双指针：建立大小为k的数据，头尾指针都指向当前插入数据的位置，并用len记录当前长度以判断是否空或满
+2. 双指针优化: 为了避免头尾指针在空队列时候的耦合，让头指针指向头元素
+
+### 42. trapping rain water
+
+单调栈: 栈存每个bar的索引，如果新的bar height > heights[stack[-1]]时需要出栈
+
+
+### 26. remove-duplicates-from-sorted-array
+
+快慢指针: 快指针遍历，慢指针记录当前最新不重复的数的位置，关键是如何写的优雅
+
+
+### 189. rotate-array
+
+1. 暴力法: 每次移动最后一个元素到队首，移动k次
+2. 三次翻转法: 先全部翻转，再翻转[0,k-1], [k, len(nums)-1] 
+
+### 88. merge-sorted-array
+
+1. 暴力法: 逐个加入nums2, 插入时整体copy nums1后移
+2. 双指针法:从后向前比较num1和nums2