Tag Archives: fizzbuzz

Monoidal FizzBuzz In Scala

2014/05/25 domfox

I am truly sorry…

import scalaz._

object Main {

  case class FizzBuzz(elems: String*)

  implicit object FizzBuzzMonoid extends Monoid[FizzBuzz] {
    override def zero = FizzBuzz()
    override def append(f1: FizzBuzz, f2: => FizzBuzz): FizzBuzz = FizzBuzz(f1.elems ++ f2.elems :_*)
  }

  implicit object FuzzBuzzShow extends Show[FizzBuzz] {
    override def shows(f1: FizzBuzz): String = f1.elems.mkString("")
  }

  def interpreter(name: String, cond: Int => Boolean): Int => FizzBuzz = i =>
    if (cond(i)) FizzBuzz(name) else FizzBuzzMonoid.zero

  val fizz = interpreter("fizz", (i: Int) => (i % 3) == 0)
  val buzz = interpreter("buzz", (i: Int) => (i % 5) == 0)

  def fizzBuzzer[T](interpreters: (Int => T)*)(implicit m: Monoid[T], s: Show[T]): Int => String = i => {
    val interpreted: T = interpreters.map(_.apply(i)).fold(m.zero)(m.append(_, _))
    if (interpreted == m.zero) i.toString else s.shows(interpreted)
  }

  def main(args: Array[String]) {
    (1 to 100).map(fizzBuzzer(fizz, buzz)).foreach(println)
  }

}

import scalaz._

object Main {

case class FizzBuzz(elems: String*)

implicit object FizzBuzzMonoid extends Monoid[FizzBuzz] {

override def zero = FizzBuzz()

override def append(f1: FizzBuzz, f2: => FizzBuzz): FizzBuzz = FizzBuzz(f1.elems ++ f2.elems :_*)

}

implicit object FuzzBuzzShow extends Show[FizzBuzz] {

override def shows(f1: FizzBuzz): String = f1.elems.mkString("")

}

def interpreter(name: String, cond: Int => Boolean): Int => FizzBuzz = i =>

if (cond(i)) FizzBuzz(name) else FizzBuzzMonoid.zero

val fizz = interpreter("fizz", (i: Int) => (i % 3) == 0)

val buzz = interpreter("buzz", (i: Int) => (i % 5) == 0)

def fizzBuzzer[T](interpreters: (Int => T)*)(implicit m: Monoid[T], s: Show[T]): Int => String = i => {

val interpreted: T = interpreters.map(_.apply(i)).fold(m.zero)(m.append(_, _))

if (interpreted == m.zero) i.toString else s.shows(interpreted)

}

def main(args: Array[String]) {

(1 to 100).map(fizzBuzzer(fizz, buzz)).foreach(println)

}

Java 8

Monoidal FizzBuzz

2014/05/23 domfox

package com.codepoetics.fizzbuzz.monoidal;

import java.util.function.Function;

public class MonoidalFizzBuzz<T, I extends Interpreter<T>, M extends Monoid<T>, R extends Representation<T>> implements Function<Integer, String> {

    private final I interpreter;
    private final M monoid;
    private final R representable;

    public MonoidalFizzBuzz(I interpreter, M monoid, R representable) {
        this.interpreter = interpreter;
        this.monoid = monoid;
        this.representable = representable;
    }

    @Override
    public String apply(Integer integer) {
        T product = interpreter.interpret(integer)
                               .stream()
                               .reduce(monoid.zero(), monoid::product);
        return product.equals(monoid.zero()) ? integer.toString() : representable.represent(product);
    }

    public static void main(String[] argv) {
        Function<Integer, String> mfb = new MonoidalFizzBuzz<>(
                FizzBuzz.interpreter,
                FizzBuzz.monoid,
                FizzBuzz.representation);

        for (int i=1; i<=100; i++) {
            System.out.println(mfb.apply(i));
        }
    }
}

package com.codepoetics.fizzbuzz.monoidal;

import java.util.function.Function;

public class MonoidalFizzBuzz<T, I extends Interpreter<T>, M extends Monoid<T>, R extends Representation<T>> implements Function<Integer, String> {

private final I interpreter;

private final M monoid;

private final R representable;

public MonoidalFizzBuzz(I interpreter, M monoid, R representable) {

this.interpreter = interpreter;

this.monoid = monoid;

this.representable = representable;

}

@Override

public String apply(Integer integer) {

T product = interpreter.interpret(integer)

.stream()

.reduce(monoid.zero(), monoid::product);

return product.equals(monoid.zero()) ? integer.toString() : representable.represent(product);

}

public static void main(String[] argv) {

Function<Integer, String> mfb = new MonoidalFizzBuzz<>(

FizzBuzz.interpreter,

FizzBuzz.monoid,

FizzBuzz.representation);

for (int i=1; i<=100; i++) {

System.out.println(mfb.apply(i));

}

See the whole thing on github.

clojure, Java 8

Higher-Order FizzBuzz

2014/05/16 domfox 1 Comment

Clojure (paste into an instarepl to see outputs):

(defn condition [pred? term]
  (fn [n] (if (pred? n) term "")))

(def fizz (condition #(zero? (mod % 3)) "fizz"))
(def buzz (condition #(zero? (mod % 5)) "buzz"))

(defn try-conditions [&amp; conditions]
  (fn [n] 
    (let [s (apply str (map #(% n) conditions))]
      (if (empty? s) (str n) s))))

(def fizzbuzz (try-conditions fizz buzz))
(def buzzfizz (try-conditions buzz fizz))

(map fizzbuzz (range 1 100))

(map buzzfizz (range 1 100))

(def bang (condition #(zero? (mod % 7)) "bang"))
(def fizzbuzzbang (try-conditions fizz buzz bang))

(map fizzbuzzbang (range 1 106))

(defn condition [pred? term]

(fn [n] (if (pred? n) term "")))

(def fizz (condition #(zero? (mod % 3)) "fizz"))

(def buzz (condition #(zero? (mod % 5)) "buzz"))

(defn try-conditions [& conditions]

(fn [n]

(let [s (apply str (map #(% n) conditions))]

(if (empty? s) (str n) s))))

(def fizzbuzz (try-conditions fizz buzz))

(def buzzfizz (try-conditions buzz fizz))

(map fizzbuzz (range 1 100))

(map buzzfizz (range 1 100))

(def bang (condition #(zero? (mod % 7)) "bang"))

(def fizzbuzzbang (try-conditions fizz buzz bang))

(map fizzbuzzbang (range 1 106))

Java 8:

public class FizzBuzzEtc {
    private static Function<Integer, String> condition(Predicate<Integer> p, String t) {
        return n -> p.test(n) ? t : "";
    }

    private static Function<Integer, String> tryConditions(Function<Integer, String>...conditions) {
        return n -> {
            String s = String.join("", Stream.of(conditions).map(c -> c.apply(n)).collect(Collectors.toList()));
            return s.isEmpty() ? Integer.toString(n) : s;
        };
    }

    private static void run(String description, Function<Integer, String>...conditions) {
        System.out.println("\n" + description + ":");
        IntStream.range(1, 106).boxed().map(tryConditions(conditions)).forEach(System.out::println);
    }

    public static void main(String[] argv) {
        Function<Integer, String> fizz = condition(n -> (n % 3) == 0, "fizz");
        Function<Integer, String> buzz = condition(n -> (n % 5) == 0, "buzz");
        Function<Integer, String> bang = condition(n -> (n % 7) == 0, "bang");

        run("FIZZBUZZ", fizz, buzz);
        run("BUZZFIZZ", buzz, fizz);
        run("FIZZBUZZBANG", fizz, buzz, bang);
    }
}

public class FizzBuzzEtc {

private static Function<Integer, String> condition(Predicate<Integer> p, String t) {

return n -> p.test(n) ? t : "";

}

private static Function<Integer, String> tryConditions(Function<Integer, String>...conditions) {

return n -> {

String s = String.join("", Stream.of(conditions).map(c -> c.apply(n)).collect(Collectors.toList()));

return s.isEmpty() ? Integer.toString(n) : s;

};

}

private static void run(String description, Function<Integer, String>...conditions) {

System.out.println("\n" + description + ":");

IntStream.range(1, 106).boxed().map(tryConditions(conditions)).forEach(System.out::println);

}

public static void main(String[] argv) {

Function<Integer, String> fizz = condition(n -> (n % 3) == 0, "fizz");

Function<Integer, String> buzz = condition(n -> (n % 5) == 0, "buzz");

Function<Integer, String> bang = condition(n -> (n % 7) == 0, "bang");

run("FIZZBUZZ", fizz, buzz);

run("BUZZFIZZ", buzz, fizz);

run("FIZZBUZZBANG", fizz, buzz, bang);

}

Conclusion: Java 8 is an acceptable functional programming language.

poetix

Tag Archives: fizzbuzz

Monoidal FizzBuzz In Scala

Monoidal FizzBuzz

Higher-Order FizzBuzz

opting out of the ordinary human real