# 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? – Geobits 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? – Oberon Mar 5 '14 at 14:22
• esolangs.org Hello, World! – Geobits 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. – algorithmshark Mar 5 '14 at 23:32

# Perl

Hello, World!
$ ## 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 pn ad sp 12 ; 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 pr ad sp 1  # 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... – WallyWest 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. – Jonathan Van Matre 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 # 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)

# J - 73 char

It can be done, after all!

72 101 108 108 111 44 32 87 111 114 108 100 33{do 1 8{show 0 def 0
take
)


Here's the thing about J. Most of the primitives are ASCII punctuation, followed by up to two dots or colons. Those primitives that aren't made of punctuation are an alphanumeric character followed up to two dots or colons. So we're allowed none of those, except for { } [ ]. [ and ] are identity verbs and are thus useless.

Luckily, { indexes arrays, so if we had, say, a string with every single ASCII character (a., called Alphabet), we could pull the letters out by their ASCII codepoints. We also have a backup way of making strings, 0 : 0 and then stuff and then a lone ); the colon in which has an alias in the standard library, def.

Then there's a verb in the standard library, show, that gives you the internal representation of a verb if you pass it the name as a string. There's another verb, do, that will eval a string. So if we can pull out an a. from any such representation, we can eval that and pull out Hello, World!.

Our saviour comes in the form of take, an alias for {. that has an a in its name. show'take' will return take=: {., so we have our a. and thus a solution.

We can get rid of { by using the essentially equivalent pick` from the standard library, but the paren at the very end can't be avoided.