Add files via upload

Author: je-suis-tm

edit distance dynamic programming.jl

@@ -0,0 +1,118 @@
+
+# coding: utf-8
+
+# In[1]:
+
+
+#its also called levenshtein distance
+#it can be done via recursion too
+#the recursion version is much more elegant yet less efficient
+# https://github.com/je-suis-tm/recursion/blob/master/edit%20distance%20recursion.jl
+
+#edit distance is to minimize the steps transforming one string to another
+#the way to solve this problem is very similar is to knapsack
+#assume we have two strings text1 and text2
+#we build a matrix with the size of (length(text1)+1)*(length(text2)+1)
+
+#there are three different ways to transform a string
+#insert,delete and replace
+#we can use any of them or combined
+#lets take a look at the best case first
+#assume string text1 is string text2
+#we dont need to do anything
+#so 0 steps would be the answer
+#for the worst case
+#when string text1 has nothing in common with string text2
+#we would have to replace the whole string text1
+#the steps become the maximum step which is max(length(text1),length(text2))
+#for general case,the number of steps would fall between the worst and the best case
+#assume we are at i th letter of string text1 and j th letter string text2
+#if we wanna get the optimal steps of transforming string text1 to string text2
+#we have to make sure at each letter transformation
+#text1[1:i] and text2[1:j] have reached their optimal status
+#otherwise,we could always find another combination of insert,delete and replace
+#to get a "real" optimal text1[1:i] and text2[1:j]
+#it would make our string transformation not so optimal any more
+#it is the same logic as the optimization of knapsack problem
+#after we set our logic straight
+#we would take a look at three different approaches
+#lets take a look at insertion
+#basically we need to insert j th letter from string text2 into string text1 at i th position
+#the cumulated steps we have taken should be matrix[i][j-1]+1
+#matrix[i][j-1] is the steps for text1[1:i] to text2[1:j]
+#for delete,it is vice versa
+#the cumulated steps we have taken should be matrix[i-1][j]+1
+#for replacement,it is a lil bit tricky
+#there are two scenarios
+#if text1[i-1]==text2[j-1]
+#it should be matrix[i-1][j-1]
+#we dont need any replacement at all
+#else,it should be matrix[i-1][j-1]+1
+#we replace i th letter of string text1 with j th letter of string text2
+#after we managed to understand three different approaches
+#we want to take the minimum number of steps among these three approaches
+#throughout the iteration of different positions of both strings
+#in the end,we would get the optimal steps to transform one string to another,YAY
+
+
+# In[2]:
+
+
+function edit_distance(text1,text2)
+ 
+ len1=length(text1)+1
+ len2=length(text2)+1
+ 
+ #this part is to create a matrix of (length(text1)+1)*(length(text2)+1)
+ matrix=[[0 for _ in 1:len2] for _ in 1:len1]
+ 
+ for i in 1:len1
+ 
+ matrix[i][1]=i-1
+ 
+ end
+ 
+ for i in 1:len2
+ 
+ matrix[1][i]=i-1
+ 
+ end
+ 
+ #we take iterations on both string text1 and text2
+ #next,we check if text1[i-1]==text2[j-1]
+ #if yes,no replacement needed
+ #if no,replacement needed
+ #we take a minimum function to see which combination would give the minimum steps
+ #eventually we got what we are after
+ for i in 2:len1
+ 
+ for j in 2:len2
+ 
+ if text1[i-1]==text2[j-1]
+ 
+ matrix[i][j]=min(matrix[i-1][j]+1,
+ matrix[i][j-1]+1,
+ matrix[i-1][j-1])
+ 
+ else
+ 
+ matrix[i][j]=min(matrix[i-1][j]+1,
+ matrix[i][j-1]+1,
+ matrix[i-1][j-1]+1)
+ 
+ end
+ 
+ end
+ 
+ end
+ 
+ return matrix[len1][len2]
+ 
+end
+
+
+# In[3]:
+
+
+println(edit_distance("baiseé","bas"))
+

edit distance recursion.jl

@@ -0,0 +1,50 @@
+
+# coding: utf-8
+
+# In[1]:
+
+
+#explanation can be found in dynamic programming version
+# https://github.com/je-suis-tm/recursion/blob/master/edit%20distance%20dynamic%20programming.jl
+#the only problem with recursion is that it is so freaking slow
+#recursion is so inefficient in any programming language
+#although it looks much more elegant than dynamic programming
+
+
+# In[2]:
+
+
+function edit_distance(text1,text2)
+ 
+ if isempty(text1) || isempty(text2)
+ 
+ return max(length(text1),length(text2))
+ 
+ end
+ 
+ #we are comparing characters here
+ #to get string, we should do end:end
+ if text1[end]==text2[end]
+ 
+ replacement=0
+ 
+ else
+ 
+ replacement=1
+ 
+ end
+ 
+ steps=min(edit_distance(text1[1:end-1],text2)+1,
+ edit_distance(text1,text2[1:end-1])+1,
+ edit_distance(text1[1:end-1],text2[1:end-1])+replacement)
+ 
+ return steps
+ 
+end
+
+
+# In[3]:
+
+
+println(edit_distance("arsehole","asshoe"))
+

knapsack.jl

@@ -0,0 +1,110 @@
+
+# coding: utf-8
+
+# In[1]:
+
+
+#this has nothing to do with recursion algorithm
+#it happened to be in the recursion chapter in my book
+#so i kept it under recursion
+#its about dynamic programming
+#its kinda tricky to understand
+#if you are familiar with convex optimization or lagrangian
+#its better to use em instead of this
+
+
+#knapsack problem is to maximize the value
+#while having a weight constraint
+#each value has a different weight
+#the knapsack has a maximum capacity which is the constraint
+
+
+#to solve the problem,we have to use recursive thinking
+#lets create a list from 1 to the maximum capacity
+#for each capacity in the list 
+#we try to reach the optimal allocation of weight at the given capacity
+#say we have c as the maximum capacity
+#we remove the last item i
+#we get weight capacity-weight[i]
+#we wanna make sure our allocation at capacity-weight[i] is still the optimal
+#by optimal,we mean for the same weight we can achieve the highest value
+#if capacity-weight[i] is not the optimal
+#we can find another combo with the same weight but higher value
+#we add the item i back into the knapsack then
+#the new total value we get would be larger than the previous so-called optimal
+#it will contradict the definition of optimal
+#hence,for each capacity,we keep removing items
+#until we reach base case 0,and it always stays the optimal at the given capacity
+
+
+#to get the optimal status
+#we shall do a traversal on all items
+#we create a matrix with (number of items) * (maximum capacity)
+#for each capacity level,we try to add a new item
+#if adding new item causes the overall weight larger than the current capacity level
+#the knapsack reverts to the previous status without item i which is matrix[i-1][j]
+#if adding new item doesnt cause the overall weight bigger than the current capacity level
+#we try to see whether adding item i would be the new optimal case
+#so we compare the previous status with the status after adding item i
+#the status after adding item i shall be matrix[i-1][j-weight[i-1]]+value[i-1]
+#we use j-weight[i-1] cuz adding item i would reduce the capacity we have
+#we have to use the current constraint level j to minus item i weight
+
+
+# In[2]:
+
+
+function knapsack(value,weight,capacity)
+
+ #in this section,we create a nested list with size of (number of items+1)*(capacity+1)
+ matrix=[[0 for _ in 1:(capacity+1)] for _ in 1:(length(value)+1)]
+ 
+ #now we begin our traversal on all elements in matrix
+ #i starts from 2 cuz we would be using i-1 to imply item i
+ for i in 2:(length(value)+1)
+ 
+ for j in 2:(capacity+1)
+ 
+ #this is the part to check if adding item i-1 would exceed the current capacity j
+ #if it does,we go back to the previous status
+ #if not,we shall find out whether adding item i-1 would be the new optimal
+ if weight[i-1]>j
+ 
+ matrix[i][j]=matrix[i-1][j]
+ 
+ else
+ 
+ #julia index starts from 1
+ #which is a pain in the ass
+ #when current capacity==the new item s weight
+ #it creates an issue
+ if j==weight[i-1]
+ 
+ ind=1
+ 
+ else
+ 
+ ind=j-weight[i-1]
+ 
+ end
+ 
+ #we use max funcion to see if adding item i-1 would be the new optimal
+ matrix[i][j]=max(matrix[i-1][j],
+ matrix[i-1][ind]+value[i-1])
+ 
+ end
+ 
+ end
+ 
+ end
+ 
+ return matrix[length(value)+1][capacity+1]
+ 
+end
+
+
+# In[3]:
+
+
+println(knapsack([0,50,60,60,120],[0,10,15,20,40],50))
+