Fix algorithm

Author: mahdihasnat

Algorithms/Strings/MinCostStringConversion.fs

@@ -9,90 +9,75 @@
 namespace Algorithms.Strings
 
 module MinCostStringConversion =
+    
+    [<RequireQualifiedAccess>]
+    type Operation =
+        | Copy of char
+        | Replace of Source: char * Target: char
+        | Delete of char
+        | Insert of char
+    
     let computeTransformTables
         (
-            sourceString: string,
-            destinationString: string,
+            source: string,
+            destination: string,
             copyCost: int,
             replaceCost: int,
             deleteCost: int,
             insertCost: int
-        ): list<int> * list<string> =
-        let sourceSeq = [ sourceString ]
-        let destinationSeq = [ destinationString ]
-        let lenSourceSeq = sourceSeq.Length
-        let lenDestinationSeq = destinationSeq.Length
-
+        ): array<array<int>> * array<array<Operation>> =
+        
         let costs =
-            [| for i in 0 .. (lenSourceSeq + 1) -> [| for i in 0 .. lenDestinationSeq + 1 -> 0 |] |]
-
+            Array.init (source.Length + 1) (fun  _ -> Array.init (destination.Length + 1) (fun _ -> None))
+            
         let ops =
-            [| for i in 0 .. lenSourceSeq + 1 -> [| for i in 0 .. lenDestinationSeq + 1 -> "" |] |]
-
-        for i = 1 to lenSourceSeq + 1 do
-            costs.[i].[0] <- i * deleteCost
-            ops.[i].[0] <- sprintf "D%s" (sourceSeq.[i - 1])
-
-        for i = 1 to lenDestinationSeq + 1 do
-            costs.[0].[i] <- i * insertCost
-            ops.[0].[i] <- sprintf "I%s" (destinationSeq.[i - 1])
-
-        for i in 1 .. lenSourceSeq + 1 do
-            for j in 1 .. lenDestinationSeq + 1 do
-                if sourceSeq.[i - 1] = destinationSeq.[j - 1] then
-                    costs.[i].[j] <- costs.[i - 1].[j - 1] + copyCost
-                    ops.[i].[j] <- sprintf "C%s" (sourceSeq.[i - 1])
+            Array.init (source.Length + 1) (fun  _ -> Array.init (destination.Length + 1) (fun _ -> None))
+        
+        costs.[0].[0] <- Some 0
+        ops.[0].[0] <- Some (Operation.Copy 'a') // There is no operation to perform, assigning dummy operation to satisfy compiler 
+        
+        
+        for i = 1 to source.Length do
+            costs.[i].[0] <- Some (i * deleteCost)
+            ops.[i].[0] <- Some (Operation.Delete source.[i - 1])
+
+        for i = 1 to destination.Length do
+            costs.[0].[i] <- Some (i * insertCost)
+            ops.[0].[i] <- Some (Operation.Insert destination.[i - 1])
+
+        for i in 1 .. source.Length do
+            for j in 1 .. destination.Length do
+                if source.[i - 1] = destination.[j - 1] then
+                    costs.[i].[j] <- Some (costs.[i - 1].[j - 1].Value + copyCost)
+                    ops.[i].[j] <- Some (Operation.Copy (source.[i - 1]))
                 else
-                    costs.[i].[j] <- costs.[i - 1].[j - 1] + replaceCost
-
-                    ops.[i].[j] <-
-                        sprintf
-                            "R%s"
-                            (sourceSeq.[i - 1]
-                             + (string) (destinationSeq.[j - 1]))
+                    costs.[i].[j] <- Some (costs.[i - 1].[j - 1].Value + replaceCost)
+                    ops.[i].[j] <- Some (Operation.Replace (source.[i - 1], destination.[j - 1]))
 
-                if costs.[i - 1].[j] + deleteCost < costs.[i].[j] then
-                    costs.[i].[j] <- costs.[i - 1].[j] + deleteCost
-                    ops.[i].[j] <- sprintf "D%s" (sourceSeq.[i - 1])
+                if costs.[i - 1].[j].Value + deleteCost < costs.[i].[j].Value then
+                    costs.[i].[j] <- Some (costs.[i - 1].[j].Value + deleteCost)
+                    ops.[i].[j] <- Some (Operation.Delete (source.[i - 1]))
 
-                if costs.[i].[j - 1] + insertCost < costs.[i].[j] then
-                    costs.[i].[j] <- costs.[i].[j - 1] + insertCost
-                    ops.[i].[j] <- sprintf "I%s" (destinationSeq.[j - 1])
+                if costs.[i].[j - 1].Value + insertCost < costs.[i].[j].Value then
+                    costs.[i].[j] <- Some (costs.[i].[j - 1].Value + insertCost)
+                    ops.[i].[j] <- Some (Operation.Insert destination.[j - 1])
 
-        costs |> Seq.cast<int> |> Seq.toList, ops |> Seq.cast<string> |> Seq.toList
+        costs |> Array.map (Array.map Option.get), ops |> Array.map (Array.map Option.get)
 
-    let rec assembleTransformation (ops: list<string>, i: int, j: int): list<string> =
+    let rec assembleTransformation (ops: array<array<Operation>>, i: int, j: int): array<Operation> =
+        printfn $"i={i},j={j},%A{ops}"
         if i = 0 && j = 0 then
-            List.empty
+            Array.empty
         else
             match ops.[i].[j] with
-            | o when o = 'C' || o = 'R' ->
-                let mutable seq =
-                    assembleTransformation (ops, i - 1, j - 1)
-                    |> List.toArray
-
-                let ch =
-                    [ ((string) ops.[i].[j]) ] |> List.toArray
-
-                seq <- seq |> Array.append ch
-                seq |> List.ofArray
-            | 'D' ->
-                let mutable seq =
-                    assembleTransformation (ops, i - 1, j)
-                    |> List.toArray
-
-                let ch =
-                    [ ((string) ops.[i].[j]) ] |> List.toArray
-
-                seq <- seq |> Array.append ch
-                seq |> List.ofArray
-            | _ ->
-                let mutable seq =
-                    assembleTransformation (ops, i, j - 1)
-                    |> List.toArray
-
-                let ch =
-                    [ ((string) ops.[i].[j]) ] |> List.toArray
-
-                seq <- seq |> Array.append ch
-                seq |> List.ofArray
+            | Operation.Replace _
+            | Operation.Copy _ ->
+                let seq = assembleTransformation (ops, i - 1, j - 1)
+                Array.append seq [| ops[i][j] |] 
+            | Operation.Delete _ ->
+                let seq = assembleTransformation (ops, i - 1, j)
+                Array.append seq [| ops[i][j] |] 
+            | Operation.Insert _ ->
+                let seq = assembleTransformation (ops, i , j - 1)
+                Array.append seq [| ops[i][j] |] 
+