Fizz Buzz in Every Language

(define (mult-15? n)
  (and (mult-5? n)
       (mult-3? n)))

(define (mult-5? n)
  (= (modulo n 5) 0))

(define (mult-3? n)
  (= (modulo n 3) 0))

(define (fizzbuzz n)
  (cond
    [(mult-15? n) "FizzBuzz"]
    [(mult-5? n) "Buzz"]
    [(mult-3? n) "Fizz"]
    [else n]))

(define (print-list xs)
  (map displayln xs))

(print-list (map fizzbuzz (range 1 101)))

DECLARE @i INT = 100;

;WITH E1(N) AS (SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL 
                SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL 
                SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1), -- 1*10^1 or 10 rows
      E2(N) AS (SELECT 1 FROM E1 a, E1 b),                                          -- 1*10^2 or 100 rows
      E4(N) AS (SELECT 1 FROM E2 a, E2 b),                                          -- 1*10^4 or 10,000 rows
      E8(N) AS (SELECT 1 FROM E4 a, E4 b),                                          -- 1*10^8 or 100,000,000 rows
cteTally(N) AS (SELECT TOP (@i) ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) FROM E8)

SELECT  CASE WHEN N % 15 = 0 THEN 'fizzbuzz'
             WHEN N % 5 = 0 THEN 'buzz'
             WHEN N % 3 = 0 THEN 'fizz'  
             ELSE CONVERT(VARCHAR(10),N) END
FROM    cteTally

const worder = (predicate, patterner) => (prev, n) =>
  predicate(prev, n)
    ? patterner(prev, n)
    : prev

const isDivisible = d => (_, n) =>
  n % d === 0

const isEmpty = s =>
  s.length === 0

const append = x => (prev) => prev + x

const setNumber = (_, n) => n

const fizzer = worder(isDivisible(3), append('fizz'))

const buzzer = worder(isDivisible(5), append('buzz'))

const numberer = worder(isEmpty, setNumber)

const reducer = (...worders) => n =>
  worders.reduce(
    (prev, w) => w(prev, n),
    ''
  )

const fizzbuzzer = reducer(
  fizzer,
  buzzer,
  numberer
)

for (let i = 0; i <= 100; i++) {
  console.log(fizzbuzzer(i))
}

const fazzer = worder(isDivisible(7), append('fazz'))

const fizzbuzzfazzer = reducer(
  fizzer,
  buzzer,
  fazzer,
  numberer
)

1..100
|> Enum.map(fn
  n when rem(n, 3) == 0 and rem(n, 5) == 0 -> "FizzBuzz"
  n when rem(n, 3) == 0 -> "Fizz"
  n when rem(n, 5) == 0 -> "Buzz"
  n -> Integer.to_string(n)
end)
|> Enum.each(&IO.puts/1)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace FizzBuzz
{
    static class Program
    {
        static void Main(string[] args)
        {
            var buzzMap = new Dictionary<int, string>
            {
                { 3, "Fizz" },
                { 5, "Buzz" },
            };

            Func<int, string> buzzer = i =>
            {
                var buzzed = buzzMap.Keys
                    .Where(k => i % k == 0)
                    .Select(k => buzzMap[k]);

                return buzzed.Any() ? buzzed.Aggregate((prev, next) => prev += next) : null;
            };

            var output = Enumerable.Range(1, 100)
                .Select(i => buzzer(i) ?? i.ToString())
                .Aggregate(new StringBuilder(), (sb, s) => sb.AppendLine(s))
                .ToString();

            Console.WriteLine(output);
        }
    }
}

(defun divides (divisor dividend)
  (= (mod divisor dividend) 0))

(defun fizzbuzz (n)
  (let ((fizz (when (divides n 3) "Fizz"))
        (buzz (when (divides n 5) "Buzz")))
    (if (or fizz buzz)
        (concatenate 'string fizz buzz)
        (write-to-string n))))

(defun divides (divisor dividend)
  (= (mod divisor dividend) 0))

(defmacro define-fizzbuzzer (name &body pairs)
  `(defun ,name (n)
     (let ((result nil))
       (dolist (p ',pairs)
         (let ((test-passed? (if (typep (first p) 'integer)
                                 (divides n (first p))
                                 (funcall (eval (first p)) n))))
           (when test-passed? (push (second p) result))))
       (if (null result)
           (write-to-string n)
           (apply #'concatenate 'string (nreverse result))))))

(define-fizzbuzzer fizz-buzz
  (3 "Fizz")
  (5 "Buzz"))

(define-fizzbuzzer fizz-buzz-bazz
  (3 "Fizz")
  (5 "Buzz")
  (7 "Bazz"))

(defmacro define-fizzbuzzer (name &body pairs)
  (let ((ps (clean-args pairs)))
    `(defun ,name (n)
       (let ((result nil))
         (dolist (p ',ps)
           (let ((test-passed? (funcall (eval (first p)) n)))
             (when test-passed? (push (second p) result))))
         (if (null result)
             (write-to-string n)
             (apply #'concatenate 'string (nreverse result)))))))

(defun clean-args (pairs)
  (mapcar #'clean-pair pairs))

(defun clean-pair (pair)
  (cond ((typep (first pair) 'integer)
         (list '#'(lambda (n) (divides n (first pair))) (second pair)))
        ((eq (caar pair) 'function)
         pair)
        (t (error "first element of pair must be either an integer or a function"))))

(defun prime? (n)
  "evaluates to t when n is prime. Highly inefficient"
  (loop for x from 2 to (round n 2) never (divides n x)))

(defun has-a-nine-in-it? (n)
 "does the decimal representation of this number have a 9 in it?"
 (some #'(lambda (c) (char= c #\9)) (write-to-string n)))

(define-fizzbuzzer fizz-buzz
  (3 "Fizz")
  (5 "Buzz"))

(define-fizzbuzzer fazz-bazz
  (#'prime? "Fazz")
  (#'has-a-nine-in-it? "Bazz"))

    print('\n'.join(['FizzBuzz' if x % 15 == 0 else 'Fizz' if x % 3 == 0 else 'Buzz' if x % 5 == 0 else str(x) for x in range(1,101)]))

<p id="target"></p>

let target = document.getElementById("target");

for(let i = 1; i <= 100; i++) {
  if( i % 5 == 0 && i % 3 == 0 ) {
    target.innerHTML += "FizzBuzz<br>";
  } else if( i % 5 == 0 ) {
    target.innerHTML += "Fizz<br>";
  } else if( i % 3 == 0) {
    target.innerHTML += "Buzz<br>";
  } else {
    target.innerHTML += i + "<br>";
  }
}

{(‘FizzBuzz’ ‘Fizz’ ‘Buzz’,⍵)[(0=15 3 5|⍵)⍳1]}¨⍳100

package main

import (
    "fmt"
)

func main() {
    for num := 1; num < 101; num++ {
        if num % 3 != 0 && num % 5 != 0 {
            fmt.Println(num)
            continue
        }
        if num % 3 == 0 {
            fmt.Print("Fizz")
        }
        if num % 5 == 0 {
            fmt.Print("Buzz")
        }
        fmt.Println()
    }
}