-- FizzBuzz Haskellilla
-- (C) ane 2011 <ane@iki.fi>

module Main where

fizzBuzzes :: [Either String Int]
fizzBuzzes = map fizzBuzz [1..]
  where
    fizzBuzz x | x `rem` 3 == 0 && x `rem` 5 == 0 = Left "FizzBuzz"
               | x `rem` 3 == 0 = Left "Fizz"
               | x `rem` 5 == 0 = Left "Buzz"
               | otherwise = Right x

printFizzBuzz :: Either String Int -> IO ()
printFizzBuzz fb = case fb of
                     Left s -> putStrLn s
                     Right x -> print x

main = mapM printFizzBuzz (take 50 fizzBuzzes)

ainakin gcc 4.5.2:n mielestä tämä on C:tä:

main(){int i=0;for(;i++<100;)(i%3&&i%5)?printf("%i ",i):printf("%s%s ",i%3?"":"Fizz",i%5?"":"Buzz");}

Tämmönen siistitty Java-versio tästä ratkaisusta.

public class FizzBuzz {
  public static void main(String[] args){
    System.out.println("1");
    System.out.println("2");
    System.out.println("Fizz");
    System.out.println("4");
    System.out.println("Buzz");
    System.out.println("Fizz");
    System.out.println("7");
    System.out.println("8");
    System.out.println("Fizz");
    System.out.println("Buzz");
    System.out.println("11");
    System.out.println("Fizz");
    System.out.println("13");
    System.out.println("14");
    System.out.println("FizzBuzz");
    System.out.println("16");
    System.out.println("17");
    System.out.println("Fizz");
    System.out.println("19");
    System.out.println("Buzz");
    System.out.println("Fizz");
    System.out.println("22");
    System.out.println("23");
    System.out.println("Fizz");
    System.out.println("Buzz");
    System.out.println("26");
    System.out.println("Fizz");
    System.out.println("28");
    System.out.println("29");
    System.out.println("FizzBuzz");
    System.out.println("31");
    System.out.println("32");
    System.out.println("Fizz");
    System.out.println("34");
    System.out.println("Buzz");
    System.out.println("Fizz");
    System.out.println("37");
    System.out.println("38");
    System.out.println("Fizz");
    System.out.println("Buzz");
    System.out.println("41");
    System.out.println("Fizz");
    System.out.println("43");
    System.out.println("44");
    System.out.println("FizzBuzz");
    System.out.println("46");
    System.out.println("47");
    System.out.println("Fizz");
    System.out.println("49");
    System.out.println("Buzz");
    System.out.println("Fizz");
    System.out.println("52");
    System.out.println("53");
    System.out.println("Fizz");
    System.out.println("Buzz");
    System.out.println("56");
    System.out.println("Fizz");
    System.out.println("58");
    System.out.println("59");
    System.out.println("FizzBuzz");
    System.out.println("61");
    System.out.println("62");
    System.out.println("Fizz");
    System.out.println("64");
    System.out.println("Buzz");
    System.out.println("Fizz");
    System.out.println("67");
    System.out.println("68");
    System.out.println("Fizz");
    System.out.println("Buzz");
    System.out.println("71");
    System.out.println("Fizz");
    System.out.println("73");
    System.out.println("74");
    System.out.println("FizzBuzz");
    System.out.println("76");
    System.out.println("77");
    System.out.println("Fizz");
    System.out.println("79");
    System.out.println("Buzz");
    System.out.println("Fizz");
    System.out.println("82");
    System.out.println("83");
    System.out.println("Fizz");
    System.out.println("Buzz");
    System.out.println("86");
    System.out.println("Fizz");
    System.out.println("88");
    System.out.println("89");
    System.out.println("FizzBuzz");
    System.out.println("91");
    System.out.println("92");
    System.out.println("Fizz");
    System.out.println("94");
    System.out.println("Buzz");
    System.out.println("Fizz");
    System.out.println("97");
    System.out.println("98");
    System.out.println("Fizz");
    System.out.println("Buzz");
  }
}

// C#
// Ziticca

class FizzBuzz
{
    static void Main(string[] args)
    {
        for (int i = 1; i <= 100; i++)
        {
            System.Console.WriteLine(( i % 5 == 0 && i % 3 == 0 ) ? "FizzBuzz" : (i % 3 == 0) ? "Fizz" : ( i % 5 == 0) ? "Buzz" : i.ToString());   
        }
    }
}

for i in [1...100]
  s = ""
  s += "Fizz" if i % 3 is 0
  s += "Buzz" if i % 5 is 0
  alert if s then s else i

C FIZZBUZZ && FORTRAN77
C CAPS LOCK IS CRUISE CONTROL FOR COOL 8-)
       IMPLICIT INTEGER(I,N)
       N=100
       I=0
10     IF(MOD(I,15).EQ.0) THEN
           PRINT *, "FIZZBUZZ"
       ELSE IF(MOD(I,3).EQ.0) THEN
           PRINT *, "FIZZ"
       ELSE IF(MOD(I,5).EQ.0) THEN
           PRINT *, "BUZZ"
       ELSE
           PRINT *, I
       END IF
       IF(I.LT.100) THEN
           I=I+1
           GOTO 10
       END IF
       STOP
       END

%Nopea Matlab-oksennus
%Snjoo

function f = fizzbuzz()

for i=1:100,
	if(mod(i,5))
                if(mod(i,3))
                        disp(int2str(i));
                else
                    	disp('Fizz');
                end
        elseif(mod(i,3))
                disp('Buzz');
        else
            	disp('FizzBuzz');
        end
end
return
end

Ai että, Snjoo kerkes ensin! Pistän silti oman Matlab implementaationi, joka alkaa lupaavasti vektorisaatiolla mutta sitten tuleekin for-luuppi...

asd = (rem(1:100,3)==0) + 2 * (rem(1:100,5)==0);
for i=1:100
    switch asd(i)
        case 1 ;    disp('Fizz')
        case 2 ;    disp('Buzz')
        case 3 ;    disp('FizzBuzz')
        otherwise;  disp(num2str(i))
    end
end

C++ ja boost

// g++ -O3 -Wall -Wextra -Wshadow -Werror -o fizzbuzz fizzbuzz.cpp

#include <iostream>
#include <string>

#include <boost/lexical_cast.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/bind.hpp>


typedef boost::mpl::range_c<int, 1, 100> range_1_100;


static std::string FizzBuzz(int i)
{
	if ((i % 3 == 0) && (i % 5 == 0)) {
        return "FizzBuzz";
	} else if (i % 3 == 0) {
        return "Fizz";
	} else if (i % 5 == 0) {
        return "Buzz";
	}

	return boost::lexical_cast<std::string>(i);
}


struct printFizzBuzz
{
	void operator()(int i)
	{
		std::cout << FizzBuzz(i) << std::endl;
	}
};


int main(int, char **)
{
	boost::mpl::for_each<range_1_100>(printFizzBuzz());
}

-- Toinen korkean tason FizzBuzz
-- Eladith

module FizzBuzz where

multiTest def others x = if null res then [def x] else res
    where res = [ f x | (test,f) <- others, test x ]

fizzbuzz = concat . multiTest show [mk 3 "Fizz", mk 5 "Buzz"]
    where mk x str = ((== 0) . (`mod` x), const str)

main = do 
    print $ map fizzbuzz [1..100]

Tulipas siitä ruma Python-versio näin aamukahvia nenän kautta ryystäessä.

#!/usr/bin/env python
# coding: utf-8
#
# FizzBuzz Python
# (C) 2011 Jorer

def fizzBuzz(n):
    for i in range(1,n+1):
        str = ''
        if i % 3 == 0:
            str += 'Fizz'
        if i % 5 == 0:
            str += 'Buzz'
        if str:
            print str
        else:
            print i

fizzBuzz(100)

<?php
/* Mulle on aina opetettu että luokat on tärkeitä ja niitä pitää
 * käyttää. Käytetään siis! Samalla voisi tottakai hyödyntää
 * PHP:n muitakin mahtavia ominaisuuksia ...
 * Tuomas Virtanen / Katajakasa@IRCNet
 */

define('TYPE_ONE_CHECK', 0x100);
define('TYPE_TWO_CHECKS', 0x101);

interface FizzBuzzInterface {
    public function getValue();
}

class Number implements FizzBuzzInterface {
    private $num;
    
    public function __construct($number) {
        $this->num = $number;
    }
    
    public function getValue() {
        return $this->num;
    }
}

class Fizz implements FizzBuzzInterface {
    public function getValue() {
        return "Fizz";
    }
}

class Buzz implements FizzBuzzInterface {
    public function getValue() {
        return "Buzz";
    }
}

class FizzBuzz implements FizzBuzzInterface {
    public function getValue() {
        return "FizzBuzz";
    }
}

class KatajaFizzBuzz {
    private $rounds;
    private $dostuff;
    
    public function makeTheCallMrsJones($i, $number) {
        if($this->dostuff[$i]['exception']) {
            $obj = new $this->dostuff[$i]['class']($number);
            return $obj->getValue();
        } else {
            $obj = new $this->dostuff[$i]['class']();
            return $obj->getValue();
        }
    }
    
    public function getLine($number) {
        for($i = 0; $i < count($this->dostuff); $i++) {
            if($this->dostuff[$i]['type'] == TYPE_ONE_CHECK) {
                if($number % $this->dostuff[$i]['cmp'] == 0) {
                    return $this->makeTheCallMrsJones($i, $number);
                }
            } elseif($this->dostuff[$i]['type'] == TYPE_TWO_CHECKS) {
                if($number % $this->dostuff[$i]['cmp'][0] == 0
                    && $number % $this->dostuff[$i]['cmp'][1] == 0) {
                    return $this->makeTheCallMrsJones($i, $number);
                }
            }
        }
    }
    
    public function __construct($rounds = 100) {
        $this->rounds = $rounds;
    }
    
    public function getOutput() {
        $this->dostuff = array(
            array(
                'cmp' => array(3,5),
                'type' => TYPE_TWO_CHECKS,
                'class' => "FizzBuzz",
                'exception' => false
            ),
            array(
                'cmp' => 3,
                'type' => TYPE_ONE_CHECK,
                'class' => "Fizz",
                'exception' => false
            ),
            array(
                'cmp' => 5,
                'type' => TYPE_ONE_CHECK,
                'class' => "Buzz",
                'exception' => false
            ),
            array(
                'cmp' => 1,
                'type' => TYPE_ONE_CHECK,
                'class' => "Number",
                'exception' => true
            )
        );
        
        $output = array();
        for($i = 1; $i <= $this->rounds; $i++) {
            $output[] = $this->getLine($i);
        }
        return implode("\n", $output);
    }
}

$omg = new KatajaFizzBuzz();
print $omg->getOutput();
?>

Riittääks jos vaan tulostaa kahteenkymppiin asti

+++++++[>+++++++<-]
+++++++[>>++++++++++<<-]
+++++++[>>>+++++++++++++++<<<-]
++++++++++[>>>>++++++++++++<<<<-]
+++++[>>>>>+++++++++++++<<<<<-]
+++++++++[>>>>>>+++++++++++++<<<<<<-]
+++++++++++++
>.<.>+.<.>>.>.>++..<<<<.>++.<.>>>>>+.>.<<..<<<<.>>.>.>..<<<<.>+++.<.>+.<.>>.>.>..<<<<.>>>>>.>.<<..<<<<.>-------..<.>>.>.>..<<<<.>.++.<.>--.+++.<.>>.>.>..>.>.<<..<<<<.>---.+++++.<.>-----.++++++.<.>>.>.>..<<<<.>------.++++++++.<.>>>>>.>.<<..

Pikaisesti Groovylla :)

(1..100).each {
  println "${it % 3 ? '' : 'Fizz' + (it % 5 ? '' : 'Buzz')}" ?: it
}

for(i=1;i<101;i++){console.log(i%3?i%5?i:"Buzz":i%5?"Fizz":"FizzBuzz")}

Javascriptin voimaa

// FizzBuzz Dart
// by BigMama
main() {
  for (int i = 1; i <= 100; i++) {
      var a = '';
      if (i % 3 == 0) {
        a += "Fizz";
      }
      if (i % 5 == 0) {
        a += "Buzz";
      }    
      print((a == '' ? i : a));
  }
}

http://www.dartlang.org/

<?php
/* Vähän erilainen ratkaisu, jossa vältelty 
 * jakojäännöksen käyttöä...
 * -Cornix */

$fizzCounter = 0;
$buzzCounter = 0;

for ($i=1; $i <= 100; $i++) {
	$fizzCounter++;
	$buzzCounter++;
	$printed = 0;

	if ($fizzCounter == 3) { 
		echo "Fizz";
		$fizzCounter = 0;
		$printed = 1;
	}
	if ($buzzCounter == 5) {
		echo "Buzz";
		$buzzCounter = 0;
		$printed = 1;
	}
	if ($printed == 0) {
		echo "{$i}";
	}

	echo "<br />\n"; // Rivinvaihto. Mukana HTML-tagi, jotta näkyy kivemmin selaimessa. Periaatteessa tuo \n riittäisi.
}
?>

Aiemmat toteutukset Haskellilla eivät miellyttäneet koodisilmääni. Osallistun siis itse tällä:

module Main where

main = mapM printer [1..100]  
printer x = putStrLn $ case (x `rem` 3, x `rem` 5) of
  (0,0) -> "FizzBuzz"
  (0,_) -> "Fizz"
  (_,0) -> "Buzz"
  (_,_) -> show x

-- Joel

Yet Another Haskell FizzBuzz. Veikkaan, ettei jää viimeiseksi.

module Main where

import Control.Monad

main = mapM_ fizzB [1..100]

fizzB i = do 
    let (f,b) = (i%3, i%5)
    when f $ putStr "Fizz"
    when b $ putStr "Buzz"
    unless (f||b) $ putStr . show $ i
    putStr "\n"

i % d = i `rem` d == 0

<?php
$str = 'FizzBuzz';
$int = (int)$str;
while('FizzBuzz')
{
    ($int==intval('1100100',2)) ? exit : $int++;
    $out = ($int%3==0) ? substr($str,0,4):'';
    $out.= ($int%5==0) ? substr($str,4,4):'';
    echo ($out!=false) ? $out."\n":$int."\n";
}
?>

php is lotsa fun.

1.upto(100) do |i|
s = ""
s += "Fizz" if i%3==0
s += "Buzz" if i%5==0
puts i if s.empty?
puts s if !s.empty?
end


ruby

nasm

;Fizzbuzz
;2011 Tuomo Sipola (tuomo.sipola@iki.fi)

	extern printf			;external functions

	SECTION	.data			;put predefined variables here
fizz:		db "Fizz",10,0
buzz:		db "Buzz",10,0
fizzbuzz:	db "FizzBuzz",10,0
number:		db "%d",10,0

	SECTION .text

	global _start			;entry point for program
_start:
	mov	ecx,100			;initialize ecx, how many loops
_loop:
	mov	ebx,101			;numbers from 1 to 100
	sub	ebx,ecx
	push	ecx

	xor	edx,edx
	mov	eax,ebx
	mov	ecx,15
	div	ecx			;current/15
	cmp	edx,0
	jnz	_not_both
	push	dword fizzbuzz
	call	printf
	add	esp,4
	jmp	_continue_loop

_not_both:
	xor	edx,edx
	mov	eax,ebx
	mov	ecx,3
	div	ecx			;current/3
	cmp	edx,0
	jnz	_not_fizz
	push	dword fizz
	call	printf
	add	esp,4
	jmp	_continue_loop

_not_fizz:
	xor	edx,edx
	mov	eax,ebx
	mov	ecx,5
	div	ecx			;current/5
	cmp	edx,0
	jnz	_not_buzz
	push	dword buzz
	call	printf
	add	esp,4
	jmp	_continue_loop

_not_buzz:
	push	ebx
	push	dword number
	call	printf
	add	esp,8

_continue_loop:
	pop	ecx
	loop	_loop			;loop until ecx hits 0

					;EXIT TIME
	mov	eax,1			;set sys_exit
	xor	ebx,ebx 		;return value to 0
	int	128			;make a system call

edit: luettavampi versio

Rumahan siitä tuli.

#!/bin/bash

for i in `seq 1 100`; do
 if [ $(expr "$i" % 15) = 0 ]; then
  echo FizzBuzz
 else
  if [ $(expr "$i" % 3) = 0 ]; then
   echo Fizz
  else
   if [ $(expr "$i" % 5) = 0 ]; then
    echo Buzz
   else
    echo $i
   fi
  fi
 fi
done

Tällä kertaa täysin vektoroitu Matlab -kikkare! Vielä kun pääsis eroon hitaasta cell -tietotyypistä...

lol = 1:100;
isfizz = rem(lol,3)==0;
isbuzz = rem(lol,5)==0;
isboth = isfizz & isbuzz;
asd = cellstr(num2str(lol'));
asd(isfizz) = cellstr('fizz');
asd(isbuzz) = cellstr('buzz');
asd(isboth) = cellstr('fizzbuzz');
disp(char(asd))

FizzBuzz SharePoint web part, by JannuMies

*** Elements.xml ***

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/" >
  <Module Name="FizzBuzz" List="113" Url="_catalogs/wp">
    <File Path="FizzBuzz\FizzBuzz.webpart" Url="FizzBuzz.webpart" Type="GhostableInLibrary" >
      <Property Name="Group" Value="Linkki JKL" />
    </File>
  </Module>
</Elements>

*** FizzBuzzUserControl.ascx.designer.cs ***

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated. 
// </auto-generated>
//------------------------------------------------------------------------------

namespace FizBuzz.FizzBuzz {
    
    
    public partial class FizzBuzzUserControl {
        
        /// <summary>
        /// FizzBuzz control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Panel FizzBuzz;
    }
}

*** FizzBuzz.cs ***

using System;
using System.ComponentModel;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;

namespace FizBuzz.FizzBuzz
{
    [ToolboxItemAttribute(false)]
    public class FizzBuzz : WebPart
    {
        // Visual Studio might automatically update this path when you change the Visual Web Part project item.
        private const string _ascxPath = @"~/_CONTROLTEMPLATES/FizBuzz/FizzBuzz/FizzBuzzUserControl.ascx";

        protected override void CreateChildControls()
        {
            Control control = Page.LoadControl(_ascxPath);
            Controls.Add(control);
        }
    }
}

*** FizzBuzz.webpart ***

<?xml version="1.0" encoding="utf-8"?>
<webParts>
  <webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
    <metaData>
      <type name="FizBuzz.FizzBuzz.FizzBuzz, $SharePoint.Project.AssemblyFullName$" />
      <importErrorMessage>$Resources:core,ImportErrorMessage;</importErrorMessage>
    </metaData>
    <data>
      <properties>
        <property name="Title" type="string">FizzBuzz</property>
        <property name="Description" type="string">FizzBuzz web part</property>
      </properties>
    </data>
  </webPart>
</webParts>

*** FizzBuzzUserControl.ascx ***

<%@ Assembly Name="$SharePoint.Project.AssemblyFullName$" %>
<%@ Assembly Name="Microsoft.Web.CommandUI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> 
<%@ Register Tagprefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> 
<%@ Register Tagprefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register Tagprefix="asp" Namespace="System.Web.UI" Assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" %>
<%@ Import Namespace="Microsoft.SharePoint" %> 
<%@ Register Tagprefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="FizzBuzzUserControl.ascx.cs" Inherits="FizBuzz.FizzBuzz.FizzBuzzUserControl" %>

<asp:Panel runat="server" ID="FizzBuzz">
<%=GetFizzBuzz()%>
</asp:Panel>

*** FizzBuzzUserControl.ascx.cs ***

using System;
using System.Text;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

namespace FizBuzz.FizzBuzz
{
    public partial class FizzBuzzUserControl : UserControl
    {
        protected void Page_Load(object sender, EventArgs e)
        {
        }
        
        public static string GetFizzBuzz()
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 1; i <= 100;i++ )
            {
                sb.Append("<p>");
                if(i%3 == 0)
                {
                    sb.Append("Fizz");
                }
                if(i%5== 0)
                {
                    sb.Append("Buzz");
                }
                if(i%3 != 0 && i%5 != 0)
                {
                    sb.Append(i);
                }
                sb.Append("</p>");
            }
                return sb.ToString();
        }
    }
}

Fizzbuzz-tiedostojärjestelmä käyttäen 9P:tä. Linux sisältää tuen protokollalle versiosta 2.6.14 alkaen, kuvassa kuitenkin Plan 9. Käyttö omalla vastuulla.

-- Main.hs
module Main where

import Control.Monad
import Safe (readMay)
import Data.NineP
import Data.Maybe
import Data.Monoid
import Control.Applicative
import Control.Concurrent.Chan
import Control.Arrow ((&&&))

import Details

-- Itse fizzbuzz deggistä mukaillen
fizzB i = (++ "\n") . fromMaybe (show i) $ ("Fizz" `maybeFz` 3) `mappend` ("Buzz" `maybeFz` 5)
    where maybeFz str x = str <$ guard (i `rem` x == 0)

-- Kaksi tiedostotyyppiä
data IOFile = IOFile (Chan Int)
data ConstFile = ConstFile String


instance RW IOFile where
    -- Odotetaan tiedoston kanavasta saapuvaksi kokonaislukua ja palautetaan fizzbuzz-tulkinta
    -- Palvelin käsittelee jokaisen pyynnön omassa säikeessään, odottavia pyyntöjä voi olla liikkeellä n+1
    read' (IOFile chan) offset count = readChan chan >>= return . fizzB

    -- Koetetaan lukea kokonaisluku. Onnistuessa lähetetään kirjoitettavaksi, muutoin ilmoitetaan 
    -- kirjoituksen epäonnistumisesta
    write' (IOFile chan) msg = f (readMay msg)
        where f (Just i) = writeChan chan i >> (return . Just $ length msg)
              f Nothing = return Nothing

instance RW ConstFile where
    -- Palautetaan pyydetty osa tallennetusta tekstistä
    read' (ConstFile txt) offset count = return $ section txt
        where section = take count . drop offset

    -- Kirjoitusyritykset epäonnistukoot
    write' _ _ = return Nothing


main = do 
    -- Alkuun luodaan suodatinta matkiva tiedosto 
    buzzdev <- addFile "fizzbuzz" . IOFile <$> newChan

    -- Sitten jokunen numeroilla nimetty tiedosto, jotka sisältävät vastaavan fizzbuzz-arvon
    let constFiles = [addFile (show i) (ConstFile (fizzB i)) | i <- [10..20]]

    -- Lopuksi yhdistetään tiedostopuut ja aletaan kuunnella 9P-yhteyksiä
    simpleServer 5556 $ buzzdev : constFiles

Seuraavaksi pikainen tulkinta protokollaspeksistä:

-- Details.hs 
{-# LANGUAGE GADTs, RecordWildCards #-}
module Details (simpleServer, addFile, addDir, FileTree, RW, read', write') where

import qualified Data.ByteString.Lazy.Char8 as C
import qualified Data.ByteString.Lazy as L
import Network.Socket hiding (send, recv)
import Network.Socket.ByteString.Lazy
import Data.Binary.Get
import Data.Binary.Put
import Data.NineP
import Data.Bits
import Data.Word
import Data.Maybe
import Data.List (find)
import Data.Map (Map, (!))
import qualified Data.Map as Map
import Control.Monad
import Control.Applicative
import Control.Concurrent
import Control.Concurrent.MVar
import Control.Arrow ((&&&))

-- Simple read/write interface for files
class RW a where
    read' :: a -> Int -> Int -> IO String
    write' :: a -> String -> IO (Maybe Int)

-- Internal representation of file hierarchy
data FileTree where 
    Dir :: { name :: String, qid :: Qid, children :: [FileTree] } -> FileTree
    Leaf :: RW a => { name :: String, qid :: Qid, file :: a } -> FileTree


    -- Utilities to create a filetree
addFile :: RW a => String -> a -> FileTree
addFile name = Leaf name (Qid 0 0 0)

addDir :: String -> [FileTree] -> FileTree
addDir name = Dir name (Qid 128 0 0)

createTree :: [FileTree] -> FileTree
createTree = Dir "root" (Qid 128 0 0)


-- Generate unique server side id's for files
generateQids :: FileTree -> IO FileTree
generateQids tree = do
    counter <- newMVar 0
    let incr (Qid a b _) = Qid a b <$> modifyMVar counter (return . ((+1) &&& id))
        gen (Dir a b c) = do
            b' <- incr b
            Dir a b' <$> mapM gen c
        gen (Leaf a b c) = do
            b' <- incr b
            return $ Leaf a b' c
    gen tree


-- Maintains pool of file handles and utilities to modify them
data Env = Env { tree :: FileTree, 
                 env :: MVar (Map Fid FileTree),
                 fileFromFid :: Fid -> IO FileTree,
                 insertFid :: Fid -> FileTree -> IO (),
                 deleteFid :: Fid -> IO () }

buildEnv tree env = Env tree env a b c
    where a fid = withMVar env $ return . (! fid)
          b fid file = modifyMVar_ env $ return . Map.insert fid file
          c fid = modifyMVar_ env $ return . Map.delete fid

type Fid = Word32


-- Generate access modes, access times etc.
genStat Dir{..} = dummyStat name qid $ shiftL 128 24 .|. 0o775
genStat Leaf{..} = dummyStat name qid 0o666
dummyStat n q m = Stat 77 31 q m 0 0 0 n "" "" ""


---------------------------------------------------------
-- Incomplete handling of 9P protocol, use at own risk --
---------------------------------------------------------
respond :: Env -> Msg -> IO Msg

-- Shake hands with everyone
respond _ (Msg TTversion tag (Tversion size body)) = return $ Msg TRversion tag $ Rversion size body

-- Free passage
respond _ (Msg TTauth tag (Tauth afid _ _)) = return $ Msg TRerror tag $ Rerror "No authentication required"

-- Show the way to the root of the synthetic filesystem
respond Env{..} (Msg TTattach tag (Tattach fid _ _ _)) = do 
    insertFid fid tree
    return . Msg TRattach tag . Rattach $ qid tree

-- Access basic information about files
respond Env{..} (Msg TTstat tag (Tstat fid)) = Msg TRstat tag . stat <$> fileFromFid fid
    where stat f = Rstat [genStat f]

-- Forget about files no longer accesed
respond Env{..} (Msg TTclunk tag (Tclunk fid)) = do
    deleteFid fid
    return $ Msg TRclunk tag Rclunk

-- Acquire another handle (fid) of current file
respond Env{..} (Msg TTwalk tag (Twalk fid newfid [])) = do
    insertFid newfid =<< fileFromFid fid
    return $ Msg TRwalk tag (Rwalk [])

-- Move in hierarchy, again new fid. Does not handle subdirectories too well
respond Env{..} (Msg TTwalk tag (Twalk fid newfid [path])) = fileFromFid fid >>= reply . findFile path
    where findFile path (Dir _ _ files) = find ((== path) . name) files
          reply (Just file@(Leaf _ qid _)) = do
                insertFid newfid file
                return $ Msg TRwalk tag (Rwalk [qid])
          reply Nothing = return $ Msg TRwalk tag $ Rerror "File not found!"

-- Open a file for access
respond Env{..} (Msg TTopen tag (Topen fid mode)) = do 
    f <- fileFromFid fid
    return $ Msg TRopen tag $ Ropen (qid f) 0

-- Read a file using methods of RW instance
respond Env{..} (Msg TTread tag (Tread fid offset count)) = Msg TRread tag . Rread <$> (readFile =<< fileFromFid fid)
    where readFile (Dir _ _ children) = return . section offset count . runPut . putListAll . map genStat $ children
          readFile (Leaf _ _ file) = C.pack <$> read' file (fromIntegral offset) (fromIntegral count)
          section off n = C.take (fromIntegral n) . C.drop (fromIntegral off)

-- Write to a file using methods of RW instance, offsets ignored
respond Env{..} (Msg TTwrite tag (Twrite fid offset msg)) = reply <$> (writeFile =<< fileFromFid fid)
    where writeFile (Leaf _ _ file) = write' file $ C.unpack msg
          reply (Just n) = Msg TRwrite tag . Rwrite . fromIntegral $ n
          reply Nothing = Msg TRerror tag $ Rerror "Write failed!"

-- Abort request (blocking read for example), unhandled 
respond Env{..} (Msg TTflush tag (Tflush oldtag)) = return $ Msg TRflush tag Rflush

-- In NineP.hs but unexported, used here for serializing directory reads
putListAll :: (Bin a) => [a] -> Put
putListAll = mapM_ put



-- Simple handler, forks a response thread for every request
dummyHandler sock env = forever $ do 
    req <- runGet get <$> recv sock 8096
    forkIO $ respond env req >>= send sock . runPut . put >> return ()

-- Prepare environment for connection and start communicating
runConn tree (sock, _) = do
    env <- newMVar $ Map.fromList []
    tree' <- generateQids . createTree $ tree
    dummyHandler sock (buildEnv tree' env)

simpleServer port tree = withSocketsDo $ do
    sock <- socket AF_INET Stream 0
    setSocketOption sock ReuseAddr 1
    bindSocket sock (SockAddrInet port iNADDR_ANY)
    listen sock 2

    forever $ accept sock >>= forkIO . runConn tree

// g++ -std=c++0x -O3 -Wall -Wextra -Wshadow -Werror -o fizzbuzz fizzbuzz.cpp

#include <iostream>
#include <string>

#include <boost/mpl/arithmetic.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/modulus.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/transform_view.hpp>


typedef boost::mpl::range_c<int, 1, 101> range_1_100;


struct Fizz
{
	constexpr static const char *value = "Fizz";
};


template <typename T> struct FizzSel
	: public boost::mpl::if_<
		boost::mpl::equal_to<
			boost::mpl::modulus<T, boost::mpl::int_<3> >
			, boost::mpl::int_<0>
			>
		, Fizz
		, T
	>::type
{
};


struct Buzz
{
	constexpr static const char *value = "Buzz";
};


template <typename T> struct BuzzSel
	: public boost::mpl::if_<
		boost::mpl::equal_to<
			boost::mpl::modulus<T, boost::mpl::int_<5> >
			, boost::mpl::int_<0>
			>
		, Buzz
		, FizzSel<T>
	>::type
{
};


struct FizzBuzz
{
    constexpr static const char *value = "FizzBuzz";
};


struct FizzBuzzSel
{
	template <typename T> struct apply
	: public boost::mpl::if_<
		boost::mpl::equal_to<
			boost::mpl::modulus<T, boost::mpl::int_<15> >
			, boost::mpl::int_<0>
			>
		, FizzBuzz
		, BuzzSel<T>
		>
	{
	};
};


typedef boost::mpl::transform_view<range_1_100, FizzBuzzSel> FizzBuzzList;


struct Print
{
	template<typename T> void operator()(T)
	{
		std::cout << T::value << std::endl;
	}
};


int main(int, char **)
{
	boost::mpl::for_each<FizzBuzzList>(Print());
}

1 REM FIZZBUZZ COMMODORE 64 STYLE
2 REM BY KATAJAKASA
10 A=0
20 B=0
30 R=0
100 IF R=100 GOTO 1000
110 R=R+1
111 A=A+1
112 B=B+1
115 IF A<3 AND B<5 THEN PRINT R;
120 IF A=3 THEN PRINT "FIZZ";:A=0
130 IF B=5 THEN PRINT "BUZZ";:B=0
140 PRINT " "
170 GOTO 100
1000 PRINT "C64=WIN"

Learn you some Erlang!

-module(fizzbuzz).                                                              
-export([start/0]).                                                             
                                                                                
                                                                                
show_fizzezz({ 0, 0, _ }) ->                                                    
    io:format("FizzBuzz~n");                                                    
                                                                                
show_fizzezz({ _, 0, _ }) ->                                                    
    io:format("Fizz~n");                                                        
                                                                                
show_fizzezz({ 0, _, _ }) ->                                                    
    io:format("Buzz~n");                                                        
                                                                                
show_fizzezz({ _, _, Num }) ->                                                  
    io:format("~w~n", [Num]).                                                   
                                                                                
loop_numz([Num|Rest]) ->                                                        
    show_fizzezz({ Num rem 5, Num rem 3, Num }),                                
    loop_numz(Rest);                                                            
                                                                                
loop_numz([]) ->                                                                
    done_with_thiz_shiz.                                                        
                                                                                
start() ->                                                                      
    loop_numz(lists:seq(1,100)). 

Lainaten ideaa Joelin Haskell versiosta :)

-- Esa-Matti Suuronen, Epeli@IRCnet

Funktio ja pattern match vaikutteinen Kahviratkaisu:

op =                                                                            
  "0": -> "FizzBuzz"                                                            
  "0_": -> "Fizz"                                                               
  "_0": -> "Buzz"                                                               
  "__": (i) -> i                                                                
                                                                                
[1..100].forEach (i) ->                                                         
  console.log op[(i % 3 and "_") + (i % 5 and "_")] i

-- Esa-Matti Suuronen, Epeli@IRCnet