#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>

__global__ void fizzbuzzKernel(char*, char*);

void main()
{
	// Allokerer fizz og buzz på CPU
	char *fizz = "fizz\0";
	char *buzz = "buzz\0";

	// Device-pointere for fizz og buzz
	char *dev_fizz = 0;
	char *dev_buzz = 0;

	// Allokerer plass til fizz og buzz på GPU
	cudaMalloc((void**)&dev_fizz, 5 * sizeof(char));
	cudaMalloc((void**)&dev_buzz, 5 * sizeof(char));

	// Kopierer fizz og buzz fra CPU til GPU
	cudaMemcpy(dev_fizz, fizz, 5 * sizeof(char), cudaMemcpyHostToDevice);
	cudaMemcpy(dev_buzz, buzz, 5 * sizeof(char), cudaMemcpyHostToDevice);

	// Kjører kernel med 10 blokker, som hver har 10 threads
	fizzbuzzKernel<<<10, 10>>>(dev_fizz, dev_buzz);

	// Synkronisering
	cudaDeviceSynchronize();

	// ???
	// Profit!
}

__global__ void fizzbuzzKernel(char *fizz, char *buzz)
{
	int number = threadIdx.x * blockDim.x + blockIdx.x + 1;
	if(number % 3 == 0 && number % 5 == 0)
	{
		printf("%i:\t%s%s\n", number, fizz, buzz);
	}
	else if(number % 3 == 0)
	{
		printf("%i:\t%s\n", number, fizz);
	}
	else if(number % 5 == 0)
	{
		printf("%i:\t%s\n", number, buzz);
	}
	else
	{
		printf("%i:\t%i\n", number, number);
	}
}

|
|       FIZZBUZZ!!                     
|     JUST LIKE EULER 1             
|     FOR FREAK.NO COMPO               
|                            Z   Z   I   F         Z   Z   U   B         \n
|                                    
|_CREATE_STRINGS_FOR_PRINT__09&_09&_37&_07&_"1<[__09&_09&_58&_66&_"2<[__01&"_3<[__
                                                                                  |
 ______________________________________11_________________________________________|
|
|  CHECK IF 101        BELOW 101         MOD 3          NOT DIVISABLE BY 3
|
|                   __?__40[____________>3<%____ __?______________________________
 _?__>_01&>*1+</!__|                            |                                 |
|                  |                            ?                                 |
0                  |                            |                                 |
+ ADD 1            |                            |         DIVISABLE BY 3          |
1                                               |                                 1
|                 END                           |_________41[_____1]#__________0__|
#                                                                                 |
] NEWLINE                                                                         ?
3                                                                                 >
|                                                                         MOD 5   5
?                                                                                 <
|                                                                                 %
|_0___________#>___________                     __________#]2____[14______________|
|                          |                   |                                  |
1    PRINT NUMBER          |                   |          DIVISABLE BY 5          |
|   IF NOT % 3 OR % 5      ?                   |                                  |
|                          |                   0                                  |
|_______________________?__|_____]4_________??_|_1________________________________|

                                                         NOT DIVISABLE BY 5

/*/../usr/bin/env echo compiling...;T=$(/usr/bin/env mktemp);/usr/bin/env g++ "$0" -o "$T" && ("$T";rm "$T");exit;*/

#include <iostream>
typedef unsigned char uc;
using namespace std;

int main(int argc, char **argv)
{
    uc b[2] = { '0','z' };
    uc c[3] = { 'f','i','G' };
    uc d[3] = { 'b','u','K' };
    uc e[4] = { c[0], c[1], d[0], d[1] };
    for (int n=1; n<101; n++)
    {
        b[1]=n;
        int a=0;
        if (!(n%3)) a+=1;
        if (!(n%5)) a+=2;
        uc *v=a==0?b:a==1?c:a==2?d:e;
        for (a=0;a<2;a++)
        {
            if (v[0]<'a')
            {
                std::cout << (int)v[1];
            }
            else
            {
                std::cout << v[a*2] << v[a*2+1];
                std::cout << (uc)(c[0]+5*4);
                std::cout << (uc)(d[1]+5);
            }
            if (v[0]<'a' || v[2]<'a') break;
        }
        cout << endl;
    }
}

_=__import__('pyttsx').init();_.say('\n'.join("Fizz"*(not i%3)+"Buzz"*(not i%5) or str(i) for i in range(1,101)));_.runAndWait()

<?php
//husker ikke helt hvor jeg opprinneling fant denne funksjonen, men har i hvert fall ikke skrevet den selv
function rgb2hex($r, $g, $b){
    $r=dechex($r);
    if (strlen($r)<2)
    $r='0'.$r;

    $g=dechex($g);
    if (strlen($g)<2)
    $G='0'.$g;

    $b=dechex($b);
    if (strlen($b)<2)
    $b='0'.$b;

    return $r . $g . $b;
}


// henter inn bildefilen og finner dimensjonene. 
$image = 'image.png';
list($width, $height) = getimagesize($image);


// sjekker om bildet er kvadratisk - hvis ja: går ut fra at bildet er delt opp i 10 like deler per lengde, og finner hvor mange pixler man må flytte seg for å komme til neste del
if ($width == $height) {
	$step = $width / 10;
	}
else {
	die("Bildet er ikke kvadratisk.");
	}


// $xcor og $yxor = koordinatene på bildefila
// $x teller antall ganger loopen kjøres
// $y teller hvor mange ganger $xcor har oversteget bildets bredde
$image = imagecreatefrompng($image);
$xcor = $step - 1;
$ycor = 0;
$x = 1; 
$y = 1; 



while($x<=100)
    {
    
    // sjekker om X-koordinatet er større en bildets bredde, og øker Y-koordinatet hvis det er tilfelle
    if ($xcor >= $width) {
	    $xcor = $step - 1;
	    $ycor = $step * $y;
	    $y++;
	    }
    
    
	// array med hexadesimaler og tilhørende navn
    $hex = array("00000", "008040", "000ff");
    $txt = array("fizz", "buzz", "fizzbuzz");
    
    
    // finner RGB-verdien utifra koordinatene, gjør om til hexadesimaler og endrer til navnene i arrayet overfor
    $rgb = imagecolorat($image, $xcor, $ycor);
    $output = str_replace($hex, $txt, (rgb2hex(($rgb >> 16) & 0xFF, ($rgb >> 8) & 0xFF, $rgb & 0xFF)));
    
    
    // echoer $x (antall ganger loopen har kjørt) hvis feltet er gult. Ellers echoes navnet som er funnet overfor
    if ($output != "ffff00") {
	    echo $output;
	    }
    else {
	    echo $x;
	    }
    
    echo '<br />';
    
    
    // finner nytt X-koordinatet og looper koden
    $xcor = $xcor + $step;
    $x++;
    } 

?>

	private static void icanhazbuzz(int range){


		String[] fizz = new String[range+1];


		int range_3 = range/3;

		for(int i = 1; i < range_3; i++){
			fizz[i*3] = "fizz";			
		}

		int range_5 = range/5;

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

			int index = i*5;
			fizz[index] = (fizz[index] == null ? "" : fizz[index])+"buzz";
		}


		for(String s : fizz){

			if(s==null){
				continue;
			}

			System.out.println(s);
		}

	}

	
	private static void minimal(int range){

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

			System.out.println((i%3 == 0 ? "fizz":"") + (i%5 == 0 ? "buzz":""));			
		}		
	}

		NeuralNetwork buzznet = new NeuralNetwork();
		try {


			buzznet.buildNetwork(2, new int[]{3}, 1, ActivatorFactory.LINEAR_ACTIVATOR, ActivatorFactory.SIGMOID_ACTIVATOR, ActivatorFactory.SIGMOID_ACTIVATOR);

			ValueSet[] inputs = new ValueSet[]{
					new ValueSet(0f,0f), // ""
					new ValueSet(1f,0f), // "fizz"
					new ValueSet(0f,1f), // "buzz"
					new ValueSet(1f,1f) // "fizzbuzz"
			};


			ValueSet[] desired = new ValueSet[]{
					new ValueSet(0.0f),
					new ValueSet(0.25f),
					new ValueSet(0.75f),
					new ValueSet(1f)
			};

			buzznet.scrambleWeights();


			Trainer trainer = new BackpropagationTrainer(buzznet);

			for(int x = 0; x < 1000; x++){

				float sum = 0;

				for(int i = 0; i < 4; i++){	
					float val = trainer.train(inputs[i], desired[i], 0.25f);
					sum += val;
				}

				if(sum <= 0.128f){
					System.out.println(sum);
					break;
				}
			}


			// test training
			for(int i = 0; i < 4; i++){				
				buzznet.run(inputs[i]);	
				System.out.println(buzznet.toString());
			}


			//network is trained, get fizzbuzz
			String[] outputs = new String[]{"","fizz", "buzz", "fizzbuzz"};

			ValueSet input = new ValueSet(1,1);

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



				if(i % 3 == 0){
					input.setValue(0, 1);
				}else{
					input.setValue(0, 0);
				}


				if(i % 5 == 0){
					input.setValue(1, 1);
				}else{
					input.setValue(1, 0);
				}


				buzznet.run(input);

				float value = buzznet.getOutputValueSet().getValue(0);
				int selectedIndex = 0;

				if(value > 0.8f){
					selectedIndex = 3;
				}else if(value > 0.5f){
					selectedIndex = 2;
				}else if(value > 0.2f){
					selectedIndex = 1;
				}				

				System.out.println(i+") "+outputs[selectedIndex]);			
			}





		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

<?php

interface FizzBuzz 
{
    public function run();
    public function output();
}

class FizzBuzzer implements FizzBuzz
{
    protected $iterator;
    protected $strategy;
    protected $printer;

    public function __construct(FizzBuzzIterator $iterator, FizzBuzzStrategy $strategy)
    {
        $this->iterator = $iterator;
        $this->strategy = $strategy;
        $this->printer = new FizzBuzzPrinter();
    }
    
    public function run()
    {
        $multipliers = $this->strategy->getMultipliers();
        
        $this->iterator->rewind();
        
        while($this->iterator->valid()) {
            $worker = new FizzBuzzWorker($multipliers, $this->iterator->current());

            $this->printer->queue($worker->getResult());
            
            $this->iterator->next();
        }
        
        return $this;
    }
    
    public function output($asHtml = false)
    {
        if($asHtml)
            $this->printer->setFormatter(new FizzBuzzPrinterHtmlFormatter());
        
        $this->printer->printAll();
    }
}

class FizzBuzzIterator implements Iterator 
{
    protected $start;
    protected $stop;
    protected $current;
    
    public function __construct(FizzBuzzIteratorNumber $start, FizzBuzzIteratorNumber $stop)
    {
        $this->start = $start;
        $this->stop = $stop;
        $this->current = $start;
    }
    
    public function current()
    {
        return $this->current->getNumber();
    }
    
    public function rewind()
    {
        $this->current->setNumber($this->start->getNumber());
    }
    
    public function key()
    {
        return null;
    }
    
    public function next()
    {
        $this->current->increaseBy(new FizzBuzzIteratorNumber(1));
    }
    
    public function valid()
    {
        return $this->current->getNumber() <= $this->stop->getNumber();
    }
}

class FizzBuzzIteratorNumber 
{
    protected $number;
    
    public function __construct($number)
    {
        if(!$this->isValid($number))
            throw new FizzBuzzIteratorNumberException($number);
            
        $this->number = $number;
    }
    
    public function increaseBy($number)
    {
        $number = $number->getNumber();
        
        if(intval($number) == 0)
            return;
        
        if(intval($number) == 1)
            return ++$this->number;
            
        $this->number = $this->number + $number;
        
        return $this->number;
    }
    
    public function decreaseBy($number)
    {
        if(!$this->isValid($number))
            throw new FizzBuzzIteratorNumberException($number);
            
        if(intval($number) == 0)
            return;
        
        if(intval($number) == 1)
            return --$this->number;
            
        $this->number = $this->number - $number;
        
        return $this->number;
    }
    
    public function getNumber()
    {
        return $this->number;
    }
    
    public function setNumber($number)
    {
        if(!$this->isValid($number))
            throw new FizzBuzzIteratorNumberException($number);
        
        $this->number = $number;
    }
    
    public function isValid($number)
    {
        if(!is_numeric($number)) {
            return false;
        } 
        
        return true;
    }
}

class FizzBuzzIteratorNumberException extends Exception
{
     public function __construct($input, $code = 0, Exception $previous = null) 
     {
        $message = '"' . $input . '" is not a valid number';
        
        parent::__construct($message, $code, $previous);
     }
}

class FizzBuzzStrategy
{
    protected $multipliers;
    
    public function __construct($multipliers) 
    {
        if(!is_array($multipliers))
            throw new FizzBuzzStrategyException('Strategy needs to be constructed with an array');
        
        $this->multipliers = $multipliers;
    }
    
    public function getMultipliers()
    {
        return $this->multipliers;
    }
}

class FizzBuzzStrategyException extends Exception
{
     public function __construct($message, $code = 0, Exception $previous = null) 
     {   
        parent::__construct($message, $code, $previous);
     }
}

class FizzBuzzStrategyMultiplier 
{
    protected $number;
    
    public function __construct($number)
    {
        if(!$this->isValidNumber($number))
            throw new FizzBuzzStrategyMultiplierException('"' . $number . '" is not a valid number');
            
        $this->number = $number;
    }
    
    public function getNumber()
    {
        return $this->number;
    }
    
    public function isValidNumber($number)
    {
        if(!is_numeric($number))
            return false;
            
        return true;
    }
}

class FizzBuzzStrategyMultiplierException extends Exception
{
     public function __construct($message, $code = 0, Exception $previous = null) 
     {  
        parent::__construct($message, $code, $previous);
     }
}

class FizzBuzzWord
{
    protected $text;
    
    public function __construct($text)
    {
        if(!is_string($text))
            throw new FizzBuzzWordException('FizzBuzzStrategyWord must be constructed with a string');
            
        $this->text = $text;
    }
    
    public function getText()
    {
        return $this->text;
    }
}

class FizzBuzzWordException extends Exception
{
     public function __construct($message, $code = 0, Exception $previous = null) 
     {  
        parent::__construct($message, $code, $previous);
     }
}


class FizzBuzzWorker
{
    public function __construct($multipliers, $number)
    {
        if(!is_array($multipliers)) 
            throw new FizzBuzzWorkerException('Multipliers must be provided');
        
        $result = '';
        
        foreach($multipliers as $word => $multiplier) {
            if(!$multiplier instanceof FizzBuzzStrategyMultiplier)
                throw new FizzBuzzWorkerException('Multiplier must be instance of FizzBuzzStrategyMultiplier');
                
            if($this->check($multiplier->getNumber(), $number)) {
                $fbWord = new FizzBuzzWord($word);
                $result .= $fbWord->getText();
            }
        }
        
        if(strlen($result) > 0) {
            $this->result = $result;
        }
        else {
            $this->result = $number;
        }
    }
    
    public function check($multiplier, $number)
    {
        return !($number % $multiplier);
    }
    
    public function getResult()
    {
        return $this->result;
    }
}

class FizzBuzzPrinter
{
    protected $printQueue;
    protected $formatter;
    
    public function __construct()
    {
        $this->printQueue = array();
    }
    
    public function queue($message)
    {
        $this->printQueue[] = $message;
    }
    
    public function printSingle($key = 0)
    {
        if(!isset($this->printQueue[$key]))
            throw new FizzBuzzPrinterException('Invalid key in printqueue');
        
        echo $this->printQueue[$key] . "\n";
        
        array_splice($this->printQueue, $key, 1);
    }
    
    public function printAll()
    {
        foreach($this->printQueue as $printItem) {
            if($this->formatter instanceof FizzBuzzPrinterFormatter) {
                echo $this->formatter->getLine($printItem);
            }
            else {
                echo $printItem . "\n";
            }
        }
        
        $this->reset();
    }
    
    public function reset()
    {
        $this->printQueue = array();
    }
    
    public function setFormatter(FizzBuzzPrinterFormatter $formatter)
    {
        $this->formatter = $formatter;
    }
}

class FizzBuzzPrinterException extends Exception
{
     public function __construct($message, $code = 0, Exception $previous = null) 
     {   
        parent::__construct($message, $code, $previous);
     }
}

interface FizzBuzzPrinterFormatter
{
    public function getLine($line);
}

class FizzBuzzPrinterHtmlFormatter implements FizzBuzzPrinterFormatter
{
    public function getLine($line) 
    {
        return $line . '<br />';
    }
}

$fb = new FizzBuzzer(
    new FizzBuzzIterator(
        new FizzBuzzIteratorNumber(1),
        new FizzBuzzIteratorNumber(100)
    ),
    new FizzBuzzStrategy(array(
        'Fizz' => new FizzBuzzStrategyMultiplier(3),
        'Buzz' => new FizzBuzzStrategyMultiplier(5)
    ))
);

$fb->run()->output();

$fb->run()->output(true);

from flask import Flask
import sys
from StringIO import StringIO
from lxml.html import parse

app = Flask(__name__)
buffer = StringIO()
sys.stdout = buffer
tag = parse('http://freak.no/forum/showthread.php?t=263999').getroot()
code = tag.xpath ('.//*[@id="post_message_3068988"]/div/pre/text()')
exec(''.join(code))
sys.stdout = sys.__stdout__

@app.route("/")
def fizzbuzz():
    return '<h2 style="color:red;background:black;">{}</h2>'.format(buffer.getvalue())

#http://localhost:5000/
if __name__ == "__main__":
    app.run()

from bottle import run, template, get, post, request
from plotly import plotly
from lxml.html import parse
from collections import Counter

py = plotly(username_or_email='snippsat', key='xxxxxx')

@get('/fizzbuzz')
def submit():
    tag = parse('http://localhost:5000/').getroot()
    links = tag.cssselect('html body h2')
    stats = Counter(links[0].text.split())
    x0 = ['Fizz', 'Buzz', 'Fizzbuzz']
    y0 = [str(stats['fizz']), str(stats['buzz']), str(stats['fizzbuzz'])]
    data = {'x': x0, 'y': y0, 'type': 'bar'}
    response = py.plot([data])
    url = response['url']
    filename = response['filename']
    return template('''<a href=""></a>!''', url=url)

#http://localhost:8080/fizzbuzz
if __name__ == '__main__':
    port = int(os.environ.get('PORT', 8080))
    run(host='0.0.0.0', port=port, debug=True)

  | x `modP` 3 = if x `modP` 5 then "fizzbuzz" else "fizz"

f :: Int -> String
f n =
  case (n `mod` 3, n `mod` 5) of
    (0, 0) -> "fizzbuzz"
    (_, 0) -> "fizz"
    (0, _) -> "buzz"
    _       -> show n

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        FizzBuzz();
    }

    protected void FizzBuzz()
    {
        int start = 0;
        int slutt = 0;

        for (int i = start; i <= slutt; i++)
        {
            if (i % 15 == 0)
            {
                FizzBuzzLiteral.Text = "FizzBuzz";
            
            }
            else if (i % 3 == 0)
            {
                FizzBuzzLiteral.Text = "Fizz";
            
            }
            else if (i % 5 == 0)
            {
                FizzBuzzLiteral.Text = "Buzz";
 
            
            }
 
        
        }
    
    }


}

#!/usr/bin/env python

import pygame
from random import randint, choice

def boring_function(isitabuzz):
    if isitabuzz %3 == 0 and isitabuzz%5 == 0:
        return "fizzbuzz"
    elif isitabuzz %3 == 0:
        return "fizz"
    elif isitabuzz %5 == 0:
        return "buzz"
    else:
        return str(isitabuzz)


def space_colors():
    return randint(10,255),randint(10,255),randint(10,255)


pygame.font.init()
buzzez = [pygame.font.Font(None,int(freak*10+15)).render(boring_function(freak)\
         ,True,space_colors()) for freak in range(1,101)]

X = 7000
Y = 7000
cloud = pygame.Surface((X,Y))
cloud.fill((0,0,0))
rects = []
buzzez.reverse()
for buzz in buzzez:

    y = Y/2
    x = randint(0,X-buzz.get_width())
    h = buzz.get_height()
    w = buzz.get_width()
    rect = pygame.Rect(x,y,w,h)
    trying_to_draw = True

    while trying_to_draw:
        if rect.collidelist(rects) == -1:
            rects.append(rect)
            cloud.blit(buzz,rect)
            trying_to_draw = False
        else:
            y += choice((-5,5))
            if y >= Y-buzz.get_height() or y < 0:
                y = Y/2
                x = randint(0,X-buzz.get_width())
            rect = pygame.Rect(x,y,w,h)

pygame.image.save(cloud,"inurbuzz.png")

freak@computer:~$ time buzzcloud.py
real	1m7.001s
user	1m5.780s
sys	0m0.352s

Z:\home\xxxxxx\Projects\Prog>fizzbuzz.bat

Z:\home\xxxxxx\Projects\Prog>#define m// 2>NUL & @echo off & goto :fibu 
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
76
77
fizz
79
buzz
fizz
82
83
fizz
buzz
86
fizz
88
89
fizzbuzz
91
92
fizz
94
buzz
fizz
97
98
fizz
buzz

     class Program
    {
        static void Main(string[] args)
        {
            string showFunction = Console.ReadLine();
            DoFizzBuzz(showFunction);
            Console.ReadLine();
        }

        public static void DoFizzBuzz(string showCode = "MessageBox.Show")
        {
            var se = new ScriptEngine();
            var session = se.CreateSession();

            session.ImportNamespace("System");
            
            var code = String.Format("new Action<string>({0})", showCode);

            Action<string> showFunction = (Action<string>)session.Execute(code);

            for (int i = 0; i <= 100; i++)
            {
                string s = String.Empty;
                if (i % 3 == 0 && i % 5 == 0)
                    s = "fizzbuzz";
                else if (i % 3 == 0)
                    s = "fizz";
                else if (i % 5 == 0)
                    s = "buzz";
                else
                    s = i.ToString();

                showFunction(s);
            }
        }
    }