Fixed Formatting

Author: martial-plains

Algorithms/Program.fs

@@ -8,5 +8,5 @@ module Program =
         // for item in InsertionSort.Sort list do
         //    System.Console.WriteLine item
         Math.Fibonacci.PrintSerie 1 0
-        
+
         0

Algorithms/Search/BinarySearch.fs

@@ -1,14 +1,15 @@
 namespace Algorithms.Search
+
 open System
 
 module BinarySearch =
-    let rec byRecursion (sortedData : IComparable[], item : int, left : int, right : int) =
+    let rec byRecursion (sortedData: IComparable [], item: int, left: int, right: int) =
 
         let middle = left + (right - left) / 2
 
         match sortedData.[middle] with
-        | s when s.CompareTo(sortedData.[middle]) > item -> byRecursion(sortedData, item, left, middle - 1)
-        | s when s.CompareTo(sortedData.[middle]) < item -> byRecursion(sortedData, item, left, middle + 1)
+        | s when s.CompareTo(sortedData.[middle]) > item -> byRecursion (sortedData, item, left, middle - 1)
+        | s when s.CompareTo(sortedData.[middle]) < item -> byRecursion (sortedData, item, left, middle + 1)
         | _ -> middle
 
     /// <summary>
@@ -20,7 +21,7 @@ module BinarySearch =
     /// <param name="sortedData">Sorted array to search in.</param>
     /// <param name="item">Item to search for.</param>
     /// <returns>Index of item that equals to item searched for or -1 if none found.</returns>
-    let rec findIndex (sortedData : IComparable[], item : int) =
+    let rec findIndex (sortedData: IComparable [], item: int) =
 
         let left = 0
         let right = sortedData.Length - 1
@@ -29,6 +30,6 @@ module BinarySearch =
         let currentItem = sortedData.[middle]
 
         match currentItem with
-        | c when c.CompareTo(sortedData.[middle]) > item -> findIndex(sortedData, item)
-        | c when c.CompareTo(sortedData.[middle]) < item -> findIndex(sortedData, item)
-        | _ -> item
+        | c when c.CompareTo(sortedData.[middle]) > item -> findIndex (sortedData, item)
+        | c when c.CompareTo(sortedData.[middle]) < item -> findIndex (sortedData, item)
+        | _ -> item

Algorithms/Sort/Bubble_Sort.fs

@@ -1,17 +1,16 @@
 namespace Algorithms.Sort
 
 module BubbleSort =
-    let rec Sort list: 'T[] =
+    let rec Sort list: 'T [] =
         let mutable updated = false
         let mutable list = list |> Array.copy
-        for index in 0..list.Length - 1 do
+        for index in 0 .. list.Length - 1 do
             if index < list.Length - 1 then
                 let current = list.[index]
                 let next = list.[index + 1]
                 if next < current then
                     list.[index] <- next
                     list.[index + 1] <- current
                     updated <- true
-        if updated then
-            list <- Sort list
+        if updated then list <- Sort list
         list

Algorithms/Sort/Comb_Sort.fs

@@ -1,14 +1,13 @@
 namespace Algorithms.Sort
 
 module CombSort =
-    let Sort list: 'T[] =
+    let Sort list: 'T [] =
         let mutable list = list |> Array.copy
         let mutable gap = double list.Length
         let mutable swaps = true
         while gap > 1.0 || swaps do
             gap <- gap / 1.247330950103979
-            if gap < 1.0 then
-                gap <- 1.0
+            if gap < 1.0 then gap <- 1.0
             let mutable i = 0
             swaps <- false
             while i + int gap < list.Length do

Algorithms/Sort/Cycle_Sort.fs

@@ -1,15 +1,14 @@
 namespace Algorithms.Sort
 
 module CycleSort =
-    let Sort list: 'T[] =
+    let Sort list: 'T [] =
         let mutable list = list |> Array.copy
         let mutable writes = 0
-        for index in 0..list.Length - 1 do
+        for index in 0 .. list.Length - 1 do
             let mutable value = list.[index]
             let mutable pos = index
-            for i in index + 1..list.Length - 1 do
-                if list.[i] < value then
-                    pos <- pos + 1
+            for i in index + 1 .. list.Length - 1 do
+                if list.[i] < value then pos <- pos + 1
             if pos <> index then
                 while value = list.[pos] do
                     pos <- pos + 1
@@ -19,9 +18,8 @@ module CycleSort =
                 writes <- writes + 1
                 while pos <> index do
                     pos <- index
-                    for i in index + 1..list.Length - 1 do
-                        if list.[i] < value then
-                            pos <- pos + 1
+                    for i in index + 1 .. list.Length - 1 do
+                        if list.[i] < value then pos <- pos + 1
                     while value = list.[pos] do
                         pos <- pos + 1
                     tmp <- list.[pos]

Algorithms/Sort/Gnome_Sort.fs

@@ -1,7 +1,7 @@
 namespace Algorithms.Sort
 
 module GnomeSort =
-    let Sort list: 'T[] =
+    let Sort list: 'T [] =
         let mutable list = list |> Array.copy
         let mutable first = 1
         let mutable second = 2

Algorithms/Sort/Heap_Sort.fs

@@ -1,24 +1,29 @@
 namespace Algorithms.Sort
 
 module HeapSort =
-    let inline swap (a: 'T[]) i j =
+    let inline swap (a: 'T []) i j =
         let temp = a.[i]
         a.[i] <- a.[j]
         a.[j] <- temp
- 
-    let inline sift cmp (a: 'T[]) start count =
+
+    let inline sift cmp (a: 'T []) start count =
         let rec loop root child =
             if root * 2 + 1 < count then
-                let p = child < count - 1 && cmp a.[child] a.[child + 1] < 0
+                let p =
+                    child < count
+                    - 1
+                    && cmp a.[child] a.[child + 1] < 0
+
                 let child = if p then child + 1 else child
                 if cmp a.[root] a.[child] < 0 then
                     swap a root child
                     loop child (child * 2 + 1)
+
         loop start (start * 2 + 1)
- 
-    let inline heapsort cmp (a: 'T[]) =
+
+    let inline heapsort cmp (a: 'T []) =
         let n = a.Length
-        for start = n/2 - 1 downto 0 do
+        for start = n / 2 - 1 downto 0 do
             sift cmp a start n
         for term = n - 1 downto 1 do
             swap a term 0

Algorithms/Sort/Insertion_Sort.fs

@@ -1,9 +1,9 @@
 namespace Algorithms.Sort
 
 module InsertionSort =
-    let Sort list: 'T[] =
+    let Sort list: 'T [] =
         let mutable list = list |> Array.copy
-        for index in 1..list.Length - 1 do
+        for index in 1 .. list.Length - 1 do
             let item = list.[index]
             let mutable j = index
             while j > 0 && list.[j - 1] > item do

Algorithms/Sort/Merge_Sort.fs

@@ -4,23 +4,22 @@ module MergeSort =
     let split list =
         let rec aux l acc1 acc2 =
             match l with
-                | [] -> (acc1, acc2)
-                | [x] -> (x::acc1, acc2)
-                | x::y::tail ->
-                    aux tail (x::acc1) (y::acc2)
-        in aux list [] []
-     
+            | [] -> (acc1, acc2)
+            | [ x ] -> (x :: acc1, acc2)
+            | x :: y :: tail -> aux tail (x :: acc1) (y :: acc2)
+
+        aux list [] []
+
     let rec merge l1 l2 =
         match (l1, l2) with
-            | (x, []) -> x
-            | ([], y) -> y
-            | (x::tx, y::ty) ->
-                if x <= y then x::merge tx l2
-                else y::merge l1 ty
+        | (x, []) -> x
+        | ([], y) -> y
+        | (x :: tx, y :: ty) -> if x <= y then x :: merge tx l2 else y :: merge l1 ty
 
-    let rec sort list = 
+    let rec sort list =
         match list with
-            | [] -> []
-            | [x] -> [x]
-            | _ -> let (l1, l2) = split list
-                   in merge (sort l1) (sort l2)
+        | [] -> []
+        | [ x ] -> [ x ]
+        | _ ->
+            let (l1, l2) = split list
+            merge (sort l1) (sort l2)

Algorithms/Sort/Pancake_Sort.fs

@@ -1,20 +1,29 @@
 namespace Algorithms.Sort
 
 module PancakeSort =
-    let show data = data |> Array.iter (printf "%d ") ; printfn ""
-    let split (data: int[]) pos = data.[0..pos], data.[(pos+1)..]
-     
+    let show data =
+        data |> Array.iter (printf "%d ")
+        printfn ""
+
+    let split (data: int []) pos = data.[0..pos], data.[(pos + 1)..]
+
     let flip items pos =
         let lower, upper = split items pos
         Array.append (Array.rev lower) upper
-     
+
     let sort items =
         let rec loop data limit =
-            if limit <= 0 then data
+            if limit <= 0 then
+                data
             else
                 let lower, upper = split data limit
-                let indexOfMax = lower |> Array.findIndex ((=) (Array.max lower))
-                let partialSort = Array.append (flip lower indexOfMax |> Array.rev) upper
-                loop partialSort (limit-1)
-     
-        loop items ((Array.length items)-1)
+
+                let indexOfMax =
+                    lower |> Array.findIndex ((=) (Array.max lower))
+
+                let partialSort =
+                    Array.append (flip lower indexOfMax |> Array.rev) upper
+
+                loop partialSort (limit - 1)
+
+        loop items ((Array.length items) - 1)

Algorithms/Sort/Quick_Sort.fs

@@ -2,11 +2,13 @@ namespace Algorithms.Sort
 
 module QuickSort =
     let Sort lst =
-      let rec aux l cont =
-        match l with
-        | [] -> cont []
-        | pivot::rest ->
-          let left, right = rest |> List.partition(fun i -> i < pivot)
-          aux left (fun acc_left ->
-          aux right (fun acc_right -> cont(acc_left @ pivot::acc_right)))
-      aux lst (fun x -> x)
+        let rec aux l cont =
+            match l with
+            | [] -> cont []
+            | pivot :: rest ->
+                let left, right =
+                    rest |> List.partition (fun i -> i < pivot)
+
+                aux left (fun acc_left -> aux right (fun acc_right -> cont (acc_left @ pivot :: acc_right)))
+
+        aux lst (id)

Algorithms/Strings/RemoveDuplicates.fs

@@ -1,12 +1,11 @@
-namespace Algorithms.Strings
-
-/// <summary>
+/// <summary>
 /// Remove duplicates from sentence
 /// <summary>
+namespace Algorithms.Strings
+
 module RemoveDuplicates =
     let removeDuplicates (string: string) =
         let mutable newString = ""
         for s in string.Split() do
-            if not (newString.Contains s) then
-                newString <- newString + " " + s
-        newString
+            if not (newString.Contains s) then newString <- newString + " " + s
+        newString

Algorithms/Strings/ReverseLetters.fs

@@ -6,11 +6,11 @@ module ReverseLetters =
     /// </summary>
     /// <param name="input">String to reverse.</param>
     /// <returns>Reversed string</returns>
-    let reverseLetters(input: string) =
+    let reverseLetters (input: string) =
         let mutable str = ""
         for phrase in input.Split() do
             let mutable word = ""
             for letter in phrase do
-                word <- word.Insert(0, (string)letter)
+                word <- word.Insert(0, (string) letter)
             str <- str + word + " "
         str

Algorithms/Strings/ReverseWords.fs

@@ -6,8 +6,8 @@ module ReverseWords =
     /// </summary>
     /// <param name="input">String to reverse.</param>
     /// <returns>Reversed string</returns>
-    let reverseWords(input: string) =
+    let reverseWords (input: string) =
         let mutable str = ""
         for i in input.Split() do
             str <- str.Insert(0, i + " ")
-        str
+        str

Algorithms/Strings/Split.fs

@@ -7,14 +7,19 @@ module Split =
     /// <param name="str">String to split into lists</param>
     /// <param name="item">The separator on what you would like to separate your strings</param>
     /// <returns>A string list</returns>
-    let split(str: string, separator: string) =
+    let split (str: string, separator: string) =
         let mutable newStringList = []
         let mutable value = ""
         if str.Contains separator then
             for c in str do
-                match (string)c with
-                | c when c.Contains separator -> newStringList <- newStringList |> List.append <| [value]; value <- ""
-                | _ -> value <- value + (string)c; 
-            if value <> "" then newStringList <- newStringList |> List.append <| [value]; value <- ""
-        else newStringList <- [value]
+                match (string) c with
+                | c when c.Contains separator ->
+                    newStringList <- newStringList |> List.append <| [ value ]
+                    value <- ""
+                | _ -> value <- value + (string) c
+            if value <> "" then
+                newStringList <- newStringList |> List.append <| [ value ]
+                value <- ""
+        else
+            newStringList <- [ value ]
         newStringList

Algorithms/Strings/WordOccurrence.fs

@@ -1,12 +1,13 @@
 namespace Algorithms.Strings
+
 open System.Collections.Generic
 
 module WordOccurence =
-    let wordOccurence (sentence : string) =
+    let wordOccurence (sentence: string) =
         // Creating a dictionary containing count of each word
         let occurence = new Dictionary<string, int>()
         for word in sentence.Split(" ") do
             match word with
             | w when occurence.ContainsKey(w) -> occurence.Item(w) <- occurence.GetValueOrDefault(w) + 1
             | _ -> occurence.Add(word, 1)
-        occurence
+        occurence