Skip to content

Instantly share code, notes, and snippets.

@mgarciaisaia
Created May 10, 2023 16:04
Show Gist options
  • Save mgarciaisaia/dd997b2e1e3179526715fccaf9e9e8be to your computer and use it in GitHub Desktop.
Save mgarciaisaia/dd997b2e1e3179526715fccaf9e9e8be to your computer and use it in GitHub Desktop.
Asking ChatGPT for a FizzBuzz example

Me: can you write a fizzbuzz function in ruby?

Certainly! Here's an example of a FizzBuzz function written in Ruby:

def fizzbuzz(n)
  (1..n).each do |num|
    if num % 3 == 0 && num % 5 == 0
      puts "FizzBuzz"
    elsif num % 3 == 0
      puts "Fizz"
    elsif num % 5 == 0
      puts "Buzz"
    else
      puts num
    end
  end
end

# Example usage
fizzbuzz(15)

In this function, the fizzbuzz method takes an integer n as an argument and loops from 1 to n. It checks if each number is divisible by 3 and 5 (using the modulo operator %), and prints "FizzBuzz" if it is. If the number is only divisible by 3, it prints "Fizz". If it's only divisible by 5, it prints "Buzz". If none of these conditions are met, it simply prints the number itself.

Me: can you innecessarilly over-engineer it?

Certainly! Here's an over-engineered version of the FizzBuzz function in Ruby:

class FizzBuzz
  def initialize(rules)
    @rules = rules
  end

  def apply(number)
    result = ""
    @rules.each do |rule|
      if rule.condition.call(number)
        result += rule.output
      end
    end
    result.empty? ? number : result
  end
end

class FizzBuzzRule
  attr_reader :condition, :output

  def initialize(condition, output)
    @condition = condition
    @output = output
  end
end

def fizzbuzz(n)
  fizz_buzz = FizzBuzz.new([
    FizzBuzzRule.new(lambda { |num| num % 3 == 0 && num % 5 == 0 }, "FizzBuzz"),
    FizzBuzzRule.new(lambda { |num| num % 3 == 0 }, "Fizz"),
    FizzBuzzRule.new(lambda { |num| num % 5 == 0 }, "Buzz")
  ])

  (1..n).each do |num|
    puts fizz_buzz.apply(num)
  end
end

# Example usage
fizzbuzz(15)

In this over-engineered version, we introduce the FizzBuzz class to encapsulate the FizzBuzz logic. It takes an array of FizzBuzzRule objects during initialization. Each FizzBuzzRule consists of a condition (a lambda function) and an output string.

The apply method in the FizzBuzz class iterates through the rules and checks each rule's condition against the given number. If a condition is satisfied, the rule's output is appended to the result string. If none of the conditions are satisfied, the original number is returned.

The purpose of this over-engineered version is to showcase a more extensible and modular approach. Additional rules can be added easily without modifying the core logic of the FizzBuzz function. However, for the simple FizzBuzz problem, this level of complexity may not be necessary.

Me: now make it java

Certainly! Here's the FizzBuzz function implemented in Java:

import java.util.function.Predicate;

class FizzBuzzRule {
    private Predicate<Integer> condition;
    private String output;

    public FizzBuzzRule(Predicate<Integer> condition, String output) {
        this.condition = condition;
        this.output = output;
    }

    public Predicate<Integer> getCondition() {
        return condition;
    }

    public String getOutput() {
        return output;
    }
}

public class FizzBuzz {
    private FizzBuzzRule[] rules;

    public FizzBuzz(FizzBuzzRule[] rules) {
        this.rules = rules;
    }

    public String apply(int number) {
        StringBuilder result = new StringBuilder();
        for (FizzBuzzRule rule : rules) {
            if (rule.getCondition().test(number)) {
                result.append(rule.getOutput());
            }
        }
        return result.length() > 0 ? result.toString() : Integer.toString(number);
    }

    public void runFizzBuzz(int n) {
        for (int i = 1; i <= n; i++) {
            System.out.println(apply(i));
        }
    }

    public static void main(String[] args) {
        FizzBuzzRule[] rules = {
                new FizzBuzzRule(num -> num % 3 == 0 && num % 5 == 0, "FizzBuzz"),
                new FizzBuzzRule(num -> num % 3 == 0, "Fizz"),
                new FizzBuzzRule(num -> num % 5 == 0, "Buzz")
        };

        FizzBuzz fizzBuzz = new FizzBuzz(rules);
        fizzBuzz.runFizzBuzz(15);
    }
}

In this Java implementation, we have a FizzBuzzRule class that encapsulates the condition and output for each rule. The FizzBuzz class has an array of FizzBuzzRule objects, and the apply method applies the rules to a given number and returns the corresponding output.

The runFizzBuzz method is used to iterate from 1 to n and print the output for each number. Finally, in the main method, we create an array of FizzBuzzRule objects, initialize a FizzBuzz instance with those rules, and call the runFizzBuzz method to execute the FizzBuzz logic for a given range of numbers (in this case, 1 to 15).

Me: can you add some factories and builders here and there to make it look more entreprise-y (even if it's just bloating the code)?

Certainly! Here's an updated version with some factories and builders added to make it look more "enterprise-y" even though it might bloat the code unnecessarily:

import java.util.function.Predicate;

class FizzBuzzRule {
    private Predicate<Integer> condition;
    private String output;

    public FizzBuzzRule(Predicate<Integer> condition, String output) {
        this.condition = condition;
        this.output = output;
    }

    public Predicate<Integer> getCondition() {
        return condition;
    }

    public String getOutput() {
        return output;
    }

    // FizzBuzzRule builder
    public static class Builder {
        private Predicate<Integer> condition;
        private String output;

        public Builder condition(Predicate<Integer> condition) {
            this.condition = condition;
            return this;
        }

        public Builder output(String output) {
            this.output = output;
            return this;
        }

        public FizzBuzzRule build() {
            return new FizzBuzzRule(condition, output);
        }
    }
}

public class FizzBuzz {
    private FizzBuzzRule[] rules;

    public FizzBuzz(FizzBuzzRule[] rules) {
        this.rules = rules;
    }

    public String apply(int number) {
        StringBuilder result = new StringBuilder();
        for (FizzBuzzRule rule : rules) {
            if (rule.getCondition().test(number)) {
                result.append(rule.getOutput());
            }
        }
        return result.length() > 0 ? result.toString() : Integer.toString(number);
    }

    public void runFizzBuzz(int n) {
        for (int i = 1; i <= n; i++) {
            System.out.println(apply(i));
        }
    }

    // FizzBuzz builder
    public static class Builder {
        private FizzBuzzRule[] rules;

        public Builder rules(FizzBuzzRule... rules) {
            this.rules = rules;
            return this;
        }

        public FizzBuzz build() {
            return new FizzBuzz(rules);
        }
    }

    public static void main(String[] args) {
        FizzBuzzRule rule1 = new FizzBuzzRule.Builder()
                .condition(num -> num % 3 == 0 && num % 5 == 0)
                .output("FizzBuzz")
                .build();

        FizzBuzzRule rule2 = new FizzBuzzRule.Builder()
                .condition(num -> num % 3 == 0)
                .output("Fizz")
                .build();

        FizzBuzzRule rule3 = new FizzBuzzRule.Builder()
                .condition(num -> num % 5 == 0)
                .output("Buzz")
                .build();

        FizzBuzz fizzBuzz = new FizzBuzz.Builder()
                .rules(rule1, rule2, rule3)
                .build();

        fizzBuzz.runFizzBuzz(15);
    }
}

In this updated version, we have added builder classes for FizzBuzzRule and FizzBuzz to facilitate their construction. The FizzBuzzRule.Builder allows you to set the condition and output for a rule and then build the FizzBuzzRule object. The FizzBuzz.Builder allows you to set the rules for a FizzBuzz instance and build it.

The main method now uses the builders to create the FizzBuzzRule objects and the FizzBuzz instance. This approach adds a bit more code complexity and introduces the concept of builders for creating objects, which is often seen in enterprise-level codebases.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment