Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- let k = 3
- let errs = 0
- let L= ["AAA"; "AAC"; "ACA"; "CAC"; "CAA"; "ACG"; "CGC"; "GCA"; "ACT";"CTT";"TTA";"TAA"]
- type Edge = { src:string; dest:string; v:char }
- type Node = { label:string; adjacents:Edge list }
- type Graph = Node list
- let wordsToEdges k words =
- List.map(fun (s:string) -> {src=s.[0..k-2]; dest=s.[1..k-1]; v=s.[k-1]}) words
- let edges = wordsToEdges k L
- let edgesToGraph edges :Graph =
- edges |>
- List.groupBy (fun e -> e.src) |>
- List.map (fun (n,l) -> { label=n; adjacents=l})
- let graph = edgesToGraph edges
- let transposeGraph (graph:Graph) =
- graph |>
- List.fold (fun acc elem -> acc @ elem.adjacents) [] |>
- List.map (fun e -> { src=e.dest; dest=e.src; v=e.v }) |>
- edgesToGraph
- let gt = transposeGraph graph
- let getPossibleEdges (graph:Graph) (k:int) =
- let nodes = List.map (fun a -> a.label) graph
- List.allPairs nodes nodes |>
- List.filter (fun (a,b) -> a.[1 ..] = b.[.. k-3]) |>
- List.map (fun (a,b) -> { src=a; dest=b; v=b.[k-2]})
- let alledges = getPossibleEdges graph k
- let extractPath (n:string) (graph:Graph) :(string*Graph) =
- let
- let isSemiEulerian (graph:Graph) =
- let edges = graph |> List.collect (fun n -> n.adjacents)
- let inEdges = List.countBy (fun e -> e.dest) edges |> List.sortBy (fun (a,_) -> a)
- let outEdges = List.countBy (fun e -> e.src) edges |> List.sortBy (fun (a,_) -> a)
- match List.fold2 (fun deg (_,i) (_,o) -> deg + abs (i - o)) 0 inEdges outEdges with
- | 0 -> ""
- | 2 ->
- let startingNode = List.fold2 (fun _ (n,i) (_,o) -> if o > i then n) null inEdges outEdges
- let (mainPath,workingGraph) = extractPath startingNode graph
- | _ -> ""
- isSemiEulerian graph
- let list1 = edges |> List.groupBy (fun e -> e.src)
- let list2 = edges |> List.groupBy (fun e -> e.dest)
- //let scores:int list = List.map2 list1 list2 (fun (_,a) (_,b) -> a.Length - b.Length)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement