Highly Modular FizzBuzz, F# - rextester

Run Code | API | Code Wall | Misc | Feedback | Login | Theme | Privacy | Patreon

Highly Modular FizzBuzz

Language: Layout:

//F# Compiler for F# 4.0 (Open Source Edition), Mono 4.2.1

open System

type FBRuleType = 
| MultipleOf of int
| After of int
| Before of int
| EqualTo of int
| CustomRule of (int -> bool)
| Or of FBRuleType list
| And of FBRuleType list
type FBRule = FBRuleType * string

let determineFB num rule = //Determines if a number matches a given rule type
    let rec loop rl =
        match rl with
        | MultipleOf i -> num % i = 0
        | After i -> num > i
        | Before i -> num < i
        | EqualTo i -> num = i
        | CustomRule fn -> fn num
        | Or lis ->
            lis
            |> List.map (fun r -> loop r)
            |> List.contains true
        | And lis ->
            lis
            |> List.map (fun r -> loop r)
            |> List.contains false
            |> not
    loop rule

let FBString num (rules: FBRule list) = //Matches a number to a list of rules
    List.fold (fun acc i -> 
        match i with 
        | (rule, value) ->
            if determineFB num rule then
                acc + value
            else acc
        ) "" rules

let calcFB num rules = //Determines if a rule was matched or not
    match FBString num rules with
    | "" -> string num
    | a -> a
      
      
      
        
let runRuleset ruleset =
    printfn "\n\nTesting ruleset %A" ruleset
    for i in 1..75 do
        calcFB i ruleset |> printfn "%s"
        
runRuleset [(MultipleOf 3, "Fizz"); (MultipleOf 5, "Buzz")] //%3 -> Fizz; %5 -> Buzz
runRuleset [(MultipleOf 3, "Fizz"); (MultipleOf 5, "Buzz"); (And [MultipleOf 4; After 10], "Wack")] //%3 -> Fizz; %5 -> Buzz; (%4 & >10) -> Wack
runRuleset [(Or [MultipleOf 4; And [MultipleOf 3; MultipleOf 5]], "Hey"); (CustomRule (fun i -> i % 4 = 0 || (i % 3 = 0 && i % 5 = 0)), "Now")] //(%4 | (%3 & %5)) -> Hey; (%4 | (%3 & %5)) -> Now
runRuleset [(Or [MultipleOf 3; EqualTo 10; And [After 50; MultipleOf 2]; Or [Before 5; EqualTo 5; MultipleOf 10]], "Wow")] //(%3 | =10 | (>50 & %2) | (<5 | =5 | %10)) -> Wow

Show compiler warnings [ + ] Show input
Compilation time: 3.88 sec, absolute running time: 0.41 sec, cpu time: 0.48 sec, memory peak: 14 Mb, absolute service time: 4,3 sec

edit mode | history | discussion


Testing ruleset [(MultipleOf 3, "Fizz"); (MultipleOf 5, "Buzz")]
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz


Testing ruleset [(MultipleOf 3, "Fizz"); (MultipleOf 5, "Buzz");
 (And [MultipleOf 4; After 10], "Wack")]
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
FizzWack
13
14
FizzBuzz
Wack
17
Fizz
19
BuzzWack
Fizz
22
23
FizzWack
Buzz
26
Fizz
Wack
29
FizzBuzz
31
Wack
Fizz
34
Buzz
FizzWack
37
38
Fizz
BuzzWack
41
Fizz
43
Wack
FizzBuzz
46
47
FizzWack
49
Buzz
Fizz
Wack
53
Fizz
Buzz
Wack
Fizz
58
59
FizzBuzzWack
61
62
Fizz
Wack
Buzz
Fizz
67
Wack
Fizz
Buzz
71
FizzWack
73
74
FizzBuzz


Testing ruleset [(Or [MultipleOf 4; And [MultipleOf 3; MultipleOf 5]], "Hey");
 (CustomRule <fun:clo@59>, "Now")]
1
2
3
HeyNow
5
6
7
HeyNow
9
10
11
HeyNow
13
14
HeyNow
HeyNow
17
18
19
HeyNow
21
22
23
HeyNow
25
26
27
HeyNow
29
HeyNow
31
HeyNow
33
34
35
HeyNow
37
38
39
HeyNow
41
42
43
HeyNow
HeyNow
46
47
HeyNow
49
50
51
HeyNow
53
54
55
HeyNow
57
58
59
HeyNow
61
62
63
HeyNow
65
66
67
HeyNow
69
70
71
HeyNow
73
74
HeyNow


Testing ruleset [(Or
    [MultipleOf 3; EqualTo 10; And [After 50; MultipleOf 2];
     Or [Before 5; EqualTo 5; MultipleOf 10]], "Wow")]
Wow
Wow
Wow
Wow
Wow
Wow
7
8
Wow
Wow
11
Wow
13
14
Wow
16
17
Wow
19
Wow
Wow
22
23
Wow
25
26
Wow
28
29
Wow
31
32
Wow
34
35
Wow
37
38
Wow
Wow
41
Wow
43
44
Wow
46
47
Wow
49
Wow
Wow
Wow
53
Wow
55
Wow
Wow
Wow
59
Wow
61
Wow
Wow
Wow
65
Wow
67
Wow
Wow
Wow
71
Wow
73
Wow
Wow

λ

                                      .NET NoSQL database for rapid development