[Question]
  [
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
 
 
---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/22864/edit).
Closed 6 years ago.
[Improve this question](/posts/22864/edit) 
A rhyming program you write  
Attempting to win the fight  
For winning the contest and vote  
It must compute "Hello World"  
Then print it very polite
![](https://i.stack.imgur.com/Xhrwn.png)
The most popular poem will win.
The requirements are:
* The poem should be of [5 lines](http://en.wikipedia.org/wiki/Limerick_%28poetry%29) with rhymes AABBA
* It can print whatever you want, but the output should contain "hello world" (uppercase/lowercase does not matter, quotes not included in the output)
* Symbols are read aloud. For example, the fourth line above is read: It must compute quote hello world quote
* Post below your code, on another code preview, the "read-aloud" version of your code for disambiguation on special symbols.
Excluded are poems:
* including dead code, or characters which could be safely removed without changing the rhymes or the functionality
* Using comments as a way to rhyme (except if there is a good reason for that)
* using the same symbol as end of phrase for rhyme.
In case of a tie, programs outputting a poem will win. If there is still a tie, shorter programs will win.
New lines do not count. spaces, tabs and newlines are not read aloud.
For example, "Hello, world!" would be read aloud "double-quote hello comma world exclamation point double-quote".
  
[Answer]
## Whitespace
```
A rhyming program I	wrote  	   
	
     		  	 	
	
this poem of whitespace and bloat		 		  
	
     		 		  
	
because newlines don't count  		 				
	
     	     
	
despite the amount   	 	 			
	
     		 				
	
so deserves your sincerest upvote 			  	 
	
     		 		  
	
     		  	  
	
  
```
[Wikipedia: Whitespace (programming language)](http://en.wikipedia.org/wiki/Whitespace_(programming_language))  
[Online Interpreter to Test Answer](http://whitespace.kauaveel.ee/)
Output:
```
Hello World
```
[Answer]
**HTML**
```
<html>
<body><span
    class="poem"
    > Hello World! I'm a goat
</span></body></html><!-- Pecan -->
```
I had to get a little liberal with pronunciation of the last line. I hope it doesn't break the rules. It's also not 100% valid per W3C, but works in most browsers.
```
<!--
less than aich tee em el greater than,
less than body not equal to span,
class equals quote poem end quote,
greater than Hello World Bang I'm a goat
close span close body close root comment pecan
-->
```
[Answer]
## Javascript
I know this isn't within the rules, but I couldn't resist
```
var girl, attractive = true;    // There once was a beautiful girl
var boy; girl = ' World';       // And a boy who thought she was his world
boy = 'Hello' + girl;           // When the boy said hello
if (boy != attractive)          // She said 'my goodness no!'
    alert(window['boy']);       // And the boy through the window she hurled.
```
[Answer]
Python
```
a = [
'hello world']
print ''.\
join(a##
)
```
or,
```
a equals open square bracket
quote hello world quote close square bracket
print quote quote dot backslash
join paren a hash hash
and finally close unmatched bracket
```
I'm voluntarily signing up to additional rules, because I think (1) that limericks should have good metre and (2) that the best ones have a surprise in the last line.
(With the ending being interpreted in plain English, I figure you can work out for yourself what kind of bracket is unmatched. As to the no dead code requirement, nothing in there can be removed without changing at least one of rhyme, rhythm or output).
[Answer]
# Haskell
Taking some liberties with the pronunciation of certain
symbols, i.e. Tuple construction `(,,)` and function application
`($)`.
```
main = something that we wrote
     where something x y z = bloat
           bloat = flip ($) m putStrLn
           (that,we,wrote) = undefined
           m = "hello world"
```
The reading is supposed to be:
```
main is something that we wrote
where something x y z is bloat
bloat is flip apply m putStrLine
Tuple that we wrote is undefined
misquote hello world quote.
```
[Answer]
## JavaScript
```
if (!!1) // and
  alert('&#10084; &#10084; the world') // and
Burn = $.cache
return 1 > his_parts.the_sum
```
> 
> If in brackets one follows exclaiming marks
> 
> 
> and alert the world inside brackets after entity hearts
> 
> 
> slash, slash and burn
> 
> 
> equals cash, cash, return
> 
> 
> one is greater than the sum of his parts
> 
> 
> 
[Answer]
# BASIC
More specifically, [Chipmunk Basic](http://www.nicholson.com/rhn/basic/). The syntax rules have been stretched almost to breaking point, so it may be impossible to run this in other dialects without modification.
**Source:**
```
read hi$, u$, q
print hi$ " world how are you
  print "Or as they say
  print u$ q "day
data Hello, How R U, 2
```
**"Read-aloud" version:**
```
read hi string comma u string comma q
print hi string quote world how are you
  print quote Or as they say
  print u string q quote day
data Hello comma How R U comma 2
```
**Notes:**
* There are no line numbers in the source code, but it will still load and run without any problems (see below).
* The `$` sigil is read as *"string"* in the context of BASIC programs (see, e.g., [this Wikipedia page](http://en.wikipedia.org/wiki/Dollar_sign#Programming_languages)).
And here's proof that it does actually work:
![screen grab of program running in Mac OS X](https://i.stack.imgur.com/6HvFX.gif)
[Answer]
**Bash**
As the answer is only forced to *contain* the phrase "Hello World", the easiest solution should be:
```
echo A rhyming program you write
echo Attempting to win the fight
echo For winning the contest and vote
echo It must compute "Hello World"
echo Then print it very polite
```
[Answer]
## Java
```
public static void main(String[] boat
){ int i = 1.0f
  ;if(i<2
  )System.out.println
("Hello world");} //hello world wrote
public static void main paren String arr boat
paren brace int i is one-point-oh float
sem-col if paren i is less than two
paren system dot out dot print line new //for some reason it's println, not printnl
paren quote hello world quote paren sem-col brace slash-slash hello world wrote
```
Note that comments are not really optional in Java
[Answer]
# Ruby
```
comma = ""<<44
print "Hello" or
more = ""<<32
print comma if true
puts("World!") unless print more
```
Live: <https://ideone.com/sirBBc>
Pronounced as follows (with stressed syllables capitalized)
```
comma Equals quote-QUOTE cons four-FOUR
print QUOTE hello END quote OR
more equals QUOTE quote cons three-TWO  # ok, that was squished
print COMma if TRUE
puts QUOTE world QUOTE UNless print MORE
```
[Answer]
## Haskell
```
main = print . repeat
  $ head $ lines . init
     $ "Hello \
       \World!" #
         Just where (#) = const . id
```
> 
> Main equals printful stop repeat  
> 
>  Dollar head dollar line's full stop i'nnit?  
> 
>  Dollar quote hello back slash  
> 
>  Back slashworld bang quote hash  
> 
>  Just where parenthised hash equals constful, stop it!
> 
> 
> 
This describes, hopefully, quite well the actual behaviour of the program.
[Answer]
## TeX
I apologize in advance, because this code does not count as a limeric if you pronounce the names of each of the individual symbols (especially if you treat each letter unto itself as a token, which perhaps you ought). I have written it this way to produce the nicest possible output, which itself comes just short of being a poem.
You could safely turn it into an answer which complies with the rules by getting rid of `\it` and every non-alphabetic, non-whitespace character except for the final `\bye` (read aloud as *backslash bye*) and perhaps the first `!` (read aloud as *bang*).
```
A \TeX\ program I think would comply,
And I'll tell you the reason for why:
``Hello world!'' tells the setter:
{\it ``Print each subsequent letter!''}
And we terminate with \bye.
```
[Answer]
# Brainf\*ck
Ok, chide me now for the numerous rule violations. But I couldn't help making this.
```
++++++++[>+++++++++<-
]>.---.$#
+++++++..+
++.++++++++
.--------.+++.------.--------.
```
And the output (first violation of many: no space):
```
HELLOWORLD
```
Try it here: <http://www.iamcal.com/misc/bf_debug/>
The reading of it:
```
Eight plus left more nine plus less dash
Right more dot three dash dot cash hash
Sevén plus dot dot plus
Plus plus dot eight plus
Dot eight dash dot three plus dot six dash dot eight dash.
```
* Note that the final dot in the program is placed as the period at the end of the limerick :) [second violation; this is cheap]. Also, the `$` and `#` are ignored by the interpreter (I was very proud of myself for this line).
* The accent on `Sevén` is to show the stress: seh-VEN
* This violates the rule of using different symbols. But honestly I have a very limited symbol set and no space to add in other (ignored) characters.
* I used all caps because those are faster to access in ASCII. I had no room for a space, unfortunately.
Finally: yes, I know the last line is terrible. Any suggestions to improve it? I'm not sure if you could compress this program anymore; maybe by storing repeated letters in their at their own positions?
[Answer]
**C#**
I've taken a few slight liberties with the rules as truly phonetic C variants would involve far too much use of "semi-colon" which, as we all know, isn't a particularly good rhyme for anything. 
```
{
     string unfurled = "Hello World!";
     Console.WriteLine(unfurled);
}
```
open brace, string called unfurled
created to read "hello world"
console write line
the string we defined
a final brace, one that is curled
[Answer]
# Java
```
class Hello {public static void main
(String[] args)
{yellow = System; yellow
.out.print("Hello
world");} }
class Hello brace public static void main
paren string bracket bracket args paren
 brace yellow equals system sem-col yellow
 dot out dot print paren quote hello
world quote paren sem-col brace and brace again
```
[Answer]
## Batch
```
@echo off >dull
set /p "=Hello "<nul
set w=World
echo %w%! || Furled
del dull || cull
```
> 
> at echo off to dull   
> 
>  set slash p quote equal Hello quote from nul   
> 
>  set w equal World   
> 
>  echo percent w percent bang pipe pipe Furled   
> 
>  del dull pipe pipe cull
> 
> 
> 
[Answer]
# CSS
```
title>me
,body lets go party
only a stylesheet,html
:after { content: 'hello world'; font-family:Rockwell
; color: #adad20
```
Outputs:
> 
> title greater than me
> 
> 
> comma body lets go party
> 
> 
> only a stylesheet comma html
> 
> 
> colon after bracket content colon quote hello world quote semicolon font-family colon Rockwell
> 
> 
> semicolon color colon hashtag a dad twenty
> 
> 
> 
Tested in [Firefox and Chrome](http://jsfiddle.net/WNH9A/)
[Answer]
```
#include <stdio.h> //
void main (void){
printf("Hello, World");
//just for rhyme I say stolon
} /**/
```
hash include less than stdio dot h greater than double slash after a space
void main left paren void right paren left brace
printf left paren quote Hello comma World quote right paren semi colon
double slash just for rhyme I say stolon
right brace and double asterisk between slashes at the last place
[Answer]
## Windows Batch
The spoken words are also saved within the batch file, and skipped with the last line of actual code.
```
@echo off >nul
set hi=Hello World
rem Now print the string,
echo !hi!
goto :) to skip the words
at echo off, greater than nul,
set H I equals sign, Hello World,
rem Now print the string,
echo pling, H I, pling
goto smile, to skip the words
:)
```
Edit: You'll need delayed expansion enabled for the script to work. Use `cmd /v:on` and run it from there.
[Answer]
**Python (3)**
```
print('''Nose
No punctuation hear close
Hello World
Hurled and swerled
Goodbye now''')
```
Print open quote quote quote nose, No punctuation hear close, Hello World, Hurled and swerled, Goodbye now quote quote quote close. 
]