View difference between Paste ID: uQ4pipz4 and ieFNbzVy

 open System
 open System.IO
-open System.Collections.Generic
+open Microsoft.FSharp.Collections
 
 let flip f a b = f b a
 
-let rec yobaFold fa fi s  = match s with | a, None    -> a
+
-                                         | a, Some(i) -> yobaFold fa fi (fa a i , fi i)
+
                       |> Seq.length
 
 let buildMap ws = let l = Array.length ws - 1
                   seq{ for i in 0..l do
                        for j in i..l do
                        if diff ws.[i] ws.[j] < 2
                        then yield i, j; yield j, i }
                   |> Seq.groupBy(fst)
                   |> Seq.map(fun (k,s) -> k, s |> Seq.map(snd))
                   |> Map.ofSeq
 
 type Transmute = {s:int;c:int; h:int list}
 
 let transmutes (map:Map<int,_>) start =
-type Transmute = {p: Transmute Option; c:int}
+    let visit   = Seq.fold(fun a {c=c} -> Set.add c a)
     let next vs curs =
         let nxt c = map.[c.c]
-    let visit = Seq.fold(fun a {c=c} -> Set.add c a)
+                    |> Seq.filter(flip Set.contains vs >> not)
-    let next  vs curs =
+                    |> Seq.map(fun n -> {s=start;h = c.c::c.h; c = n})
-        let next1 c = map.[c.c] |> Seq.filter(flip Set.contains vs >> not)
+        curs |> Seq.map(nxt) |> Seq.collect(fun n -> n)
-                                |> Seq.map(fun n -> {p = Some(c); c = n})
+    let rec trans vs olds = seq{ yield! olds;
-        curs |> Seq.map(next1)  |> Seq.collect(fun n -> n)
+                                 let nvs  = visit vs olds
-    let rec trans vs olds =
+                                 let news = next nvs olds
-        if Seq.isEmpty olds then Seq.empty
+                                 if Seq.isEmpty news |> not
-        else seq{ yield! olds;
+                                 then yield! trans nvs news }
-                  let newVs = (visit vs olds) in yield! trans newVs (next newVs olds) }
+    trans Set.empty [{s=start;c=start; h=[]}]
-    trans Set.empty [{p=None; c=start}]
+
 let findWay words map (start, target) =
     let s = Array.findIndex ((=)start) words
     let t = Array.findIndex ((=)target) words
     let way = transmutes map s |> Seq.tryFind(fun {c=c} -> c=t)
     match way with | None    -> [] | Some(r) -> r.h
-    match way with | None -> []
+
-                   | res  -> yobaFold(fun a {c=c} -> c::a) (fun {p=p} -> p) ([], res)
+let words    = File.ReadAllLines @"C:\words.txt"
-                             |> List.map(fun i -> words.[i])
+
 let printWay way = way |> Seq.map(fun i -> words.[i]) |> List.ofSeq
-let words    = File.ReadAllLines @"D:\Arc\Dropbox\Dropbox\Projects\FSharp\AprilFpContest\AprilFpContest\bin\Debug\words.txt"
+
 //ОРИГИНАЛЬНОЕ ЗАДАНИЕ
-let pairs    = ["МУХА","СЛОН"; "ДЕНЬ","НОЧЬ"; "СНЕГ","ВОДА"; "ОТЕЦ", "МАТЬ";
+["МУХА","СЛОН"; "ДЕНЬ","НОЧЬ"; "СНЕГ","ВОДА"; "ОТЕЦ", "МАТЬ";
-                "РУКА","НОГА"; "ЗИМА","ЛЕТО"; "СВЕТ","ТЬМА"; "ЛИПА", "КЛЁН"]
+ "РУКА","НОГА"; "ЗИМА","ЛЕТО"; "СВЕТ","ТЬМА"; "ЛИПА", "КЛЁН"]
-               |> Seq.map(fun (s,e) -> s.ToLower(), e.ToLower())
+|> Seq.map(fun (s,e) -> s.ToLower(), e.ToLower())
-pairs |> Seq.map(fun p -> p, findWay words wordsMap p) |> Seq.iter(printfn "%A")
+|> Seq.map(fun p -> p, findWay words wordsMap p |> printWay)
 |> Seq.iter(printfn "%A")
 
 
 //ДОПОЛНИТЕЛЬНОЕ ЗАДАНИЕ
 let mt  = wordsMap |> PSeq.map(fun k -> k.Key)
                    |> PSeq.map(transmutes wordsMap)
                    |> PSeq.collect(fun x -> x)
                    |> PSeq.maxBy(fun x -> x.h.Length)
 Console.WriteLine("{0} - {1}: {2} \n", words.[mt.s], words.[mt.c], mt.h.Length)
 Console.WriteLine(Seq.reduce(fun a s -> a + " " + s) (printWay mt.h))
 
 Console.ReadLine()