# Alphanumeric Hello World [closed]

Your goal is to write "Hello, World!" (minus the quotes). This is a , so most up votes wins. Code length will be used to break ties.
Anything goes, as long as it is within the following rules:

• All characters must be either letters or numbers, so you may only use characters in the string "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".
• All code you use must be in one file, with the exception of imported modules/classes/whatever they're called in your favourite language.
• Only the standard libraries/frameworks for your language of choice are allowed (for example, Python's Math module is allowed, but Numpy, Scipy, and Pygame are not). I will allow TkInter as it is the de facto standard for GUIs in Python.
• No input is permitted, be it reading from stdin, reading a file, displying an image, or reading from the web.

+10 brownie points if you figure out how to do it in Java without bending the rules.

On your marks, get set, code!

EDIT: braces ({}), brackets ([]), and parentheses (()) are allowed as this would be pretty much impossible for most languages without them. I'm also removing the character limit rule. Hopefully this will make it more interesting.

EDIT^2: white space is also allowed. My brain isn't working properly, sorry. >.<

• Up to you, I'm just making sure. What about whitespace? Mar 5 '14 at 14:04
• Oh, right white space. My brain is clearly not functioning properly today. That should be allowed. One second, let me fix the rules.
– wec
Mar 5 '14 at 14:15
• So, no operators? And, most importantly, no ;? How can I write anything in C? Mar 5 '14 at 14:22
• esolangs.org Hello, World! Mar 5 '14 at 22:41
• +1 for figuring out how to exclude J in a natural way: 72 101 108 108 111 44 32 87 111 114 108 100 33{a. requires the period at the end to work, and a path through u: similarly requires a colon. Without . and : we are nothing. Mar 5 '14 at 23:32

Hello, World!
$ # Python: Pfff, who needs the numeric part of alphanumeric? from string import lowercase from string import uppercase from string import punctuation print uppercase[len(str([[[len(str())]]]))] print lowercase[len(str([[]]))] print lowercase[len(str([[[[[len(str())]]]]]))] print lowercase[len(str([[[[[len(str())]]]]]))] print lowercase[len(str([[[[[[[]]]]]]]))] print punctuation[len(str([[[[[len(str())]]]]]))] print print uppercase[len(str([[[[[[[[[[[]]]]]]]]]]]))] print lowercase[len(str([[[[[[[]]]]]]]))] print lowercase[len(str([[[[[[[[len(str())]]]]]]]]))] print lowercase[len(str([[[[[len(str())]]]]]))] print lowercase[len(str([len(str())]))] print punctuation[len(str())]  This is locale-dependant, so your milage may vary. However, if you really want to replicate this result, you could use the following instead of the import statements: lowercase="abcdefghijklmnopqrstuvwxyz" uppercase="ABCDEFGHIJKLMNOPQRSTUVWXYZ" punctuation="!\"#$%&'()*+,-./:;<=>?@[\]^_{|}~"


(this is not part of my submission, it's just sharing my locals for recreatability)

## Rebmu, 46 characters

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01


Strongly parallels @dragetun's solution in Rebol (Because Rebmu is a Rebol/Red teaching tool which is a "dialect" that aims to draw attention to the languages by rocking at Code Golf. :-P)

However, to get the missing characters, I did something more obvious. I just added to space, instead of going and looking through system strings. You can get add space 1 to get character literal #"!" and add space 12 to get character literal #",".

If we run this we can see it get "unmushed":

>> rebmu/debug/stats "pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01prADsp01"
Original Rebmu string was: 46 characters.
Rebmu as mushed Rebol block molds to: 46 characters.
Unmushed Rebmu molds to: 62 characters.
Executing: [pn upp q hello 1 pn ad sp 12 pn sp pn upp q world 1 pr ad sp 1]
Hello, World!


Which is fairly logial:

; print with no newline the result of doing an uppercase/part
; on the quoting of the symbolic word hello, of only the first
; N characters (where N is 1)
pn upp q hello 1

; print the character you get when you add 12 to the space
; character literal, a.k.a. comma...again no newline

; print a space, no newline
pn sp

; do the same trick of printing the quoted word hello with the
; first letter converted to uppercase
pn upp q world 1

; print the character you get when you add 1 to the space
; character literal, a.k.a. exclamation point...with newline now


# Whitespace

Okay, we can use whitespace. It uses only Space, Tab, LineFeed and ignores any other characters.





With comment: S, T or L means Space, Tab or LineFeed respectively.

S S S T S S T   S S S L
T   L
S S S S S T T   S S T   S T L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T S T T   S S L
T   L
S S S S S T S S S S S L
T   L
S S S S S T T   T   S T T   T   L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   T   S S T   S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S S T   S S L
T   L
S S S S S T S S S S T   L
T   L
S S L
L
L


## T-SQL, 52

Ah, this is better! Direct binary conversion, only 52 characters.

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)


Previously...

There's a much cleverer and golfier solution to this that would work if we could use = and + (Looking up standard built-in data in msdb and using that to construct an EXEC-able query string)

But since we can't, you get this naive approach:

SELECT CHAR(72)SELECT CHAR(101)SELECT CHAR(108)SELECT CHAR(108)SELECT CHAR(111)SELECT CHAR(44)SELECT CHAR(32)SELECT CHAR(87)SELECT CHAR(111)SELECT CHAR(114)SELECT CHAR(108)SELECT CHAR(100)SELECT CHAR(33)

• I know, the lack of concatenation operators is killing me... I'm trying to think of a way to do it with JavaScript... Mar 5 '14 at 21:37
• Yeah, although this challenge seems to produce mostly naive answers, it has definitely inspired some interesting brain-twisting to try to find interesting non-concatenative approaches. Mar 5 '14 at 21:46
• You can do better. Use PRINT rather than SELECT. And implicitly cast with LTRIM() or RTRIM(). I do something similar here.
– Muqo
Sep 24 '14 at 1:23

# Groovy

So updated. Much wat.

def wat(i) { print i
this
}
def wat(int i) { wat i as char }
def getProperty(String p) { p }
wat Hello wat 44 wat 32 wat World wat 33
`