Add files using upload-large-folder tool

-QuQ--master/baseClass/Circuit.py

@@ -0,0 +1,1063 @@
+import sys
+import os
+import psutil
+sys.path.append('../tools/')
+import interactCfg
+import helperFunction
+import datetime
+import random
+from Bit import Bit
+from Qubit import *
+from Error import *
+from IBMQX import *
+#from Gate import *
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from mpl_toolkits.axes_grid.anchored_artists import AnchoredText
+import csv
+import re
+
+#the circuit.py will use this one 
+styleDic = {
+	"I":[" I ","C5"],
+	"X":["X","C0"],
+	"Y":["Y","C1"],
+	"Z":["Z","C1"],
+	"H":["H","C2"],
+	"S":["S","C8"],
+	"T":["T","C4"],
+	#"CNOT":["+","C0"],
+	"Td":["Td","C6"],
+	"Sd":["Sd","C7"],
+	"M":["M","C3"],
+	"qif":["qif","C3"],
+	"Rz":["Rz","C5"],
+	"Ry":["Ry","C5"],
+	"Rx":["Rx","C5"]
+	#"Toffoli":["+","C0"],
+	#multi-controlled gate
+}
+
+
+ResLocation = "../results/"
+
+#the data-type is the elementary unit of executing and export
+class Circuit:
+	#mark the environment: we can execute the code when there is only one circuit in the environment
+	currentIDList = []
+	instance = None
+
+	#the parameter "withOriginalData" is True, then record the componone elements of MCU
+	#instead of the whole gateName. And in this mode, it will figure out more detailed data
+	def __init__(self,withOriginalData = False,experimentName=None):
+		self.beginMemory = 0
+		self.endMemory = 0
+		self.beginTime = datetime.datetime.now()
+		self.endTime = 0
+		if experimentName == None:
+			dt = self.beginTime
+			experimentName = "EXP" + str(dt.date()) + '-' + str(dt.strftime('%X')).replace(':','.')
+		self.name = experimentName
+		#use this value to uniquely identify
+		self.ids = id(self)
+
+		folderName = ResLocation+self.name
+		#create a new folder to save the experiment
+		helperFunction.createFolder(folderName)
+
+		self.urls = folderName
+		#each qubit stands for a individual dimension
+		#see /doc/Class-relation.doc for details
+		self.qubitExecuteList = {}
+		self.qubitNum = 0
+		Circuit.currentIDList.append(self.ids)
+		Circuit.instance = self
+		#put all the qubit which need measurement in this list
+		self.measureList = []
+		#record the execute mode of the current instance
+		self.mode = interactCfg.readCfgEM()
+
+		if withOriginalData:
+			self.withOD = True
+		else:
+			self.withOD = False
+
+		#print information and decide whether execute IBMQX
+		self.ibm = False#whether execute experiments on IBM platform
+		self.__printPreMsg()
+
+		if self.withOD:
+			self.qubitNumOD = 0
+			self.qubitExecuteListOD = {}	
+		#the if statement of QASM will be stored in this dict so that the statement won't be repeated
+		self.IFList = []	
+		self.IFDic = {}
+		#update the value
+		self.beginMemory = psutil.Process(os.getpid()).memory_info().rss
+		self.beginTime = datetime.datetime.now()
+
+
+	#the destory function
+	def __del__(self):
+		ids = id(self)
+		if ids in Circuit.currentIDList:
+			Circuit.currentIDList.remove(id(self))
+		else:
+			return
+
+	#check the environment: whether the current circuit is equal to this instance 
+	def checkEnvironment(self):
+		#if there is ErrorMsg.txt in the folder, then exit <QuQ>
+		#it means that there is exception in With block and we should exit the program
+		if os.path.exists(self.urls + "/errorMsg.txt"):
+			#True
+			sys.exit(1)
+
+		circuitNum = len(Circuit.currentIDList)
+		if self.qubitNum != len(self.qubitExecuteList):
+			return False
+		#there only can be one instance and the id of this instance must be equal with self.ids
+		if circuitNum == 1 and Circuit.currentIDList[0] == self.ids:
+			return True
+		try:
+			strs = "There are " + str(len(Circuit.currentIDList)) + " Circuit instance, please check your code"
+			raise EnvironmentError(strs)
+		except EnvironmentError as ee:
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg(ee.value,funName,line)
+
+	#figure out the number of the auxiliary qubits and the actual qubits
+	def __countACandAX(self):
+		if self.withOD:
+			er = self.qubitExecuteListOD
+		else:
+			er = self.qubitExecuteList
+		AX = 0
+		AC = 0
+		for q in er:
+			if q.tag == "AX":
+				AX += 1
+			else:
+				AC += 1
+		return [AX,AC]
+
+	#if the statement is Qif or Mif, then execute the method
+	#"content" stands for the executive record of this qubit 
+	#"gate" stands for the gate name
+	#"m" stands for the m-th record in content
+	#"qubits" stands for the string consisted of q.ids and "," as separator
+	#"code" stands for the QASM list
+	#if the function return False, then the gate isn't the Mif or Qif
+	def __generateIF(self,content,gate,m,qubits,code):
+		#judge whether the statement is the "if-statement"
+		if re.search(r'^(M\d-)+.+$',gate) != None:
+			#Mif or Qif
+
+			MgateList = re.findall(r'(M\d)',gate)
+			#construct the control guard
+			guard = ""
+			for j in range(0,len(MgateList)):
+				guard += "M[" + qubits[j] + "]=" + MgateList[j].split("M")[1]
+				if j != len(MgateList)-1:
+					guard += " && "
+
+			#judge whether the qubit is the measured qubit 
+			#or qubits are required to act quantum gate
+			tag = False
+			for k in range(0,m):
+				if re.search(r'^M \d+$',content[k]) != None:
+					#the measured qubit
+					if guard in self.IFList:
+						pass
+					else:
+						#construct the if-statement
+						ifStr = "if("
+						for j in range(0,len(MgateList)):
+							tmpStr = "c[" + qubits[j] + "]=="
+							tmpStr += MgateList[j][1]
+							if j != len(MgateList)-1:
+								tmpStr += " && "
+							ifStr += tmpStr
+						ifStr += ")"
+						code.append(ifStr)
+						self.IFList.append(guard)
+					tag = True
+					break
+
+			#qubits are required to act quantum gate
+			if tag == False:
+				#store the statement in self.IFStatement and write them to QASM.txt in the end of the method
+				statement = ""
+				gl = gate.split("-")
+				if len(gl) != len(qubits):
+					try:
+						raise CodeError("The gate number isn't same with the qubit number!")
+					except CodeError as ce:
+						info = helperFunction.get_curl_info()
+						funName = info[0]
+						line = info[1]
+						interactCfg.writeErrorMsg(ce,funName,line)
+
+				ifGate = ""
+				ifQ = ""
+				for i in range(0,len(gl)):
+					if re.search(r'^M\d$',gl[i]) != None:
+						pass
+					else:
+						ifGate += gl[i]
+						ifQ += "q["+qubits[i]+"]"
+						if i != len(gl)-1:
+							ifQ += ","
+				if re.search(r'^c\dX\d$',ifGate) != None:
+					ifGate = "CNOT"
+				else:
+					ifGate = ifGate[0:len(ifGate)-1]
+
+				#store the statement
+				reStr = ifGate + " " + ifQ + ";"
+				if guard not in self.IFDic:
+					self.IFDic[guard] = []
+				if reStr in self.IFDic[guard]:
+					pass
+				else:
+					self.IFDic[guard].append(reStr)
+			return True
+		return False
+
+	#write the statement to QASM.txt 
+	#"statement" stands for the QASM list
+	#and append the if statement according to self.IFDic and self.IFList
+	def __printCode(self,fileName,statement):
+		#append content in the original txt file
+		try:
+			code = open(fileName,"w")
+			for c in statement:
+				codeStr = ""
+				#the if statement
+				if re.search(r'if(.+)',c) != None:
+					#the format of c is "if(c[0]==1 && c[1]==0)"
+					codeStr = c + "{\n"			
+					guard = re.findall(r'\((.*?)\)',c)[0]
+					#the format of key is "M[0]=1 && M[1]=0"
+					guard = guard.replace("c","M").replace("==","=")
+					for s in self.IFDic[guard]:
+						#append the indentation
+						codeStr += "  "+ s + "\n"
+					codeStr += "}\n"
+				else:
+					codeStr = c
+				code.write(codeStr)
+			code.close()
+		except IOError:
+			info = helperFunction.get_curl_info()
+			interactCfg.writeErrorMsg("Can't write the QASM code to " + fileName + "!",info[0],info[1])
+
+		#restore the value of the IFDic and IFList
+		self.IFList = []
+		self.IFDic = {}
+
+
+	#draw the circuit according to the qubitExecuteList
+	#the parameter "typeQN" is a list [the number of AX qubits, the number of AC qubits]
+	def __exportCircuit(self,er,typeQN,fileLocation):
+		global alertMsg
+		if self.checkEnvironment():
+			if alertMsg:
+				print("begin drawing the circuit...")
+			#set the canvas
+			Fig = plt.figure('circuit',figsize=(12,6))                      
+			#set the axis off
+			plt.axis('off')
+			#devide the canvas into 1row 1col, and our pic will be draw on the first place(from up to down, from left to right)
+			Ax = Fig.add_subplot(111)
+			qubitNum = typeQN[1]
+			############################draw the line according to self.qubitNum###########################
+			partition = 100 // qubitNum
+			for i in range(0,qubitNum):
+				X = range(0,100)
+				Y = [i*partition] * 100
+				Ax.plot(X,Y,'#000000')
+			############################the line has been completed########################################
+			
+			############################draw the gate according to self.qubitExecuteList###################
+			j = 0
+			maxLength = 0
+			q_keys = []
+			for qe in er.keys():
+				#the auxiliary qubit won't be in the q_keys
+				if qe.tag == "AX":
+					#the qubit is the auxiliary qubit
+					pass
+				else:
+					maxLength = max(maxLength,len(er[qe]))
+					q_keys.append(qe)
+			quickSortQubit(q_keys,0,len(q_keys)-1)
+			for q in q_keys:
+				if q.tag == "AX":
+					#the qubit is an auxiliary qubit and need NOT be drawed
+					continue
+				if maxLength < 20:
+					factor = 1
+				else:
+					factor = maxLength / 20
+				#label the ids
+				label = 'Q' + str(q.ids)
+				Ax.annotate(label,xy=(0, j*partition), xytext=(-4, j*partition-0.5),size=12,)
+				#draw the gate
+				executeList = er[q]
+				x_position = 4 / factor
+				for item in executeList:
+					gate = item.split(" ")[0]
+					style = "square"
+					#the gate 'NULL' was stored to the list is to occupy the postion so that we can draw the circuit easily
+					if gate == 'NULL':
+						x_position += 5 / factor
+						continue
+
+					#remove the parameter of the gate
+					if re.search(r'^R\w{1}\(.+\)$',gate) != None:
+						gate = gate.split("(")[0]
+
+					if gate in styleDic:
+						gateName = styleDic[gate][0]
+						gateColor = styleDic[gate][1]
+						ann = Ax.annotate(gateName,
+							xy=(1, 20), xycoords='data',
+							xytext=(x_position, j*partition), textcoords='data',color='w',
+							size=12/factor, va="center", ha="center",
+							bbox=dict(boxstyle=style, fc=gateColor,pad=0.3,ec=gateColor),
+							)
+					#it means that the gate is a MCU
+					else:
+						if gate[-1] == '0' or gate[-1] == '1':
+							#the gate is the Mif or Qif
+							gate = gate[0:len(gate)-1]
+						if gate == "Toffoli":
+							gate = "c1-c1-X"
+						if gate == "CNOT":
+							gate = "c1-X"
+						singleGateList = gate.split("-")
+						U = singleGateList[-1]
+
+						#remove the parameter of the gate
+						if re.search(r'^R\w{1}\(.+\)$',U) != None:
+							U = U.split("(")[0]
+
+						try:
+							if U == "X":
+								if re.search(r'M\d',gate) != None and singleGateList[len(singleGateList)-2] != "c1":
+									gateName = styleDic[U][0]
+								else:
+									gateName = "+"
+							else:
+								gateName = styleDic[U][0]
+							gateColor = styleDic[U][1]
+						except KeyError as ke:
+							info = helperFunction.get_curl_info()
+							funName = info[0]
+							line = info[1]
+							interactCfg.writeErrorMsg("Key: " + str(ke) + " is not in Dict:styleDic!",funName,line)
+						#wheter the current qubit is the control-qubit
+						qubitStrList = item.split(" ")[1].split(",") 
+						targetQubit = qubitStrList[len(qubitStrList) - 1]
+						controlQubit = qubitStrList[0:len(qubitStrList)-1]
+						#the index of the target qubit
+						indexOfTarget = 0
+						#get the index of the target qubit
+						for tmp in q_keys:
+							if str(tmp.ids) != targetQubit:
+								indexOfTarget += 1
+							else:
+								break
+						
+						#draw a circle in the control qubit
+						if str(q.ids) in controlQubit:	
+							#print(indexOfTarget)
+							smaller = min(indexOfTarget,j)
+							bigger = max(indexOfTarget,j)
+							x1 = [x_position] * (bigger * partition - smaller * partition)
+							y1 = range(smaller * partition,bigger * partition)
+
+							#print(gate)
+							#draw the control-line
+							
+							#if the gate is Mif or Qif							
+							if re.search(r'^(M\d-)+.+$',gate) != None:
+								#judge whether the gate is Mif-CNOT or Qif-CNOT
+								if re.search(r'(c\d-){1}',gate) != None and str(q.ids) == controlQubit[-1]:
+									#the gate is CNOT then judge whether the qubit is the penult element
+									Ax.plot(x1,y1,gateColor)
+								else:
+									#gateColor = "black"
+									Ax.plot(x1,y1,gateColor,linestyle = ":")
+							else:	
+								Ax.plot(x1,y1,gateColor)
+							
+							indexOfCurrentQubit = controlQubit.index(str(q.ids))
+							#print(type(singleGateList[indexOfCurrentQubit][1:len(singleGateList[indexOfCurrentQubit])]))
+							if singleGateList[indexOfCurrentQubit][1:len(singleGateList[indexOfCurrentQubit])] == '0':
+								#the color of the inside
+								fc = "White"
+
+							else:
+								fc = gateColor
+							#the color of the frame
+							ec = gateColor
+							ann = Ax.annotate("1",
+                  				xy=(1, 20), xycoords='data',color=fc,
+                  				xytext=(x_position, j*partition), textcoords='data',
+                  				size=6/factor, va="center", ha="center",
+                  				bbox=dict(boxstyle="circle", fc=fc,pad=0.3,ec=ec),
+                  			)
+                  			#don't draw the CX
+						else:
+							if gateName == "+":
+								style = "circle"
+							ann = Ax.annotate(gateName,
+								xy=(1, 20), xycoords='data',
+								xytext=(x_position, j*partition), textcoords='data',color='w',
+								size=12/factor, va="center", ha="center",
+								bbox=dict(boxstyle=style, fc=gateColor,pad=0.3,ec=gateColor),
+								)
+					x_position += 5/factor							
+
+				j += 1
+			############################the gate has completed########################################
+			#plt.show()
+			#save the circuit
+			fileName = fileLocation + "circuit.jpg"
+			Fig.savefig(fileName)			
+			#print("the circuit has been stored in " + self.urls.split("..")[1]  + "/circuit.jpg")
+			if alertMsg:
+				print("the circuit has been drawn!\n")
+			return True
+		else:
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg("the circuit instance is wrong, please check your code",funName,line)
+
+	#translate the code of the current circuit to QASM, so that they can be executed on IBMQX
+	def __QASM(self,er,fileLocation):
+		global alertMsg
+		if alertMsg:
+			print("begin export the QASM code of the circuit...")
+		if self.checkEnvironment():
+			self.IFList = []
+			self.IFDic = {}
+			qubitNum = len(er.keys())
+			fileName = fileLocation + "QASM.txt"
+			code = []
+			#get the ids of the qubit
+			qubitList = []
+			for q in er.keys():
+				qubitList.append(q)
+			#get the max length of the circuit depth
+			maxGate = 0
+			for i in range(0,qubitNum):
+				if maxGate < len(er[qubitList[i]]):
+					maxGate = len(er[qubitList[i]])
+			for m in range(0,maxGate):
+				for n in range(0,qubitNum):
+					content = er[qubitList[n]]
+					#print(content)
+					length = len(content)
+					#if there is no element to be draw, skip the loop
+					if m > length-1:
+						continue
+					item = content[m]
+
+					qubits = item.split(" ")[1].split(",")
+					gate = item.split(" ")[0]
+					if gate == 'NULL':
+						continue
+					
+					if self.__generateIF(content,gate,m,qubits,code):
+						continue
+					else:
+						pass
+
+					#transform the format of the special case 
+					if gate == "Toffoli":
+						gate = "c1-c1-X"
+					elif gate == "CNOT":
+						gate = "c1-X"
+					else:
+						pass
+
+					#if the gate is MCU and the current qubit is the target, that is ,
+					#the current qubit isn't in the first postion, then don't export the gate
+					if re.search(r'^(c\d-)+.+$',gate) != None and str(qubitList[n].ids) != qubits[0]:
+						continue
+
+					#restore the format of the special case
+					if gate == "c1-c1-X":
+						gate = "Toffoli"
+					elif gate == "c1-X":
+						gate = "CNOT"
+					else:
+						pass
+
+					#print the line of QASM code to QASM.txt
+					tmpCode = gate + " "
+					if gate == "M":
+						if len(qubits) != 1:
+							try:
+								raise CodeError("Can't measure more than one qubit simultaneously")
+							except CodeError as ce:
+								info = helperFunction.get_curl_info()
+								funName = info[0]
+								line = info[1]
+								interactCfg.writeErrorMsg(ce,funName,line)
+						tmpCode += "q[" + qubits[0] + "] -> c[" + qubits[0] +"];"
+						tmpCode += "\n"
+						code.append(tmpCode)
+						continue
+					for i in range(0,len(qubits)):
+						tmpCode += "q[" + qubits[i] + "]"
+						if i != len(qubits)-1:
+							tmpCode += ","
+					tmpCode += ";"
+					tmpCode += "\n"		
+					code.append(tmpCode)			
+			#print("the code has been stored in " + self.urls.split("..")[1] + "/qasm.txt")
+			if alertMsg:
+				print("the QASM code has been exported!\n")
+			#write the Mif code or Qif code to QASM.txt
+			self.__printCode(fileName,code)
+
+			return True
+		else:
+			try:
+				raise EnvironmentError()
+			except EnvironmentError as ee:
+				info = helperFunction.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				interactCfg.writeErrorMsg(ee,funName,line)
+
+	#export the result of the measurement to charts
+	def __exportChart(self,result:list,prob:list,title:str):
+		print("begin exporting the result of measurements to charts...")
+		if self.checkEnvironment():
+			number = len(result)
+			#the dimen of the result must be same with the prob
+			if number != len(prob):
+				info = helperFunction.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				interactCfg.writeErrorMsg("the dimension of the measurement result is not equal, please check your code",funName,line)
+			###################################drawing the charts###################################
+			#set the canvas
+			Fig = plt.figure('chart',figsize=(12,12))
+			#plt.title("11")
+			#there are two sub-pictures in this picture
+			Ax = Fig.add_subplot(111)
+			Ax.set_title(title+ ':bar chart')
+			plt.grid(True)
+			#set the bar width
+			bar_width = 0.5
+			#set the position of the elements in x-axis
+			xticks = []
+			for i in range(0,number):
+				xticks.append(i + bar_width/2)
+			colors = []
+			#draw the line-chart
+			bars = Ax.bar(xticks, prob, width=bar_width, edgecolor='none')
+			Ax.set_ylabel('Prob')
+			Ax.set_xlabel('State')
+			#set the position of the x-label
+			Ax.set_xticks(xticks)
+			Ax.set_xticklabels(result)
+			#set the range of X-axis and y-axis
+			Ax.set_xlim([bar_width/2-0.5, number-bar_width/2])
+			Ax.set_ylim([0, 1])
+			#set the color to bar
+			for bar, color in zip(bars, colors):
+			    bar.set_color(color)
+			#write the probability on the top of each bar of the bat chart
+			for item in range(0,len(xticks)):
+				x_position = xticks[item]
+				y_position = prob[item]
+				if y_position < 0.1:
+					yPosition = y_position + 0.01
+				else:
+					yPosition = y_position - 0.03
+				plt.text(x_position,yPosition,'{:.3f}'.format(y_position),ha='center',va='bottom')
+			#save the picture
+			#plt.show()
+			Fig.savefig(self.urls + "/chart.jpg")			
+			#print("the circuit has been stored in " + self.urls.split("..")[1]  + "/chart.jpg")
+			print("the chart of the circuit has been exported!\n")
+			return True
+		else:
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg("the instance is wrong, please check your code!",funName,line)	
+
+	#the aim of the function is to order the idList and get the right state according to the order 
+	#of the ids
+	def __orderTheId(self,idList:list,order:list):
+		for i in range(1,len(idList)):
+			tmp = i-1
+			while tmp >=0:
+				if idList[tmp] > idList[i]:
+					idList[i],idList[tmp] = idList[tmp],idList[i]
+					order[i],order[tmp] = order[tmp],order[i]
+					i = tmp
+				tmp -= 1
+		return order
+
+	#execute measurement on the qubits
+	def execute(self,executeTimes:int):
+		#print(self.qubitExecuteList)
+		if self.checkEnvironment():
+			probList = []
+			stateList = []
+			qubitList = self.measureList.copy()
+			hasMeasure = []
+			#record the order of the qubit
+			idList = []
+			gateNum = self.__countGate()
+			totalQubitNum = self.qubitNum
+			executeRecord = self.qubitExecuteList.copy()
+			if self.withOD:
+				executeRecordOD = self.qubitExecuteListOD.copy()
+
+			#figure out the AC qubits number and the AX qubits number
+			typeQN = self.__countACandAX()
+
+			print("QuanSim is measuring the qubit, please wait for a while...")
+			#execute the measurement of the qubits
+			for qubit in qubitList:
+				if qubit in hasMeasure:
+					continue
+				hasMeasure.append(qubit)
+				#judge whether act qif on this qubit; if so, pass this loop and continue the next one.
+				hasQIF = False
+				if hasQIF:
+					continue
+				qs = qubit.entanglement
+				#the current qubit is not in entanglement
+				if qs == None:
+					result = qubit.decideProb()
+					#the result is two-dimen, result[0] is the list of probablity, and result[1] is the corresponding state
+					probList.append(result[0])
+					stateList.append(result[1])
+					idList.append(qubit.ids)
+					self.__removeQubit([qubit])
+					qubit.delete()
+					continue
+				#the current qubit is in entanglement
+				#find the other qubit ,which is also in qs.qubitList and self.measureList
+				qubitGroup = []
+				for item in qs.qubitList:
+					if item in qubitList:
+						#item will be measured with the current qubit simultaneously
+						#so delete the element from the list to avoid repeating measurement
+						#qubitList.remove(item)
+						if item not in hasMeasure:
+							hasMeasure.append(item)
+						hasQIF = False
+						#print(executeRecord[item])
+						if hasQIF:
+							pass
+						else:
+							#print(executeRecord[item])
+							qubitGroup.append(item)
+							idList.append(item.ids)
+				result = qubit.decideProb(qubitGroup)
+				#delete the measured qubit from its entangle state
+				self.__removeQubit(qubitGroup)
+				qs.deleteItem(qubitGroup)
+				#there is no element in qs.qubitList
+				if len(qs.qubitList) == 0:
+					del qs
+				#there is only one element in qs.qubitList, then there is no need to keep qs
+				elif len(qs.qubitList) == 1:
+					qs.qubitList[0].entanglement = None
+					del qs
+				else:
+					pass
+
+				probList.append(result[0])
+				stateList.append(result[1])
+			#use the prbList to compute the end prob
+			#and the state to compute the end state
+			#e.g., prob = [0.5,0.5],state = ['11','00']
+			#the state is 0.7|11> + 0.7|00>
+			if len(probList) == 0 and len(stateList) == 0:
+				#get the end time of the circuit
+				self.endTime = datetime.datetime.now()
+				self.endMemory = psutil.Process(os.getpid()).memory_info().rss
+				#there is no qubit has been measured
+				return False
+			#print(stateList)
+			prob = probList[0]
+			state = stateList[0]
+			caseNum = 2 ** len(probList)
+			for i in range(1,len(probList)):
+				tmpProb = []
+				tmpState = []
+				for j in range(0,len(prob)):
+					for k in range(0,len(probList[i])):
+						tmpProb.append(prob[j] * probList[i][k])
+						tmpState.append(state[j] + stateList[i][k])
+				prob = tmpProb
+				state = tmpState
+
+			#delete the zero probility and it corresponding state, and get the result
+			probResult = []
+			stateResult = []
+			orderList = [i for i in range(0,len(idList))]
+			order = self.__orderTheId(idList,orderList)
+			for index in range(0,len(prob)):
+				#if the prob is in [-0.00001,0.00001], then we regard it as 0
+				if prob[index] > -0.00001 and prob[index] < 0.00001 :
+					continue
+				#set the order of qubits by ASC
+				newStateStr = ""
+				for o in order:
+					newStateStr += state[index][int(o)]
+				probResult.append(prob[index])
+				stateResult.append(newStateStr)
+			
+			#get the actual measure results according to the probResult
+			timesList = self.__randomM(executeTimes,probResult)
+			endProbResult = []
+			for p in range(0,len(probResult)):
+				endProbResult.append(timesList[p] / executeTimes)
+
+			#get the end time of the circuit
+			self.endTime = datetime.datetime.now()
+			self.endMemory = psutil.Process(os.getpid()).memory_info().rss
+			#get the end sequence of the ids of the qubit
+			title = ""
+			for qid in idList:
+				title += "q"
+				title += str(qid)
+
+			self.__printExecuteMsg(stateResult,endProbResult,gateNum,typeQN) 
+			############################exporting############################
+			self.__exportChart(stateResult,endProbResult,title)
+			self.__exportOriData(stateResult,timesList)
+			############################exporting############################
+
+			############################get the QASM and circuit######################################
+			global alertMsg
+			#use this global parameter to guarantee the alert message of getting 
+			#QASM.txt and circuit.jpg will be printed for only once
+			alertMsg = True
+			#all the whole gate information are stored in "expName/Logical-Level/"
+			fileLocation = self.urls+"/Logical-Level/"
+			#create the folder
+			helperFunction.createFolder(fileLocation)
+
+			self.__exportCircuit(executeRecord,typeQN,fileLocation)
+			self.__QASM(executeRecord,fileLocation)
+			alertMsg = False
+
+			#if user want to get the original data, then call the following methods
+			if self.withOD:
+				#in this case, we should give the folder name of the QASM.txt and circuit.jpg
+				#all the actually executive information are stored in "expName/Physical-Level/"
+				fileLocation = self.urls+"/Physical-Level/"
+				#create the folder
+				helperFunction.createFolder(fileLocation)
+
+				#self.__exportCircuit(executeRecordOD,typeQN,fileLocation)
+				self.__QASM(executeRecordOD,fileLocation)
+			############################get the QASM and circuit######################################
+			if self.ibm:
+				ibm = IBMQX()
+				# ibm.test()
+				ibm.executeQASM()
+			#call the destory function to clean the current instance
+			self.__del__()
+		else:
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg("The instance is wrong, please check your code!",funName,line)
+
+
+	#remove qubitList from this instance; only the qubit has been measured, it can be removed from this instance
+	def __removeQubit(self,ql:list):
+		for q in ql:
+			try:
+				if q in self.qubitExecuteList:
+					self.qubitNum -= 1
+					del self.qubitExecuteList[q]
+					self.measureList.remove(q)
+			except KeyError:
+				info = helperFunction.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				interactCfg.writeErrorMsg("KeyError: Q"+ str(q.ids) + " is not in this Circuit instance!",funName,line)
+
+	#split the unit interval into len(probList) parts, and the length of iTH interval is probList[i]
+	#product random number for executeTimes, then count the times of number in each interval 
+	def __randomM(self,executeTimes,probList):
+		timesList = [0] * len(probList)
+		#product the prob interval
+		interval = []
+		sums = 0
+		for index in range(0,len(probList)):
+			try:
+				if index == 0:
+					interval.append([0,probList[0]])
+				else:
+					interval.append([sums,sums+probList[index]])
+				sums += probList[index]
+			except KeyError as ke:
+				info = helperFunction.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				interactCfg.writeErrorMsg("key " + str(ke) + " doesn't exist!",funName,line)
+		#the error rate is lower then 0.001
+		if abs(1 - sums) > 0.001:
+			try:
+				raise NotNormal()
+			except NotNormal as nn:
+				info = helperFunction.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				interactCfg.writeErrorMsg(nn,funName,line)
+		#product random number for executeTimes
+		for i in range(0,executeTimes):
+			#judge the number in which interval
+			randomNumber = random.uniform(0,1)
+			#the demin of timesList and interval must be same
+			for j in range(0,len(interval)):
+				if randomNumber >= interval[j][0] and randomNumber < interval[j][1]:
+					timesList[j] = timesList[j] + 1
+		return timesList
+
+	#count the numbers of the gate
+	def __countGate(self):
+		#the measured qubits of the circuit
+		Measure = self.measureList.copy()
+
+		#count the gate number of the circuit
+		Single = 0    #stands for the single-qubit gate without compiled
+		Multi = 0.0     #stands for the multi-qubit gate without compiled, such as c1-c1-c1-c1-X
+		
+		#only if circuit.withOD == True, then compute the following two parameter
+		SingleOD = 0  #stands for the single gate after compiled
+		DoubleOD = 0  #stands for the CNOT gate after compiled
+
+		try:
+			from baseGate import allowGate
+		except ImportError:
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg("Can't import the Dict: allowGate in baseGate.py!",funName,line)
+		for key in self.qubitExecuteList:
+			for operator in self.qubitExecuteList[key]:
+				gate = operator.split(" ")[0]
+				#the gate NULL is to occupy the position
+				if gate == "NULL" or gate == "M":
+					continue
+				#the format of the gate is M1-M0-X...
+				if re.search(r'^(M\d-)+.+$',gate) != None:
+					if gate[-1] == "0":
+						#the gate isn't executed
+						continue
+					else:
+						if "CNOT" in gate:
+							Multi += 1
+						else:
+							Single += 1
+				#the format of the gate is c1-c0-X...
+				if re.search(r'^(c\d-)+.+$',gate) != None:
+					#if the gate is c1-c1-X, then actually we count the gate for 3 times
+					n = len(re.findall("-",gate)) + 1
+					Multi += 1/n
+				else:
+					Single += 1
+		if self.withOD:
+			for key in self.qubitExecuteListOD:
+				for operator in self.qubitExecuteListOD[key]:
+					gate = operator.split(" ")[0]
+					#the format of the gate is M1-M0-X...
+					if re.search(r'^(M\d-)+.+$',gate) != None:
+						if gate[-1] == "0":
+							#the gate isn't executed
+							continue
+						else:
+							if "CNOT" in gate:
+								DoubleOD += 1
+							else:
+								SingleOD += 1
+						continue
+					#the gate NULL is to occupy the position
+					if gate == "NULL" or gate == "M":
+						continue
+					elif gate == "CNOT":
+						DoubleOD += 1
+					elif gate in allowGate or re.search(r'^R\w{1}\(.+\)$',gate) != None:
+						SingleOD += 1
+					else:
+						try:
+							raise GateNameError("Gate:" + gate +" hasn't defined in allowGate!")
+						except GateNameError as gne:
+							info = helperFunction.get_curl_info()
+							interactCfg.writeErrorMsg(gne,info[0],info[1])
+			#the number of the CNOT count twice when stored in the list, so we should divide 2
+			#and the number must be even number
+			if DoubleOD & 1 != 0:
+				#the number is odd
+				try:
+					raise CodeError("We count the CNOT gate twice in <QuQ>, and the number of CNOT \
+						must be an even number. However, we got an odd number! Please check your code!")
+				except CodeError as ce:
+					info = helperFunction.get_curl_info()
+					interactCfg.writeErrorMsg(ce,info[0],info[1])
+			DoubleOD = DoubleOD // 2 
+		num = {'measureQubit':Measure,'single-qubit':Single,'multi-qubit':int(Multi+0.5),\
+		'single-qubitOD':SingleOD,'double-qubit':DoubleOD}
+		return num
+
+	#print the executive message to cmd 
+	def __printExecuteMsg(self,stateList,probList,gateNum,typeQN):
+		#the total execute time, the unit of the time is second
+		totalTime = (self.endTime - self.beginTime).total_seconds()
+		#the total memory, the unit of the memory is MB
+		totalMemory = ((self.endMemory - self.beginMemory) / 1024) / 1024
+		if self.mode == 'theory':
+			singleError = 'None'
+			doubleError = 'None'
+		elif self.mode == 'simulator':
+			singleError = 0
+			for q in gateNum['measureQubit']:
+				error = interactCfg.readCfgGE('single',q.ids)
+				singleError += error
+			singleError = "%.4f%%"%(singleError / float(len(gateNum['measureQubit'])) * 100)
+			doubleError = "%.4f%%"%(interactCfg.readCfgGE('multi') * 100)
+		else:
+			try:
+				raise ExecuteModeError()
+			except ExecuteModeError as em:
+				info = helperFunction.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				interactCfg.writeErrorMsg(em,funName,line)
+
+		msg = "total qubits: "+ str(typeQN[0]+typeQN[1]) 
+		if self.withOD:
+			msg += " (Auxiliary: " + str(typeQN[0]) + ")"
+		msg += "\n"
+		
+		msg += "the number of the measured qubits: "+ str(len(gateNum['measureQubit'])) + "\n"
+		
+		msg += "the number of single-qubit gate: " + str(gateNum['single-qubit']) 
+		if self.withOD:
+			msg += " (Actually execute " + str(gateNum['single-qubitOD']) + " Single Gates)"
+		msg += "\n"
+
+		msg += "the number of multi-qubit gate: " + str(gateNum['multi-qubit'])
+		if self.withOD:
+			msg += " (Actually execute " + str(gateNum['double-qubit']) + " CNOTs)"
+		msg += "\n"
+
+		msg += "executive Mode: " + self.mode + "\n"
+		msg += "single-qubit error: " + singleError + " (AVG)\n"
+		msg += "double-qubit error: " + doubleError + " (AVG)\n"	
+		msg += "result: " + "\n"
+		for i in range(0,len(stateList)):
+			msg += "        |" + str(stateList[i]) + ">----" + "%.2f%%"%(probList[i] * 100) + "\n"
+		msg += "executive time: " + str(totalTime) + "s\n"
+		msg += "memory: " + "{:.4f}".format(totalMemory) + "MB\n\n"
+		msg += " "*27
+		msg += "the circuit has been executed!!\n"
+		msg += "-"*80 + '\n'
+		#write the message to cmd and the file named "result.log"
+		print(msg)
+		try:
+			file = open(self.urls + "/result.log","a")
+			file.write("\n")
+			file.write(msg)
+			file.close()
+		except IOError as io:
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg(io,funName,line)
+		return True
+
+	def __printPreMsg(self):
+		msg = "\n"
+		msg += "-"*80 + "\n"
+		msg += " "*27
+		msg += "begin executing the circuit...\n\n"
+		msg += "the experiment: " + self.name
+		#write the message to cmd and the file named "result.log"
+		print(msg)
+
+		print("\r")
+		self.__callIBM()
+		print("\r")
+		
+		try:
+			file = open(self.urls + "/result.log","a")
+			if self.ibm:
+				boolStr = "True"
+			else:
+				boolStr = "False"
+			file.write("Will the experiment be executed on IBMQX?    "+ boolStr + "\n")
+			file.write(msg)
+			file.close()
+		except IOError as io:
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg(io,funName,line)
+		return True			
+
+	#export the original data of the experiment to the originalData.csv
+	def __exportOriData(self,stateList:list,timesList:list):
+		print("begin exporting original date to csv...")
+		if len(stateList) != len(timesList):
+			info = helperFunction.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			interactCfg.writeErrorMsg("there are something wrong with you code!",funName,line)
+		csvFile = open(self.urls + "/originalData.csv","w")
+		writer = csv.writer(csvFile)
+		writer.writerow(['state', 'times'])
+		data = []
+		for i in range(0,len(stateList)):
+			tuples = ('|' + str(stateList[i]) + '>',str(timesList[i]))
+			data.append(tuples)
+		writer.writerows(data)
+		csvFile.close()
+		#print("the csv file has been stored in " + self.urls.split("..")[1]  + "/originalData.csv")
+		print("the original data has been exported!\n")
+		return True
+
+	#run the experiment on IBMQX by class: IBMQX
+	def __callIBM(self):
+		boolP = True
+		#post the qasm code to ibm API according to the users's input:Y/N
+		while boolP:
+			boolP = False
+			ibmBool = input("Do you want to execute your experiment on IBMQX? [Y/N]")
+			if ibmBool == 'Y' or ibmBool == 'y':
+				#yes
+				self.ibm = True
+				if self.withOD == False:
+					#the Open-QASM is relied on the physical-level qasm.txt
+					self.withOD = True
+			elif ibmBool == 'N' or ibmBool == 'n':
+				#no
+				pass
+			else:
+				boolP = True
+				print("Invalid input: Only 'Y' or 'N' is allowed!")
+
+		

-QuQ--master/baseClass/Error.py

@@ -0,0 +1,121 @@
+#!/usr/bin/python3
+#the custom exceptions are written in this file
+import sys
+sys.path.append('../tools/')
+from interactCfg import *
+from helperFunction import *
+
+#check the environment: whether the current circuit is equal to this instance 
+def checkEnvironment():
+	from Circuit import Circuit
+	circuitNum = len(Circuit.currentIDList)
+	#there only can be one instance and the id of this instance must be equal with self.ids
+	if circuitNum == 1:
+		if Circuit.currentIDList[0] == Circuit.instance.ids:
+			return Circuit.instance
+	try:
+		strs = "there are " + str(len(Circuit.currentIDList)) + " Circuit instance, please check your code"
+		raise EnvironmentError(strs)
+	except EnvironmentError as ee:
+		info = get_curl_info()
+		funName = info[0]
+		line = info[1]
+		writeErrorMsg(ee,funName,line)
+		
+
+class NoCloning(Exception):
+	def __init__(self,msg = None):
+		if msg == None:
+			self.value = ""
+		else:
+			self.value = msg
+	def __str__(self):
+		result = "Error Type: NoCloning\r\n"
+		result += "Error Message: " + self.value 
+		return result
+
+#the function named 'checkEnvironment' will cause this error
+#there only can be one Circuit instance in runtime, more than one or none instance will cause this error 
+class EnvironmentError(Exception):
+	def __init__(self,msg = None):
+		if msg == None:
+			self.value = "There are zero or more than one Circuit instance!"
+		else:
+			self.value = msg
+	def __str__(self):
+		result = "Error Type: EnvironmentError\r\n"
+		result += "Error Message: " + self.value
+		return result		
+
+#there are something wrong with the code
+class CodeError(Exception):
+	def __init__(self,msg=None):
+		if msg == None:
+			self.value = "There is something wrong with the QASM code!"
+		else:
+			self.value = msg
+	def __str__(self):
+		result = "Error Type: CodeError\r\n"
+		result += "Error Message: " + self.value
+		return result	
+
+#the gate name is not defined in this platfrom
+class GateNameError(Exception):
+	def __init__(self,msg=None):
+		if msg == None:
+			self.value = "There is gates which have not defined in this platfrom!"
+		else:
+			self.value = msg
+	def __str__(self):
+		result = "Error Type: GateNameError\r\n"
+		result += "Error Message: " + self.value
+		return result	
+
+
+#calling the IBMQX api lead to error
+class IBMError(Exception):
+	def __init__(self,msg = None):
+		if msg == None:
+			self.value = "There is something wrong when calling the API of IBMQX!"
+		else:
+			self.value = msg 
+	def __str__(self):
+		result = "Error Type: IBMError\r\n"
+		result += "Error Message: " + self.value
+		return result 
+
+#the execute mode must be either theory or simulator, but we get another value
+class ExecuteModeError(Exception):
+	def __init__(self,msg = None):
+		if msg == None:
+			self.value = "executeMode must be either 'theory' or 'simulator', but we get another mode"
+		else:
+			self.value = msg
+	def __str__(self):
+		result = "Error Type: ExecuteModeError\r\n"
+		result += "Error Message: " + self.value
+		return result
+
+#the id of the qubit must be unique
+class IDRepeatError(Exception):
+	def __init__(self,msg=None):
+		if msg == None:
+			self.value = "the id of the qubit has been used, please choose another id"
+		else:
+			self.value = msg
+	def __str__(self):
+		result = "Error Type: IDRepeatError\r\n"
+		result += "Error Message: " + self.value
+		return result
+
+#the qubit or qubits is not normal
+class NotNormal(Exception):
+	def __init__(self,msg=None):
+		if msg == None:
+			self.value = "the qubit or qubits is not normal, please normalize the measured qubit!"
+		else:
+			self.value = msg
+	def __str__(self):
+		result = "Error Type: NotNormal\r\n"
+		result += "Error Message: " + self.value
+		return result

-QuQ--master/baseClass/baseGate.py

@@ -0,0 +1,466 @@
+#!/usr/bin/python3
+import sys
+import os
+sys.path.append('../tools/')
+from interactCfg import *
+from Bit import Bit
+from Qubit import *
+from helperFunction import *
+#from Circuit import Circuit
+from Error import *
+import numpy as np
+import math
+import cmath
+
+#baseGate.py and Gate.py will use the DIC
+allowGate = {
+	'X':1,
+	'Y':1,
+	'Z':1,
+	'CNOT':2,
+	'S':1,
+	'Sd':1,
+	'T':1,
+	'Td':1,
+	'H':1,
+	'I':1,
+	'M':1,
+	'Rz':1,
+	'Ry':1,
+	#'Rx':1
+}
+
+class Gate:
+	def __init__(self,ql:list,gate:list,gateName:str):
+		self.gateName = gateName
+		self.gate = gate
+		if self.__checkType(ql):
+			self.ql = ql
+		
+	#the method has two parameters:
+	#the former stands for whether record the gate in qubitExecuteList
+	#the latter stands fot the angle parameter of the gate, 
+	#only the parameter of Rx,Ry and Rz gate isn't None 
+	def singleOperator(self,record = True,angle = None,forceQuit = False):
+		q = self.ql[0]
+		if angle != None and self.gateName not in ["Rx","Ry","Rz"]:
+			try:
+				raise GateNameError()
+			except GateNameError as gne:
+				info = self.get_curl_info()
+				writeErrorMsg(gne,info[0],info[1])
+
+		circuit = self.recordSingleExecution(record,angle,forceQuit)
+
+		qs = q.entanglement
+		noise = Noise(self.ql)
+		v = noise.simNoise(self.gate)
+		del noise
+		#the qubit is in entanglement
+		if qs != None:
+			q = self.__handleQubits(v,q)
+		else:
+			result = self.__matrixCompution(v,q.getMatrix()).tolist()
+			q.setMatrix(result)		
+		return q
+	
+	def CNOTOperator(self,record = True,forceQuit = False):
+		q1 = self.ql[0]
+		q2 = self.ql[1]
+
+		#q1 is same with q2
+		try:
+			if id(q1) == id(q2):
+				raise CodeError("The control-qubit can't be same with the target-qubit of CNOT gate!")
+		except CodeError as ce:
+			info = self.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			writeErrorMsg(ce,funName,line)	
+		
+		circuit = self.recordmultiExecution(record,None,forceQuit)
+
+		noise = Noise(self.ql)
+		v = noise.simNoise(self.gate)
+		del noise
+		q1Entangle = q1.entanglement
+		q2Entangle = q2.entanglement
+		#the twp qubits are single qubit
+		if q1Entangle == None and q2Entangle == None:
+			#construct the qubits
+			qs = Qubits(q1,q2)
+			result = self.__matrixCompution(v,qs.getMatrix()).tolist()
+			qs.setMatrix(result)
+			return qs
+		#the two qubits are in the same qubits
+		elif q1Entangle != None and q1Entangle == q2Entangle:
+			qs = q1Entangle
+			q = q2
+		#at least one of the two qubits are in entanglement
+		else:
+			#append q into qs
+			if q1Entangle == None:
+				qs = q2Entangle
+				q = q1
+			else:
+				qs = q1Entangle
+				if q2Entangle == None:
+					q = q2
+				else:
+					q = q2Entangle
+			#add q to qs, no matter the type of q is Qubit or Qubits
+			qs.addNewItem(q)
+		#note that the position of q1 and q2 may be different from before
+		q1Position = qs.getIndex(q1)
+		q2Position = qs.getIndex(q2)
+		#compute the result according to the function of CNOT
+		#if the control qubit aren't in |1>
+		if q1.getMatrix()[1] == 0:
+			return qs
+		totalQubit = len(qs.qubitList)
+		basicNum = 2 ** (totalQubit - q1Position - 1)
+		floatNum = 2 ** (totalQubit - q2Position - 1)
+		swapList = []
+
+		for i in range(basicNum, 2 ** totalQubit - floatNum):
+			#decide whether i has been in the swapList
+			whetherIn = False
+			for item in swapList:
+				if i in item:
+					whetherIn = True
+					break
+			if whetherIn == True:
+				continue
+			#we should make sure that the q1Postionth bit of 'i' is 1; if so, it means that the control bit is |1>, and 
+			#we need to flip the target; if not, the target qubit doesn't beed to be flipped 
+			if i & basicNum != 0:
+				tmpList = [i,i+floatNum]
+				swapList.append(tmpList)
+		newQSMatrix = qs.getMatrix()
+		for lists in swapList:
+			newQSMatrix[lists[0]],newQSMatrix[lists[1]] = newQSMatrix[lists[1]],newQSMatrix[lists[0]]
+		qs.setMatrix(newQSMatrix)
+		return qs		
+
+	def MOperator(self,result = True):
+		q = self.ql[0]
+		#just store the M gate in circuit.qubitExecuteList, 
+		#the measurement will actually occur when function circuit.execute is called  
+		if q.tag == "AC":
+			circuit = self.recordSingleExecution()
+		if result == True:
+			#store the measurement qubit in the self.measureList
+			circuit.measureList.append(q)
+
+		bit = q.degenerate()
+		value = bit.value
+		newMatrix = []
+		if value == 0:
+			newMatrix = [[1],[0]]
+		else:
+			newMatrix = [[0],[1]]
+		q.setMatrix(newMatrix)
+
+		return bit
+		#return data.degenerate()
+
+	#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]
+
+	#check the number of rows and cols, the result must be n*1 or m*m, otherwise raise an error
+	def __checkMatrix(self,m:list):
+		rows = len(m)
+		try:
+			cols = len(m[0])
+			for i in range(0,rows):
+
+				if cols != len(m[i]):
+					#each row must have the same number of elements
+					raise ValueError("each row doesn't have the same number of elements")
+			if cols != 1 and cols != rows:
+				raise ValueError("the format of the list is wrong")
+		except KeyError as ke:
+			info = self.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			writeErrorMsg(ke,funName,line)
+		except ValueError as ve:
+			info = self.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			writeErrorMsg(ve,funName,line)
+		lists = [rows,cols]
+		return lists
+
+	#check the type of the input, only Qubit is allowed.
+	def __checkType(self,ql:list):
+		for q in ql:
+			types = type(q)
+			#print(types)
+			if types == Bit:
+				try:
+					raise TypeError
+				except TypeError:
+					info = self.get_curl_info()
+					funName = info[0]
+					line = info[1]
+					writeErrorMsg("Bit " + str(q.ids) + " has been meaured! You can't act any quntum gate on it!",funName,line)
+			if types != Qubit:
+				try:
+					raise TypeError
+				except TypeError:
+					info = self.get_curl_info()
+					funName = info[0]
+					line = info[1]
+					writeErrorMsg("The type of the date should be Qubit!",funName,line)	
+		return True	
+
+	#compution the matrix multiplication
+	def __matrixCompution(self,l1:list,l2:list):
+		rc1 = self.__checkMatrix(l1)
+		rc2 = self.__checkMatrix(l2)
+		if rc1 == None or rc2 == None or rc1[1] != rc2[0]:
+			info = self.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			writeErrorMsg("the matrix is error",funName,line)
+		gate = np.matrix(l1)
+		qubit = np.matrix(l2)
+		return (gate*qubit)
+
+	#if the input of GATE is in entanglement, then call this function
+	def __handleQubits(self,gate:list , q:Qubit):
+		qs = q.entanglement
+		#get the index of the q in qs
+		position = qs.getIndex(q)
+		totalQubit = len(qs.qubitList)
+		basic = 2 ** (totalQubit - position - 1)
+		endResult = []
+		for i in range(0,2 ** totalQubit):
+			tmpResult = []
+			for n in range(0,2 ** totalQubit):
+				tmpResult.append([0])
+			amplitude = qs.getAmp()[i]
+			#pass the number i
+			if amplitude == 0.0:
+				endResult.append(tmpResult)
+				continue
+			#the target qubit is in |0>
+			if i & basic == 0:
+				tmpMatrix = [[1],[0]]
+				result = self.__matrixCompution(gate,tmpMatrix).tolist()
+				try:
+					result[0][0] = amplitude * result[0][0]
+					result[1][0] = amplitude * result[1][0]
+				except IndexError as ie:
+					info = self.get_curl_info()
+					funName = info[0]
+					line = info[1]
+					writeErrorMsg(ie,funName,line)	
+				tmpResult[i][0] = result[0][0]
+				tmpResult[i + basic][0] = result[1][0]
+			#the target qubit is in |1>
+			else:
+				tmpMatrix = [[0],[1]]
+				result = self.__matrixCompution(gate,tmpMatrix).tolist()
+				try:
+					result[0][0] = amplitude * result[0][0]
+					result[1][0] = amplitude * result[1][0]
+				except IndexError as ie:
+					info = self.get_curl_info()
+					funName = info[0]
+					line = info[1]
+					writeErrorMsg(ie,funName,line)
+				tmpResult[i][0] = result[1][0]
+				tmpResult[i - basic][0] = result[0][0]	
+				#print(newMatrix)
+			endResult.append(tmpResult)
+		sumResult = endResult[0]
+		for r in range(1,len(endResult)):
+			for x in range(0,len(endResult[r])):
+				sumResult[x][0] += endResult[r][x][0]
+		qs.setMatrix(sumResult)	
+		return q	
+
+	#record the execution
+	#if the environment is wrong, will cause the EnvironmentError 
+	#if the return-value is None, then there is somrthing wrong with the Circuit instance, and the program should be end
+	#or the current qubit is not stored in the executeList
+	#1.recordSingleExecution: record single gate, i.e. X,Y..
+	#2.recordMultiExecution:record multi gate, i.e. CNOT..
+	def recordSingleExecution(self,record = True,angle = None,forceQuit = False):
+		#only Mif and Qif will give the forceQuit to True
+		#if forceQuit is true, then end this method directly
+		if forceQuit:
+			return None
+		c = self.__recordSE(record,None,angle)
+		if c.withOD:
+			return self.__recordSE(True,c.qubitExecuteListOD,angle)
+		return c
+
+	def recordmultiExecution(self,record = True,angle = None,forceQuit = False):
+		if forceQuit:
+			return None
+		c = self.__recordME(record,None,angle)
+		if c.withOD:
+			return self.__recordME(True,c.qubitExecuteListOD,angle)
+		return c
+
+	def __recordSE(self,record,executeList = None,angle = None):
+		q = self.ql[0]
+		circuit = checkEnvironment()
+		if record == False:
+			return circuit
+		#record the execution according to the qubit.ids
+		ids = q.ids
+
+		if executeList == None:
+			executeList = circuit.qubitExecuteList
+		else:
+			#if the parameter "executeList" isn't None
+			#then it means that we are recording the executive record in circuit.qubitexecutelistOD
+			if self.gateName not in allowGate:
+				return circuit
+		#print(self.gateName)
+
+		if angle == None:
+			strs = self.gateName + " " + str(ids)
+		else:
+			#change format of the parameter "angle" to multiples of "PI"
+			tmpAngle = ""
+			multiplesList = str(angle / math.pi).split(".")
+			if len(multiplesList[1]) > 3:
+				tmpAngle = multiplesList[0] + "." + multiplesList[1][0:3]
+			else:
+				tmpAngle = multiplesList[0] + "." + multiplesList[1]
+			angleS = tmpAngle + "*pi"
+			strs = self.gateName + "(" + angleS + ") " + str(ids)
+
+		try:
+			#a qubit can only be measured once, and once the qubit was measured, you can't act any gate on it.
+			if "M "+str(ids) in executeList[q]:
+				try:
+					raise ValueError
+				except ValueError:
+					info = self.get_curl_info()
+					funName = info[0]
+					line = info[1]		
+					writeErrorMsg("Qubit: q"+ str(q.ids) + " has been measured! You can't act any gate on it!",funName,line)			
+
+			executeList[q].append(strs)
+
+		except KeyError as ke:
+			info = self.get_curl_info()
+			funName = info[0]
+			line = info[1]
+			writeErrorMsg("The current qubit is not stored in the execute list, please check your code!",funName,line)
+		return circuit
+
+	def __recordME(self,record,executeList = None,angle = None):
+		circuit = checkEnvironment()
+		if record == False:
+			return circuit
+		if circuit != None:
+			if executeList == None:
+				executeList = circuit.qubitExecuteList
+			else:
+				#if the parameter "executeList" isn't None
+				#then it means that we are recording the executive record in circuit.qubitexecutelistOD
+				if self.gateName not in allowGate:
+					return circuit
+
+			#print(exeRecord)
+			if angle == None:
+				strs = self.gateName + " "
+			else:
+				#change format of the parameter "angle" to multiples of "PI"
+				tmpAngle = ""
+				multiplesList = str(angle / math.pi).split(".")
+				if len(multiplesList[1]) > 3:
+					tmpAngle = multiplesList[0] + "." + multiplesList[1][0:3]
+				else:
+					tmpAngle = multiplesList[0] + "." + multiplesList[1]
+				angleS = tmpAngle + "*pi"
+				strs = self.gateName + "(" + angleS + ") "
+
+			maxLength = 0
+			#make up the multi gate string
+			for i in range(0,len(self.ql)):
+				ids = self.ql[i].ids
+				try:
+					length = len(executeList[self.ql[i]])
+					if "M " + str(ids) in executeList[self.ql[i]]:
+						raise ValueError
+				except KeyError as ke:
+					info = self.get_curl_info()
+					funName = info[0]
+					line = info[1]
+					writeErrorMsg("Qubit: q" + str(self.ql[i].ids) + " is not stored in the execute list, please check your code!",funName,line)			
+				except ValueError:
+					info = self.get_curl_info()
+					funName = info[0]
+					line = info[1]		
+					writeErrorMsg("Qubit: q"+ str(self.ql[i].ids) + " has been measured! You can't act any gate on it!",funName,line)						
+				if maxLength < length:
+					maxLength = length
+				strs += str(ids)
+				if i != len(self.ql) - 1:
+					strs += ","
+			#add the multi gate string to the execution of each qubit; 
+			#and add NULL to the shorter execution to occupy the position so that we can draw the circuit easily
+			for item in self.ql:
+				while len(executeList[item]) < maxLength:
+					tmpStr = "NULL " + str(item.ids)
+					executeList[item].append(tmpStr)
+				executeList[item].append(strs)
+		return circuit
+
+#add noise to the gate; the noise value is read from errorRate.cfg
+#attention, only the execute mode is 'simulator', then the function is useful
+class Noise:
+	def __init__(self,qList:list):
+		circuit = checkEnvironment()
+		self.error = 0.0
+		self.qList = qList
+		if circuit.mode == "theory":
+			pass
+		elif circuit.mode == "simulator":
+			qNum = len(qList)
+			if qNum == 1:
+				self.error = interactCfg.readCfgGE("single",qList[0].ids)
+			elif qNum == 2:
+				self.error = interactCfg.readCfgGE("multi")
+			else:
+				info = self.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				writeErrorMsg("There are only single-qubit or double-qubit gate error!",funName,line)
+		else:
+			try:
+				raise ExecuteModeError()
+			except ExecuteModeError as em:
+				info = self.get_curl_info()
+				funName = info[0]
+				line = info[1]
+				writeErrorMsg(em,funName,line)
+
+	def simNoise(self,gate:list):
+		if self.error == 0.0:
+			return gate
+		else:
+			for i in range(0,len(gate)):
+				for j in range(0,len(gate[0])):
+					if gate[i][j] == 0:
+						gate[i][j] = 1 - (1.0 * (1 - self.error))
+					else:
+						gate[i][j] = gate[i][j] * (1 - self.error)
+			return gate
+
+
+
+

-QuQ--master/baseClass/baseQubit.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+import math
+class BaseQubit:
+	def __init__(self):
+		self.matrix = []
+		self.amplitude = []
+
+	def setAmp(self):
+		matrix = self.getMatrix()
+		self.amplitude = [0] * len(matrix)
+		for i in range(0,len(matrix)):
+			self.amplitude[i] = matrix[i][0]
+
+	#this function will be called when act a gate on the qubit
+	def setMatrix(self,newMatrix:list):
+		self.matrix = newMatrix
+		self.setAmp()
+	
+	def getMatrix(self):
+		return self.matrix
+	def getAmp(self):
+		return self.amplitude
+
+	def normalize(self):
+		newMatrix = self.getMatrix()
+		sums = 0
+		for item in newMatrix:
+			sums += (item[0] * item[0].conjugate())
+		#the imag of the sums must be zero
+		denominator = math.sqrt(sums.real)
+		for i in range(0,len(newMatrix)):
+			newMatrix[i][0] = newMatrix[i][0] / denominator
+		#set the result to the amplitude and the matrix of the current instance 
+		self.setMatrix(newMatrix)
+
+	#overwrite the multiply to express the tensor product  
+	def __mul__(self,other):
+		newMatrix = []
+		selfMatrix = self.getMatrix()
+		otherMatrix = other.getMatrix()
+		for i in range(0,len(selfMatrix)):
+			for j in range(0,len(otherMatrix)):
+				item = []
+				item.append(selfMatrix[i][0] * otherMatrix[j][0])
+				newMatrix.append(item)
+		return newMatrix
+
+
+		

-QuQ--master/userCode/ibmGroverN=8.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f9e1ab116c9883b20f9e9bd0ba98bf122db33ce64382ff4bc518fc8201b1cb3
+size 737792

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

@@ -0,0 +1,39 @@
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	n1 := &ListNode{Val: 1}
+	n2 := &ListNode{Val: 2, Next: n1}
+	n3:= &ListNode{Val: 3, Next: n2}
+	n4 := &ListNode{Val: 4, Next: n3}
+
+	if hasCycle(n1) {
+		t.Fatalf("failed")
+	}
+	if hasCycle(n2) {
+		t.Fatalf("failed")
+	}
+	if hasCycle(n3) {
+		t.Fatalf("failed")
+	}
+	if hasCycle(n4) {
+		t.Fatalf("failed")
+	}
+
+	n1.Next = n2
+	if !hasCycle(n4) {
+		t.Fatalf("failed")
+	}
+}
+
+func Test2(t *testing.T) {
+	n1 := &ListNode{Val: 1}
+	n2 := &ListNode{Val: 2, Next: n1}
+	n3:= &ListNode{Val: 3, Next: n2}
+	n4 := &ListNode{Val: 4, Next: n3}
+	n1.Next = n3
+	if !hasCycle(n4) {
+		t.Fatalf("failed")
+	}
+}

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

@@ -0,0 +1,45 @@
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution:
+    def reverseList(self, head: ListNode) -> ListNode:
+        if head is None:
+            return
+
+        head_new = head
+        while head.next is not None:
+            next_ = head.next
+            next_.next, head.next = head_new, next_.next
+            head_new = next_
+        return head_new
+
+    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.reverseList(node1)
+        assert ans == node1
+
+        ans = self.reverseList(node2)
+        assert ans == node1
+
+        ans = self.reverseList(node1)
+        assert ans == node2
+
+        ans = self.reverseList(node4)
+        assert ans == node1
+
+        print("success")
+
+
+if __name__ == "__main__":
+    Solution().test()

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

@@ -0,0 +1,26 @@
+package main
+
+import "testing"
+
+func Test(t *testing.T)  {
+	node1 := ListNode{Val: 1}
+	node2 := ListNode{Val: 2, Next: &node1}
+	node3 := ListNode{Val: 3, Next: &node2}
+	node4 := ListNode{Val: 4, Next: &node3}
+	node5 := ListNode{Val: 5, Next: &node4}
+	if ans := reverseList(&node1); ans != &node1 {
+		t.Fatalf("failed, got %v\n", (*ans).Val)
+	}
+
+	if ans := reverseList(&node2); ans != &node1 {
+		t.Fatalf("failed, got %v\n", (*ans).Val)
+	}
+
+	if ans := reverseList(&node1); ans != &node2 {
+		t.Fatalf("failed, got %v\n", (*ans).Val)
+	}
+
+	if ans := reverseList(&node5); ans != &node1 {
+		t.Fatalf("failed, got %v\n", (*ans).Val)
+	}
+}

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

@@ -0,0 +1,24 @@
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
+        dummy = ListNode()
+        cur = dummy
+
+        while l1 is not None and l2 is not None:
+            if l1.val < l2.val:
+                cur.next = l1
+                l1 = l1.next
+            else:
+                cur.next = l2
+                l2 = l2.next
+            cur = cur.next
+        if l1 is not None:
+            cur.next = l1
+        else:
+            cur.next = l2
+        return dummy.next

10-week-algorithm-excercise-master/Week_01/24/swap_nodes_in_pairs.go

@@ -0,0 +1,16 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func swapPairs0(head *ListNode) *ListNode {
+	if head == nil || head.Next == nil {
+		return head
+	}
+	next := head.Next
+	head.Next = swapPairs(next.Next)
+	next.Next = head
+	return next
+}

10-week-algorithm-excercise-master/Week_01/641/design_circular_deque_test.go

@@ -0,0 +1,58 @@
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	q := Constructor(3)
+	if !q.IsEmpty() {
+		t.Fatalf("failed")
+	}
+	if q.GetFront() != -1 {
+		t.Fatalf("failed")
+	}
+	q.InsertLast(3)
+	if ans := q.GetFront(); ans != 3 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	if ans := q.GetRear(); ans != 3 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	q.InsertLast(8)
+	if ans := q.GetFront(); ans != 3 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	if ans := q.GetRear(); ans != 8 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	q.InsertLast(20)
+	if !q.IsFull() {
+		t.Fatalf("failed")
+	}
+	if q.InsertLast(30) {
+		t.Fatalf("failed\n")
+	}
+	q.DeleteFront()
+	if ans := q.GetFront(); ans != 8 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	if ans := q.GetRear(); ans != 20 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	q.DeleteLast()
+	if ans := q.GetFront(); ans != 8 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	if ans := q.GetRear(); ans != 8 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	q.DeleteLast()
+	if ans := q.GetFront(); ans != -1 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	if ans := q.GetRear(); ans != -1 {
+		t.Fatalf("failed, ans: %d\n", ans)
+	}
+	if !q.IsEmpty() {
+		t.Fatalf("failed")
+	}
+}

10-week-algorithm-excercise-master/Week_01/70/climbing_stairs.go

@@ -0,0 +1,14 @@
+package main
+
+func climbStairs(n int) int {
+	if n < 3 {
+		return n
+	}
+	f1, f2 := 1, 2
+	for i := 3; i <= n; i++ {
+		f2, f1 = f2 + f1, f2
+	}
+	return f2
+}
+
+

10-week-algorithm-excercise-master/Week_01/84/largest_rectangle_in_histogram.go

@@ -0,0 +1,24 @@
+package main
+
+func largestRectangleArea0(heights []int) int {
+	res := 0
+
+	for i := 0; i < len(heights); i++ {
+		l, r := i, i
+		for l > 0 && heights[l-1] >= heights[i] {
+			l--
+		}
+		for r < len(heights)-1 && heights[r+1] >= heights[i] {
+			r++
+		}
+		res = max(res, heights[i]*(r-l+1))
+	}
+	return res
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}

10-week-algorithm-excercise-master/Week_01/84/largest_rectangle_in_histogram2.go

@@ -0,0 +1,32 @@
+package main
+
+func largestRectangleArea1(heights []int) int {
+	if len(heights) == 0 {
+		return 0
+	}
+	n := len(heights)
+	leftIdx := make([]int, n)
+	rightIdx := make([]int, n)
+	leftIdx[0] = -1
+	rightIdx[n-1] = n
+
+	for i := 1; i < n; i++ {
+		l := i - 1
+		for l >= 0 && heights[l] >= heights[i] {
+			l = leftIdx[l]
+		}
+		leftIdx[i] = l
+	}
+	for i := n - 2; i >= 0; i-- {
+		r := i + 1
+		for r < n && heights[r] >= heights[i] {
+			r = rightIdx[r]
+		}
+		rightIdx[i] = r
+	}
+	res := 0
+	for i := 0; i < n; i++ {
+		res = max(res, heights[i]*(rightIdx[i]-leftIdx[i]-1))
+	}
+	return res
+}

10-week-algorithm-excercise-master/Week_01/88/merge_sorted_array2.go

@@ -0,0 +1,20 @@
+package main
+
+func merge(nums1 []int, m int, nums2 []int, n int) {
+	l := m + n - 1
+	m--
+	n--
+	for m >= 0 && n >= 0 {
+		if nums1[m] > nums2[n] {
+			nums1[l] = nums1[m]
+			m--
+		} else {
+			nums1[l] = nums2[n]
+			n--
+		}
+		l--
+	}
+	if n >= 0 {
+		copy(nums1[:n+1], nums2[:n+1])
+	}
+}

10-week-algorithm-excercise-master/Week_01/88/merge_sorted_array2.py

@@ -0,0 +1,22 @@
+from typing import List
+
+
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        """
+        Do not return anything, modify nums1 in-place instead.
+        """
+        l = m + n - 1
+        m -= 1
+        n -= 1
+
+        while m >= 0 and n >= 0:
+            if nums1[m] > nums2[n]:
+                nums1[l] = nums1[m]
+                m -= 1
+            else:
+                nums1[l] = nums2[n]
+                n -= 1
+            l -= 1
+        if n >= 0:
+            nums1[:n + 1] = nums2[:n + 1]

10-week-algorithm-excercise-master/Week_02/144/binary_tree_preorder_traversal.go

@@ -0,0 +1,22 @@
+package main
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func preorderTraversal(root *TreeNode) []int {
+	res := make([]int, 0)
+
+	var preOrder func(node *TreeNode)
+	preOrder = func(node *TreeNode) {
+		if node != nil {
+			res = append(res, node.Val)
+			preOrder(node.Left)
+			preOrder(node.Right)
+		}
+	}
+	preOrder(root)
+	return res
+}

10-week-algorithm-excercise-master/Week_02/144/binary_tree_preorder_traversal2.py

@@ -0,0 +1,40 @@
+from typing import List
+
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+
+class Solution:
+    def preorderTraversal(self, root: TreeNode) -> List[int]:
+        res = []
+        stack = [root]
+
+        while len(stack) > 0:
+            node = stack.pop()
+            if node is not None:
+                res.append(node.val)
+                if node.right is not None:
+                    stack.append(node.right)
+                if node.left is not None:
+                    stack.append(node.left)
+        return res
+
+    def test(self):
+        n1 = TreeNode(1)
+        n2 = TreeNode(2)
+        n3 = TreeNode(3)
+
+        n1.right = n2
+        n2.left = n3
+
+        ans = self.preorderTraversal(n1)
+        assert ans == [1, 2, 3], f"ans: {ans}"
+        print("well done")
+
+
+if __name__ == "__main__":
+    Solution().test()

10-week-algorithm-excercise-master/Week_02/144/binary_tree_preorder_traversal3.go

@@ -0,0 +1,21 @@
+package main
+
+func preorderTraversal3(root *TreeNode) []int {
+	res := make([]int, 0)
+
+	for root != nil {
+		res = append(res, root.Val)
+		if root.Left == nil {
+			root = root.Right
+		} else {
+			pre := root.Left
+
+			for pre.Right != nil {
+				pre = pre.Right
+			}
+			pre.Right = root.Right
+			root = root.Left
+		}
+	}
+	return res
+}

10-week-algorithm-excercise-master/Week_02/144/binary_tree_preorder_traversal3.py

@@ -0,0 +1,42 @@
+from typing import List
+
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+
+class Solution:
+    def preorderTraversal(self, root: TreeNode) -> List[int]:
+        res = []
+
+        while root is not None:
+            res.append(root.val)
+            if root.left is None:
+                root = root.right
+            else:
+                pre = root.left
+                while pre.right is not None:
+                    pre = pre.right
+                pre.right = root.right
+                root = root.left
+
+        return res
+
+    def test(self):
+        n1 = TreeNode(1)
+        n2 = TreeNode(2)
+        n3 = TreeNode(3)
+
+        n1.right = n2
+        n2.left = n3
+
+        ans = self.preorderTraversal(n1)
+        assert ans == [1, 2, 3], f"ans: {ans}"
+        print("well done")
+
+
+if __name__ == "__main__":
+    Solution().test()

10-week-algorithm-excercise-master/Week_02/264/ugly_number_ii2.go

@@ -0,0 +1,33 @@
+package main
+
+func nthUglyNumber2(n int) int {
+	dp := make([]int, n)
+	dp[0]=1
+	two := 0
+	three := 0
+	five := 0
+	for i := 1; i < n; i++ {
+		num := min(2*dp[two], 3*dp[three], 5*dp[five])
+		dp[i] = num
+		if 2*dp[two] == num {
+			two++
+		}
+		if 3*dp[three] == num {
+			three++
+		}
+		if 5*dp[five] == num {
+			five++
+		}
+	}
+	return dp[n-1]
+}
+
+func min(x, y, z int) int {
+	if x <= y && x <= z {
+		return x
+	}
+	if y <= x && y <= z {
+		return y
+	}
+	return z
+}

10-week-algorithm-excercise-master/Week_02/264/ugly_number_ii2.py

@@ -0,0 +1,30 @@
+class Solution:
+    def nthUglyNumber(self, n: int) -> int:
+        dp = [0] * n
+        dp[0] = 1
+
+        two = three = five = 0
+
+        for i in range(1, n):
+            num = min(2 * dp[two], 3 * dp[three], 5 * dp[five])
+            dp[i] = num
+            if 2 * dp[two] == num:
+                two += 1
+            if 3 * dp[three] == num:
+                three += 1
+            if 5 * dp[five] == num:
+                five += 1
+        return dp[-1]
+
+    def test(self):
+        for n, target in [
+            (1, 1),
+            (10, 12),
+        ]:
+            ans = self.nthUglyNumber(n)
+            assert ans == target, f"n: {n}, target: {target}"
+        print("well done")
+
+
+if __name__ == "__main__":
+    Solution().test()

10-week-algorithm-excercise-master/Week_02/264/ugly_number_ii_test.go

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

10-week-algorithm-excercise-master/Week_02/347/top_k_frequent_elements.go

@@ -0,0 +1,49 @@
+package main
+
+func topKFrequent(nums []int, k int) []int {
+	counter := make(map[int]int, 0)
+	for _, n := range nums {
+		counter[n]++
+	}
+	data := make([][2]int, k)
+
+	i := 0
+	for key, v := range counter {
+		if i <= k-1 {
+			data[i] = [2]int{key, v}
+			if i == k-1 {
+				for j := k/2 - 1; j >= 0; j-- {
+					heaplify(data, j, k-1)
+				}
+			}
+			i++
+		} else if v > data[0][1] {
+			data[0][0] = key
+			data[0][1] = v
+			heaplify(data, 0, k-1)
+		}
+	}
+	res := make([]int, k)
+
+	for i := 0; i < k; i++ {
+		res[i] = data[i][0]
+	}
+	return res
+}
+
+func heaplify(arr [][2]int, root int, end int) {
+	for {
+		child := root*2 + 1
+		if child > end {
+			return
+		}
+		if child+1 <= end && arr[child][1] > arr[child+1][1] {
+			child++
+		}
+		if arr[root][1] < arr[child][1] {
+			return
+		}
+		arr[root], arr[child] = arr[child], arr[root]
+		root = child
+	}
+}

10-week-algorithm-excercise-master/Week_02/347/top_k_frequent_elements2.go

@@ -0,0 +1,42 @@
+package main
+
+func topKFrequent2(nums []int, k int) []int {
+	counter := make(map[int]int, 0)
+	for _, n := range nums {
+		counter[n]++
+	}
+	arr := make([][2]int, 0)
+	for key, v := range counter {
+		arr = append(arr, [2]int{key, v})
+	}
+	if len(arr) > k {
+		quickSearch(arr, 0, len(arr)-1, k)
+	}
+	res := make([]int, k)
+	for i := 0; i < k; i++ {
+		res[i] = arr[i][0]
+	}
+	return res
+}
+
+func quickSearch(arr [][2]int, left, right, k int) {
+	if n := partition(arr, left, right); n > k {
+		quickSearch(arr, left, n-1, k)
+	} else if n < k {
+		quickSearch(arr, n+1, right, k)
+	}
+}
+
+func partition(arr [][2]int, left, right int) int {
+	pivot := arr[right][1]
+	i := left - 1
+	for j := left; j < right; j++ {
+		if arr[j][1] >= pivot {
+			i++
+			arr[i], arr[j] = arr[j], arr[i]
+		}
+	}
+	i++
+	arr[i], arr[right] = arr[right], arr[i]
+	return i
+}

10-week-algorithm-excercise-master/Week_02/347/top_k_frequent_elements_test.go

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

10-week-algorithm-excercise-master/Week_02/429/n_ary_tree_level_order_traversal.go

@@ -0,0 +1,26 @@
+package main
+
+type Node struct {
+	Val      int
+	Children []*Node
+}
+
+func levelOrder(root *Node) [][]int {
+	res := make([][]int, 0)
+
+	var levelOrder func(node *Node, level int)
+	levelOrder = func(node *Node, level int) {
+		if node != nil {
+			if len(res) == level {
+				res = append(res, []int{node.Val})
+			} else {
+				res[level] = append(res[level], node.Val)
+			}
+			for i := 0; i < len(node.Children); i++ {
+				levelOrder(node.Children[i], level+1)
+			}
+		}
+	}
+	levelOrder(root, 0)
+	return res
+}

10-week-algorithm-excercise-master/Week_02/429/n_ary_tree_level_order_traversal.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+
+
+class Solution:
+    def levelOrder(self, root: 'Node') -> List[List[int]]:
+        res = []
+
+        def level_order(node: Node, level: int):
+            if node is not None:
+                if len(res) == level:
+                    res.append([node.val])
+                else:
+                    res[level].append(node.val)
+                for c in node.children:
+                    level_order(c, level + 1)
+
+        level_order(root, 0)
+        return res

10-week-algorithm-excercise-master/Week_02/429/n_ary_tree_level_order_traversal2.go

@@ -0,0 +1,25 @@
+package main
+
+func levelOrder2(root *Node) [][]int {
+	res := make([][]int, 0)
+	stack := []*Node{root}
+	level := 0
+	for len(stack) > 0 {
+		num := len(stack)
+		for i := 0; i < num; i++ {
+			if stack[i] != nil {
+				if len(res) == level {
+					res= append(res, []int{stack[i].Val})
+				} else {
+					res[level] = append(res[level], stack[i].Val)
+				}
+				for j := 0; j < len(stack[i].Children); j++ {
+					stack = append(stack, stack[i].Children[j])
+				}
+			}
+		}
+		stack = stack[num:]
+		level++
+	}
+	return res
+}

10-week-algorithm-excercise-master/Week_02/49/group_anagrams.go

@@ -0,0 +1,25 @@
+package main
+
+func groupAnagrams(strs []string) [][]string {
+	res := make([][]string, 0)
+	indexMap := make(map[string]int, 0)
+	for _, s := range strs {
+		ss := sortString(s)
+		if idx, ok := indexMap[ss]; !ok {
+			indexMap[ss] = len(indexMap)
+			res = append(res, []string{s})
+		} else {
+			res[idx] = append(res[idx], s)
+		}
+	}
+	return res
+}
+
+func sortString(str string) string {
+	sl := make([]rune, 26)
+
+	for _, c := range str {
+		sl[c-'a']++
+	}
+	return string(sl)
+}

10-week-algorithm-excercise-master/Week_02/49/group_anagrams.py

@@ -0,0 +1,35 @@
+from typing import List, Dict
+
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        counter: Dict[tuple, List[str]] = {}
+
+        def count_char(s: str) -> tuple:
+            base = [0] * 26
+            for c in s:
+                base[ord(c) - ord('a')] += 1
+            return tuple(base)
+
+        for s in strs:
+            cc = count_char(s)
+            if cc in counter:
+                counter[cc].append(s)
+            else:
+                counter[cc] = [s]
+        return list(counter.values())
+
+    def test(self):
+        for strs, target in [
+            ([""], [[""]]),
+            (["a", "b"], [["a"], ["b"]]),
+            (["ab", "ba", "bb"], [["ab", "ba"], ["bb"]]),
+        ]:
+            ans = self.groupAnagrams(strs)
+            assert sorted(ans) == sorted(target)
+
+        print("all done")
+
+
+if __name__ == "__main__":
+    Solution().test()

10-week-algorithm-excercise-master/Week_02/49/group_anagrams_test.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	tests := []struct {
+		strs   []string
+		target [][]string
+	}{
+		{[]string{""}, [][]string{{""}}},
+		{[]string{"a", "ab", "ba"}, [][]string{{"a"}, {"ab", "ba"}}},
+		{[]string{"eat", "tea", "tan", "ate", "nat", "bat"}, [][]string{{"eat", "tea", "ate"}, {"tan", "nat"}, {"bat"}},
+		}}
+
+	for _, tt := range tests {
+		if ans := groupAnagrams(tt.strs); !reflect.DeepEqual(ans, tt.target) {
+			t.Fatalf("target: %v, ans: %v\n", tt.target, ans)
+		}
+	}
+}

10-week-algorithm-excercise-master/Week_02/589/n_ary_tree_preorder_traversal.go

@@ -0,0 +1,21 @@
+package main
+
+type Node struct {
+	Val      int
+	Children []*Node
+}
+
+func preorder(root *Node) []int {
+	res := make([]int, 0)
+	var preOrder func(node *Node)
+	preOrder = func(node *Node) {
+		if node != nil {
+			res = append(res, node.Val)
+			for i := 0; i < len(node.Children); i++ {
+				preOrder(node.Children[i])
+			}
+		}
+	}
+	preOrder(root)
+	return res
+}

10-week-algorithm-excercise-master/Week_02/589/n_ary_tree_preorder_traversal.py

@@ -0,0 +1,21 @@
+from typing import List
+
+
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+
+
+class Solution:
+    def preorder(self, root: 'Node') -> List[int]:
+        res = []
+
+        def pre_order(node: Node):
+            if node is not None:
+                res.append(node.val)
+                for c in node.children:
+                    pre_order(c)
+
+        pre_order(root)
+        return res

10-week-algorithm-excercise-master/Week_02/589/n_ary_tree_preorder_traversal2.go

@@ -0,0 +1,18 @@
+package main
+
+func preorder2(root *Node) []int {
+	res := make([]int, 0)
+	stack := []*Node{root}
+
+	for len(stack) > 0 {
+		node := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		if node != nil {
+			res = append(res, node.Val)
+			for i := len(node.Children) - 1; i >= 0; i-- {
+				stack = append(stack, node.Children[i])
+			}
+		}
+	}
+	return res
+}

10-week-algorithm-excercise-master/Week_02/589/n_ary_tree_preorder_traversal2.py

@@ -0,0 +1,21 @@
+from typing import List
+
+
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+
+
+class Solution:
+    def preorder(self, root: 'Node') -> List[int]:
+        res = []
+
+        stack = [root]
+        while stack:
+            node = stack.pop()
+            if node is not None:
+                res.append(node.val)
+                for i in range(len(node.children) - 1, -1, -1):
+                    stack.append(node.children[i])
+        return res

10-week-algorithm-excercise-master/Week_02/590/n_ary_tree_postorder_traversal.go

@@ -0,0 +1,21 @@
+package main
+
+type Node struct {
+	Val      int
+	Children []*Node
+}
+
+func postorder(root *Node) []int {
+	res := make([]int, 0)
+	var postOrder func(node *Node)
+	postOrder = func(node *Node) {
+		if node != nil {
+			for i := 0; i < len(node.Children); i++ {
+				postOrder(node.Children[i])
+			}
+			res = append(res, node.Val)
+		}
+	}
+	postOrder(root)
+	return res
+}

10-week-algorithm-excercise-master/Week_02/590/n_ary_tree_postorder_traversal2.go

@@ -0,0 +1,22 @@
+package main
+
+func postorder2(root *Node) []int {
+	res := make([]int, 0)
+	stack := []*Node{root}
+
+	for len(stack) > 0 {
+		node := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		if node != nil {
+			res = append(res, node.Val)
+			for i := 0; i < len(node.Children); i++ {
+				stack = append(stack, node.Children[i])
+			}
+		}
+	}
+
+	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/Week_02/590/n_ary_tree_postorder_traversal2.py

@@ -0,0 +1,21 @@
+from typing import List
+
+
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+
+
+class Solution:
+    def postorder(self, root: 'Node') -> List[int]:
+        res = []
+
+        stack = [root]
+        while len(stack) > 0:
+            node = stack.pop()
+            if node is not None:
+                res.append(node.val)
+                for c in node.children:
+                    stack.append(c)
+        return res[::-1]

10-week-algorithm-excercise-master/Week_02/590/n_ary_tree_postorder_traversal_test.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	n1 := &Node{Val: 1}
+	n2 := &Node{Val: 2}
+	n3 := &Node{Val: 3}
+	n4 := &Node{Val: 4}
+	n5 := &Node{Val: 5}
+	n1.Children = []*Node{n2, n3, n4}
+	n3.Children = []*Node{n5}
+
+	if ans := postorder2(n1); !reflect.DeepEqual(ans, []int{2, 5, 3, 4, 1}) {
+		t.Fatalf("ans: %v\n", ans)
+	}
+}