<?
class printletter{
public $letter;
function __construct($var){
$this->letter = preg_split('//', $var, -1, PREG_SPLIT_NO_EMPTY);;}}

function display($var){
foreach($var as $output){
if($output == " "){
$output = "space";}

$output = strtolower($output);
echo"<img src=\"$output.jpg\" alt=\" \">";}}

$originalstring = new printletter("Hello World");
display($originalstring->letter);
?>

#include <iostream>
using namespace std;

int main()
{
char letter = 'a';
int hello[] = {7,-3,7,0,3};
int world[] = {8,-8,3,-6,-8};

letter = letter + hello[0]; cout << letter;
letter = letter + hello[1]; cout << letter;
letter = letter + hello[2]; cout << letter;
letter = letter + hello[3]; cout << letter;
letter = letter + hello[4]; cout << letter;

cout << " ";   

letter = letter + world[0]; cout << letter;
letter = letter + world[1]; cout << letter;
letter = letter + world[2]; cout << letter;
letter = letter + world[3]; cout << letter;
letter = letter + world[4]; cout << letter;
cin >> letter;
}

$szSeq = '721011081081113287111114108100';
$aChars = str_split((string) $szSeq, 1);

for($iIndex = 0; $iIndex < count($aChars); $iIndex++)
{
    list($iA, $iB, $iC) = array
    (
        $aChars[$iIndex],
        !isset($aChars[$iIndex + 1]) ? null : $aChars[$iIndex + 1],
        !isset($aChars[$iIndex + 2]) ? null : $aChars[$iIndex + 2]
    );
                            
    $iSeq = (int) str_pad($iA . $iB . $iC, 3, STR_PAD_LEFT);
    
    if($iSeq >= 120)
    {
        $iSeq = substr($iSeq, 0, 2);
        $iIndex += 1;
    }
    else $iIndex += 2;
    
    echo chr($iSeq);
}

<?php

interface Outputtable
{
    public function generate();
    public function output();
}

abstract class HelloWorld
{
    protected $phrase = 'Hello World';
}

class HelloXml extends HelloWorld implements Outputtable {
    private $root = 'phrase';
    
    public function generate()
    {
        $output  = '<?xml version="1.0" encoding="utf-8"?>';
        $output .= "\n";
        $output .= sprintf('<%1$s>%2$s</%1$s>', $this->root, $this->phrase);
        return $output;
    }
    public function output()
    {
        header('Content-Type: application/xml; charset=utf-8');
        echo $this->generate();
        
    }
}

class TextImage implements Outputtable
{
    public $img;
    public $text;
    protected $palette;
    const FONT_FILE  = 'Georgia.ttf';
    const FONT_SIZE  = 20;
    const FONT_ANGLE = 4;
    
    public function __construct($text)
    {
        $this->text = $text;
        $this->generate();    
    }
    
    public function resource()
    {
        return $this->img;
    }
    
    public function generate()
    {
        $bbox = (object) array_combine(array('llx', 'lly', 'lrx', 'lry', 'urx', 'ury', 'ulx', 'uly'), 
                                       imagettfbbox(self::FONT_SIZE, self::FONT_ANGLE, TextImage::FONT_FILE, $this->text));
        $width  = abs(max($bbox->lrx, $bbox->urx) - min($bbox->llx, $bbox->ulx));
        $height = abs(max($bbox->lry, $bbox->lly) - min($bbox->ury, $bbox->uly));
        $left   = min($bbox->llx, $bbox->lrx);
        $bottom = min($bbox->lly, $bbox->lry);
        $this->img = imagecreatetruecolor($width, $height);
    
        $this->generate_palette();
        
        imagefill($this->img, 0, 0, $this->palette['white']);
        imagettftext($this->img, 
                    self::FONT_SIZE, 
                    self::FONT_ANGLE, 
                    max(0, abs($bbox->ulx)), 
                    self::FONT_ANGLE < 0
                        ? abs($bbox->lly - $bbox->uly)
                        : abs($bbox->lly - $bbox->ury),
                    $this->palette['red'], 
                    self::FONT_FILE, 
                    $this->text);
    }
    
    public function output()
    {
        header('Content-Type: image/png');
        imagepng($this->img);
        imagedestroy($this->img);
    }
    
    private function generate_palette()
    {
        $this->palette = array(
            'white' => imagecolorallocate($this->img, 255, 255, 255),
            'black' => imagecolorallocate($this->img, 0,   0,   0  ),
            'red'   => imagecolorallocate($this->img, 255, 0,   0  )
        );
    }
}

class Image2Text implements Outputtable
{
    private $img;
    private $text = 'hello';
    
    public function __construct(TextImage $img, $text = 'text', $elem = 'span')
    {
        $this->img  = $img;
        $this->elem = $elem;
        $this->text = $text;
    }
    
    public function generate()
    {
        $img     = $this->img->img;
        $width   = imagesx($img);
        $height  = imagesy($img);
        $counter = 0;
        $output  = '';
        
        for ($y = 0; $y < $height; $y++)
        {
            for ($x = 0; $x < $width; $x++)
            {
                $counter %= strlen($this->text);
                $colour   = imagecolorat($img, $x, $y);
                $rgb      = imagecolorsforindex($img, $colour);
                $hex      = self::rgb2hex(array($rgb['red'], $rgb['green'], $rgb['blue']));
                $output  .= sprintf('<%s style="color: #%s;">%s</%s>',
                                    $this->elem,
                                    $hex,
                                    $this->text[$counter],
                                    $this->elem);
                $counter++;
            }
            $output .=  '<br />';
        }
        return $output;
    }
    
    public function output()
    {
        header('Content-Type: text/html; charset=utf-8');
        echo $this->generate();
    }

    public static function rgb2hex($rgb)
    {
        $rgb = array_slice(array_pad($rgb, 3, 0), 0, 3);
        
        $hex = array();
        foreach ($rgb as $dec)
        {
            $hex[] = str_pad(dechex($dec), 2, '0', STR_PAD_RIGHT);
        }
        return implode($hex);
    }
}

class HelloImage implements Outputtable
{
    protected $source;
    
    public function __construct(HelloXml $source)
    {
        $this->source = $source;
    }
    
    public function generate()
    {
        $xml_raw = $this->source->generate();
        $xml = new SimpleXMLElement($xml_raw);
        $phrase = (string) $xml;
        
        $img = new TextImage($phrase);    
        $text = new Image2Text($img, preg_replace('/[^a-zA-Z]+/', '', $phrase), 'span');
        echo '<style type="text/css">body {font:normal 8px/1.0 courier, monospace;}</style>';
        echo $text->generate();
        exit;
        return $phrase;
    }
    
    public function output()
    {
        //header('Content-Type: image/png');
        echo $this->generate();
    }
}

class HelloContest extends HelloWorld implements Outputtable
{
    protected $renderer;
    public function __construct()
    {
        $this->renderer = new HelloImage(new HelloXml);
    }
    public function generate() { }
    public function output()
    {
        $this->renderer->output();
    }
}

// Singleton pattern
class Hello
{
    private static $instance = false;
    private function __construct() { }
    private function __clone() { }
    
    // Factory pattern
    public static function instance($key)
    {
        if (self::$instance === false and $key == 'contest')
        {
            return new HelloContest;
        }
        
        return self::$instance;
    }
}

$hello = Hello::instance('contest');
$hello->output();