text:
The alphabet in programming languages
Our task is to, for each letter of the (English) alphabet, write a program that prints the alphabet, in a language whose name starts with that letter.
Input: none
Output:
abcdefghijklmnopqrstuvwxyz

uppercase and trailing newline optional
Rules:

The scoring metric is the length of the programming language name, plus the length of the code.  Hence, C will be assessed a "penalty" of 1, while GolfScript will be assessed a penalty of 10.
One language/implementation per answer.  Multiple answers are encouraged.
If a programming language name's first letter is not an English letter, it should not be coerced into one.  It will be treated as a separate letter (meaning less competition).
No answer will be accepted until every English letter has a solution.

Current rankings:

APL: 5
BNQ: 10
Canvas: 7
DOS: 13
ESMin: 7
Fig: ~4.646
Gs2: 4
Husk: 8
Implicit: 15
Japt: 6
Keg: 6
Ly: 13
MATL: 7
Nibbles: 9.5
Ohm v2: 9
Pip: 4
QuadR: 9
RProgN: 7
Stax: 6
Thunno: 8
Uiua: 10
V: 4
W: 4
XJam: 10
Y: 30
Z80Golf: 16

Tell me if I'm missing anybody.
Automatic leaderboard (experimental)

var QUESTION_ID=2078;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&r.indexOf('non-competing')===-1&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],lang:/a)-(d<a)||e.size-s.size});var s={},a=null,n="A";e.forEach(function(e){n=e.lang[0].toUpperCase(),a=e.size;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+" is for").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.lang,p=o[0].toUpperCase();s[p]=s[p]||{language:e.language,lang:e.lang,letter:p,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return(e.letter>s.letter)-(e.letter<s.letter)});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.language).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),jQuery("#languages").append(jQuery(i))}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*(?:<[^>]+>)?(?:[^]+?for )?((?:]*?>)?(?:(?! [(=→-])[^\n,:])*[^\s,:])(?:[,:]| [(=→-]).*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px} /* font fix */ body {font-family: Arial,"Helvetica Neue",Helvetica,sans-serif;} /* #language-list x-pos fix */ #answer-list {margin-right: 200px;}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Winners by Letter

Language	User	Score

{{PLACE}}	{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Everything

	Language	Author	Size

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Are we allowed to print junk to stderr?

@Peter Taylor: Go nuts.  To answer your question, yes, printing junk to stderr is fine (as long as stdout is correct).

Is it OK to print the alphabet IN BIG LETTERS?

Funge is distinct from Befunge. Surely my pedanticism will be rewarded on a site dedicated to feats of it!

Is anyone going to update the rankings?

Is *0*5AB1E the same as *o*sabie :P?

Does "x86" work as the name for x86 machine code?  Out of all ISAs, x86 is clearly recognizable as the name of this one.  It's not a language that people regularly program in directly; usually we generate it from assembly language (or higher level languages) so "x86 machine code" is as much a description as a name.  A 9-byte x86 function was straightforward, so that would give a score of 12.  Or 11 if we use "IA" (Intel Architecture) as the name of the language, but xtal 35 has much more room for improvement so that's a more useful answer to reducing the total sum length across all letters.

Is ,,, the same as (*C*ommata) :P?

Is length in characters or bytes?

K is for K, 12 characters -> Score: 13
`0:_ci97+!26

Surely you can adapt one of your solutions to A+, right?

Setting up A+ is a little funky. I've done it before but I don't really feel like it. (Owl, newLISP and zshell were all turnkey.)

i assume that's k2 or k3. in k4/q, you can do it in 7 chars with 1 .Q.a;.

you don't need \0:or1@` in codegolf

P is (actually) for Piet - 57 codels
Large version (codel size = 6)

Small version (codel size = 1)

Tested with Erik's piet interpreter npiet and developed with Piet Creator.
Edit: Here is a "trace" version (generated with npiet -tpf) so you can see how it works.
Execution starts in the top left and goes around the border clockwise. The top edge and right edge are setup (calculating the value of a (97) takes quite a few codels). The loop starts on the bottom edge and goes to the left edge. When the value of z is reached the program turns right into the cross section under the first P and terminates.

Click the image to enlarge and see details

Oooh, Piet is always a nice one. And you don't happen to have a working Windows binary of Piet Creator lying around, do you? (I was too lazy to hunt all dependencies and prerequisites just to play around a bit again.)

And aren't that actually 400 codels and 57 coding codels? (I don't think we had a consensus how to count Piet here, though)

@Joey I'll see if I can cook up a build of Piet Creator for windows. It's been awhile since I tested it there. You're right about the codels. If I was to lay the program out in a line it would be 57 codels (give or take a few), the version above is more eye friendly (like whitespace in other langs). Perhaps Piet submissions should have both minimal and eye-catching sources. We better decide, because I'm planning many more Piet answers :)

Well, you could open a question on meta to ask for clarification how Piet code should be handled :-). I would have submitted Piet solutions too, long ago. Except pietdev was quite buggy and for Piet Creator I needed Qt and a few other things just to build it ;-). And just using a bitmap editor is quite ... cumbersome ...

@Joey Piet Creator still needs several important enhancements to be truly awesome, hopefully I can add those soon. I end up using mainly Piet Creator, and then use Paint or the GIMP to move blocks of color around. Pietdev was my main inspiration for PC. Getting some feedback on PC would be great, I'll get on that windows build ASAP.

@Joey The github site now has a windows build from today. Let me know if you find any bugs (I'm sure you will). My email is in the README. https://github.com/Ramblurr/PietCreator/downloads

P is for Perl, 10 characters -> Score: 14
print a..z

What about say a..z?

P is for Python 2, 29 chars -> Score: 35
Every few years I come here with an update. See below.
Also I'm proposing the addition of range expressions to Python over here with demo code here. That would allow us to make an even more compact answer.
Mar 2023: 29 chars
I realize the question says the output can be uppercase which allows us to shave off another char. It is quite ridiculous I didn't see that before.
print bytearray(range(65,91))

Nov 2019: 30 chars
I did it, after 8 years I realized there is a shorter way in python 2!
print bytearray(range(97,123))

Previous code that was as big as trivial print:
Jul 2011: 33 chars
print'%c'*26%tuple(range(97,123))

print'abcdefghijklmnopqrstuvwxyz'

Edit: Check out the breakthrough with Python 3 where I also found a solution smaller than trivial print: https://codegolf.stackexchange.com/a/195165/2212

This is the same length as print'abcdefghijklmnopqrstuvwxyz'...

Y is for Yoix, 44 characters → Score: 48
int x;for(;++x<27;)yoix.stdio.putchar(96+x);

W is for Whitespace, 72 characters -> Score: 82

[Sp][Sp][Sp][Tab][Tab][Sp][Sp][Sp][Sp][Tab][LF][LF][Sp][Sp][Tab][Tab][LF][Sp][LF][Sp][Tab][LF][Sp][Sp][Sp][Sp][Sp][Tab][LF][Tab][Sp][Sp][Sp][Sp][LF][Sp][Sp][Sp][Sp][Tab][Tab][Tab][Tab][Sp][Tab][Tab][LF][Tab][Sp][Sp][Tab][LF][Tab][Sp][Sp][Sp][LF][LF][Sp][LF][Tab][Tab][LF][LF][Sp][Sp][Sp][Sp][LF][LF][LF][LF]

I spent ages getting this stupid thing to work last night and then found that whitespace doesn't show as code here! Then, while I was sulking, my Internet connection died. So, I'm posting it now just so I didn't waste an hour of my life last night getting it to work.

I would have thought that it was obvious from the now-deleted comment along with my solution that I've never written any Whitespace before. Apparently not.

@Mego Any chance we can have my name taken off this since I had nothing at all to do with it?

A is for APL,  14  11 chars/bytes* → score 14
⎕UCS 96+⍳26

This works at least in Dyalog and Nars2000.

* APL can be written in its own (legacy) single-byte charset that maps APL symbols to the upper 128 byte values. Therefore, for the purpose of scoring, a program of N chars that only uses ASCII characters and APL symbols can be considered to be N bytes long.

⎕a works in APLX.

uppercase and trailing newline optional so ⎕A works.

R is for R, 19 → Score: 20
cat(letters,sep="")

Alternatively (20 characters): cat(letters,sep="")

Is not letters good enough? I don't see the spec specifying the output must be a contiguous string. Sure, the example given is in that form, but the 'trailing newline is optional'?

@Gaffi: I believe I held other languages to the same standard in this thread, namely, the output must be "abc...xyz" exactly, with no intervening characters).  I suppose I could change the rule and win my own contest, but that wouldn't be very fun.

G is for Golfscript, 8 characters -> Score: 18
123,97>+

F is for Fish (><>), 19 chars -> Score: 23
Because it's a damn beautiful language!
30"`"1+::o&p&"y"(?;

Isn't this answer scored 22 because <>> is only three characters long, not four. Is there a reason you used the longer name in the score.

@ppperry Well the language name can't both start with an F and be <><.

The name of the language is ><>, not <><

This doesn't seem to work- it just prints a. https://tio.run/##S8sszvj/39hAKUHJUNvKKl@tQE2pUknD3vr/fwA

R is for Ruby, 13 characters -> Score: 17
A Ruby 1.9 solution Matma Rex came up with:
print *?a..?z

My original Ruby 1.8 solution (15 characters -> Score: 19):
$><<[*'a'..'z']

This one doesn't match the criteria? Output contains additional characters. Also, if it's OK, it'd be $><<[*?a..?z] for Ruby 1.9 (shaving off 2 chars).

Shortest correct version I can conceive is print *?a..?z. It's the same length and the one I suggested above. We can't use $><< because << has some weird precedence rules and everything blows up. We can't use p or puts instead of print since they print every letter on separate line.

Sorry, should've mentioned that this is for Ruby 1.8. In Ruby 1.8, Array#to_s is the same as Array#join, so it'll just print the alphabet with no extra characters. But your 1.9 solution is indeed shorter.

Output is: http://codepad.org/atGFGVuQ

@George: Your output is from Ruby 1.8 (which can be verified here: http://codepad.org/pvyqzaPP). As the post mentions, this is a solution for Ruby 1.9.

@Vent: Sorry... I really know nothing about Ruby, so please forgive me :)

D is for dc, 17 characters → Score: 19
97[dP1+dBD>x]dsxx

outputs "ab" and quits in dc version 1.06.95

@Wossname echo '97[dP1+dBD>x]dsxx' | dc does work in dc version 1.07.1

O is for Owl, 11 characters -> Score: 14
a[%)1+%z>]!

P is for Python 2, 42 characters → Score: 48
import string
print string.ascii_lowercase

print 'abcdefhijklmnopqrstuvwxyz'

print'abcdefhijklmnopqrstuvwxyz'

B is for Befunge → 18 characters
"a"::,1+10p"y"`#@_

Can be done in 16 characters, for a score of 23.

S is for Scala, 16 chars => score 21
'a'to'z'mkString

18 chars => score 23
'a'to'z'mkString""

22 chars => score 27
('a'to'z')map(print _)

C is for C, 36 35 characters → Score: 36
main(a){for(;putchar(a+++64)-90;);}

You can drop 2 characters by assuming a (argc) equals one rather than having to initialize it.

But this doesn't even compile...

Best I could get to compile was 59, or 42 without the include:
#include<stdio.h>
main(){for(int a=27;--a;)putchar(96+a);}

Daniel, it works with MSVC 10 here.

L is for Logo, 26 characters → Score: 30
for[i 97 122][type char i]

P is for Python 2, 41 characters → Score: 47
print''.join(chr(i+97)for i in range(26))

P is for PowerShell, 15 characters → Score: 25
-join('a'..'z')

Hmm, not sure whether to make this W or P.

Technically it's W, since the correct name of the language (and product) is Windows PowerShell. Yes, it bugs me too.

The language is now just PowerShell, with the products being Windows PowerShell or PowerShell Core, so this now has a score of 32.

@dorukayhan: When using PowerShell Core we can also shorten it to -join('a'..'z') which results in 25.

B is for Bash: 4 + 16 = 20
printf %s {a..z}

or 15 with just:
echo {a..z}

if output of the form a b c ... is allowed (as seen in many other answers).

I don't think so. Linefeed is optional, output is "abcdefghijklmnopqrstuvwxyz"

T is for Thue, 35 characters → Score: 39
0::=~abcdefghijklmnopqrstuvwxyz
::=
0

M for Matlab, 13 chars, Score 19
disp('a':'z')

M for Matlab, 18 chars, Score 24
disp(char(97:122))

I don't have matlab at hand but I think you need disp(..) to prevent this outputting ans =  .

Correct, changed in the answer.

A is for AppleScript, 41 -> Score: 52
display alert"abcdefghijklmnopqrstuvwxyz"

I know this is a long time since posting, but you can use "abcdefghijklmnopqrstuvwxyz", since the return value is output to the results pane.

B is for BrainF***, 38 + 9 = 47
++++[>++++++<-]>[->+>++++<<]>++[->+.<]

Can be reduced to 31+9 = 40, if cells wrap around at 256:
++[>+>++<<+++++]>----->[<.+>++]

B is for bc - 2 + 28 = 30
"abcdefghijklmnopqrstuvwxyz"

J is for J, 14 characters -> Score: 15
echo u:97+i.26

Why bother with echo? u:97+i.26 is a complete J program.

Because that has no output when run as a script (for me, anyway).

H is for Haskell, 21 characters → Score: 28
main=putStr['a'..'z']

S is for Scheme, 37 -> Score: 43
(display"abcdefghijklmnopqrstuvwxyz")

I is for Inform 6, 41 + 6 = 47
[Main i;for(i=26:i--:)print(char)'z'-i;];

U is for Unlambda - 8 + 79 = 87
``````````````````````````.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.zr

Q is for QBasic, 29 characters → Score: 35
?"abcdefghijklmnopqrstuvwxyz"

Untested, but programming is like riding a bike, right?

You can get injured while riding a bike.  I dare you to drop that space before the quotation mark.

Nah, that would look too much like "optimized" BASIC programs...

You can use ? instead of print ...

Feel free to edit, I haven't programmed in BASIC for more than a decade.

Done :-). Tested now, even.

You can get fewer points by using QBX. Score 31

You can drop the last quotation mark - QBasic will fix that for you!

L is for LUA: 3 + 40 = 43
repeat n=1+(n or 96)print(("%c"):format(n))until(n>122)

-> 55
repeat n=1+(n or 96)print(string.char(n))until(n>122)

-> 53
for i=97,122 do print(string.char(i))end

-> 40

Please keep the code blocks clean, so user scripts like Code Golf UserScript Enhancement Pack which insert code block sizes in the document can show correct values. I mean, please post separate solutions in separate code blocks and specify the code length outside the code block.

Thanks. This way is much easier to spot out count mistakes: http://i.stack.imgur.com/qezQZ.png Seems you included in both cases the final newline character in the count. That is unnecessary.

@manatwork do you happen to have that userscript lying around anywhere...? the dl link is borked :/

Sorry @cat, I used to mention that one in the comments, as I consider it the official one, but I use a simple one written for my own need.

You can remove 2 bytes (and obfuscate) by using ("").char in place of string.char.

G is for GP, 30 characters -> score 32
Strchr(vectorsmall(26,i,96+i))

If I stole the 36-character C code I could submit it as a score-40 submission for PARI -- though maybe at that point I'd be required to #include <pari/pari.h> at the painful cost of an additional 23 characters.
I'm too embarrassed to submit
"abcdefghijklmnopqrstuvwxyz"

which would be printed in gp.

I is for International Phonetic Esoteric Language (IPEL), 19 bytes + 4 characters = 23 score
{97}{q}0ɑbesχue1søɒ

Score can be is 24 if since IPEL is acceptable.
Explanation
{97}{q}0ɑbesχue1søɒ
{97}                (push ord of "a")
    {q}0            (push loop bounds: 0 to 26. Q == 26 in base36)
        ɑ           (start loop)
         besχu      (print chr[65+index])
              e1sø  (increment index)
                  ɒ (end loop)

I is for International Phonetic Esoteric Language (IPEL), 20 bytes + 40 4 characters = 60 24 score
{97}{26}0ɑbesχue1søɒ

"IPEL" is acceptable in my opinion.  I'm only disappointed that the numeric literals keep the entire script from having a standard pronunciation.

hmm maybe i should allow letters in multi-digits and make it base 36 if it has a letter

B, 45 -> Score: 46
main(){auto i;i=95;while(i++<122)putchar(i);}

m4, 26 characters -> Score: 28
abcdefghijklmnopqrstuvwxyz

(Hey, shinh lists it as a supported language)

Xtal, 31 characters -> Score: 35
"abcdefghijklmnopqrstuvwxyz".p;

Awesome, thanks for filling in X with something interesting!  I guess you mean Gnu Xtal System (found with a Google search), but I'm not sure.  Could you add a link?

It's actually Xtal as used in golf.shinh.org: http://code.google.com/p/xtal-language/ , you can see some post-mortems at http://golf.shinh.org/l.rb?xtal

E, 28 characters → Score: 29
for x in 0..25{print('a'+x)}

N is for newLISP, 35 characters -> Score: 42
(print"abcdefghijklmnopqrstuvwxyz")

Z is for zsh, 31 characters -> Score: 38
echo abcdefghijklmnopqrstuvwxyz

L#, 28 characters → Score: 30
"abcdefghijklmnopqrstuvwxyz"

F is for False, 17 characters -> Score: 22
97[$123\>][$,1+]#

A is for awk: 37 characters -> score 40
BEGIN{for(i=96;i++<122;)printf"%c",i}

U is for Unicon, 50 + 6 = 56
procedure main();every writes(char(97 to 122));end

c,34 characaters -> score : 35
main(a){for(;a++<27;putch(95+a));}

putch isn't in standard C, and isn't present on my system.  Thus, I'm not going to add this to the rankings, at least not under C.  Arguably, you could change the language name to "VC" (for (Microsoft) Visual C) and put it under V ;-)

@Joey: Shouldn't any C example be classified under the compiler name, then?

@Joey, @avinashse: I went ahead and reluctantly added this to the scoreboard.

talking about vc++... if you set the entry point to f and the subsystem to console, you get a breathtaking 1 + 30 = 31
f(a){26-a&&f(putch(a+97)-96);} :)

PHP, 26 characters -> Score: 29
abcdefghijklmnopqrstuvwxyz

P is for PostScript, 29 chars → Score: 39
(abcdefghijklmnopqrstuvwxyz)=

G is for Groovy, 25 -> Score: 31
('a'..'z').each{print it}

V is for VBA - 43 (40+3) or 32 (29+3)
(formatted to run in the immediate window)
40 chars
For b=65 To 90:c=c & Chr(b):Next:Print c

And shorter, but no thinking involved:
29 chars
?"abcdefghijklmnopqrstuvwxyz"

You can crunch the loop method to 27+3 by using ? for print and ; to make it not insert a newline.  for i=65to 90:?chr(i);:next

Forth, 29 + 5 Score: 34
: a 123 97 do i emit loop ; a

Previous (Forth, 48 + 5 Score: 53 (unclean score = 48))
: a 97 begin dup emit 1 + dup 123 = until drop ;

This is the clean version.
: a 97 begin dup emit 1 + dup 123 = until ;

The second one leaves stuff on the stack.
a
abcdefghijklmnopqrstuvwxyz  ok

Or even : b ." abcdefghijklmnopqrstuvwxyz" ; at 36 characters

If uppercase output were permitted then you could drop a character with 91 65 do ... I have to say you should probably include the word a (+2 chars) at the end of your line for these to be "programs", otherwise nothing is actually executed or printed. :( I do like golfing in Forth but it often carries that penalty!

@DarrenStone OK, I've changed it - I do wonder about that though as I see, for example C source code in code golf that would also not print anything without being compiled and executed at a command line. I'm just starting out at code golf and trying to remember Forth from my youth. It is fun.

Yeah, it sucks that control structures (IF, LOOP, etc.) can't be used in interpreted mode, only in a word definition. Shaving down your string constant idea, the following would be a program and requires no word definition/execution penalty.  ." abcdefghijklmnopqrstuvwxyz"  Unfortunately, it's 30 chars! Happy Forthing!

C++, 32 + 3penalty = 35
I could not find C++. So this is my option for it:
char a=96;while(a++<122)cout<<a;

the output is:
abcdefghijklmnopqrstuvwxyz

PS. It's my first golf, pls comment if i did something wrong

A is for APL, 9 characters → Score: 12
17↓43↑⎕av

Take the first 43 characters from ⎕av, then drop the first 17 of those.
(Tested in Dyalog APL)

Are you sure this works in a version of Dyalog that predates the question?

I checked via archive.org what the current version was in February, 2011, which was 12.1. Checking the manual for that shows that ⎕av was a feature, so it should work.

Sounds good; I'd appreciate if you test it though.

Couldn't get hold of a 12.1 myself, but I asked the developers of Dyalog, and they tried it and confirmed that it worked the same all the way back to 10.0, which should be well before the question was posted :) https://twitter.com/dyalogapl/status/695184773266960384

brainfuck, 60 -> 69
+++++[>+++++<-]>+>++++++++[>+++[>++++<-]<-]>>+<<<[>>>.+<<<-]

Try it online!
-2 bytes thanks to Dust

Consider doing the addition at the beginning (the first 3 chars) later in the code. You could golf 2 bytes with +++++[>+++++<-]>+>++++++++[>+++[>++++<-]<-]>>+<<<[>>>.+<<<-].

A is for APL, 2 → 5
⎕a

Works on MicroAPL's APLX.

V is for Vim, 9+3 → Score: 12
:h<_<CR>LY<C-^>P

The screen must be exactly 66 characters wide, and 8 lines high. You can check this with tput cols and tput lines.
The program should be executed with:
echo>file.txt && /bin/vim -u NONE $'+normal :h<_\xALYZQP' '+wq' file.txt && cat file.txt

As discussed in this vim scoring meta post

Since a trailing newline is optional, you might as well drop the V to save a byte, and replace the p by P

L is for Lua, 49 bytes → Score: 52
Previous answer for Lua had each letter printed on a new line. All on one line:
s=""for i=97,122 do s=s..("").char(i)end print(s)

Try it online!

B is for Brainfuck, 42 Bytes + 9 = Score 51
+++++++++[>+++++++++++>+++<<-]>-->-[-<.+>]

Ungolfed and commented
+++++++++[>+++++++++++>+++<<-]  Leaves the tape with the values 99 and 27.
>--                             Subtracts 2 from 99 to make 97, the ASCII Code for an "a".
>-                              Subtracts 1 from 27 to make 26, the number of letters in the alphabet.
[-<.+>]                         Outputs the letter, adds 1 and decrements from the number of letters remaining.
                                When no letters are remaining, the loop Exits.

B is for brainfuck, 32 31 + 9 = 40
-1 byte thanks to Jo King
-[>++>+<<-----]>----->+[<.+>--]

Try it online!
-[>++>+<<-----]> is derived from the initialization part for 51 and generates the following layout: 102|51. The next part >----->+ changes this to 97|52 where 52 is double the amount of letters in the alphabet and 97 is the charcode of a. The final loop [<.+>--] prints a letter and increments the charcode and decrements the counter twice.

B is for Brachylog, 2 bytes → Score: 11
Ạẉ

Try it online!

C is for Cubix, 15 bytes, Score -> 20
uo)U"z`"-?@./;/

Try it online!
Cubified
    u o
    ) U
" z ` " - ? @ .
/ ; / . . . . .
    . .
    . .

Watch it run

X is for x86, 9 bytes + 3 -> score 12
(or "x86 machine code" for 9 + 16 = 25)
b0 61 aa 40 3c 7a 76 fa  c3

This is a function, callable with void alpha(char edi[26]), like the x86-64 System V calling convention but in 32-bit mode.  Or 16-bit mode (where 40 decodes as inc ax, otherwise the same).
The question says "program" that "prints", and this is neither of those things.  I'm not sure this should count.  Making a DOS .com executable out of this would take a few extra bytes, or the .text section of a Linux executable, including print and exit system calls.  But there are several other answers (like some C++ ones) that are merely snippets that wouldn't even compile without #include<iostream> and int main(){.
I'm just going to follow modern codegolf defaults for I/O methods (Default for Code Golf: Input/Output methods) which include returning a string in the caller's buffer.

An x86-64 version would cost 1 extra byte for inc al or inc eax, and 3 extra characters in the language name.  I could call it x64 but that implies Windows where the standard calling convention doesn't use RDI.  But that's irrelevant, this is an asm / machine-code answer which doesn't care about being called from other languages.  So anyway, I could say "x64" for a 10 + 3 = 13 version, but I hate that name because it goes with using "x86" to mean specifically 32-bit, instead of the whole ISA.
Ungolfed:
                machine code     NASM/FASM source
     1                         alpha:
     2 00000000 B061               mov  al, 'a'
     3                         .loop:               ; do {
     4 00000002 AA                 stosb              ; *edi++ = al
     5 00000003 40                 inc  eax           ; more compact than inc al
     6 00000004 3C7A               cmp  al, 'z'
     7 00000006 76FA               jbe  .loop       ; }while(al<='z')
     8 00000008 C3                 ret

Try it online! with a FASM _start caller.

Justification: "x86 machine code" is as much a description as a name.  Machine code is something you can program in and can be considered a family of languages.  But those languages don't usually have names other than the ISA.  I'd usually say "x86 32-bit machine code" when posting an answer like this, but that's just to make it clear the answer is the machine code, not the asm source text in the same listing.
Out of all ISAs, x86 is clearly recognizable as the name of this one.  It's not a language that people regularly program in directly; usually we generate it from assembly language (or higher level languages).
"IA" (Intel Architecture) or "IA-32" are other common names for the ISA, so I could argue for a score of 11 in the letter "I".  (But the only "x" answer is xtal at 35, so posting this as x86 is a more useful answer for reducing the total sum length across all letters.
Of course "x86" can be considered ambiguous between the machine code and assembly language.  And without context it's not obviously a programming language because it's better known as the name of an ISA.

I like this answer, it's a great intro to x86 assembly.  I can't believe how few bytes each instruction takes.

@JoeyAdams: There are special-case short forms for the accumulator (EAX / AX / AL), and instructions with implicit operands like stosb.  In "normal" 32-bit code most instructions are 2 to 4 bytes long, or longer with larger addressing modes or SIMD opcodes...  And 64-bit code needs a REX prefix on many instructions, making the avg instruction length more like 4 in compiler output.  See Tips for golfing in x86/x64 machine code  I just updated the source version with comments for the benefit of people who don't know x86 asm, since you mentioned it :P

But yes, ISAs with variable-length instructions optimize for the most common cases.  Original 8086's main bottleneck was code-fetch from memory so they put some care into that design.  It's evolved over time into an ugly Frankenstein's monster though, with much lack of long-term thinking about ISA extensions. :(  See Agner Fog's 2009 blog post, Stop the instruction set war

K is for Keg, 3 + 3 bytes - > 6
azɧ

Try it online!
It seems that the rule disallowing newer languages to be posted has been removed. Let me know if this is somehow invalid.

T is for Triangular, 19 bytes → 19+10 = 29
,5,D@"*i.jC>"dj>F+/

Try it online!
Ungolfed:
     ,
    5 ,
   D @ "
  * i . j
 C > " d j
> F + /

The process here is,

Push 65
Push 27
j is a conditional NorthWest IP switch; it changes to NW if the top value of the stack is not 0. This means we have the equivalent of looping from 26 to 0 (because we decrement prior to entering the loop)
Decrement → j → Swap top 2 stack values → Print, don't pop → Increment → Swap → Repeat

This turns out to be 1 byte shorter with capital letters than lower case due to 97 being prime.

P is for Python 3, 32 chars -> Score: 38
print('%c'*26%(*range(97,123),))

Using uppercase letters, this can be made shorter
print('%c'*26%(*range(65,91),))

This is based in my 2011 answer which is before Python 3.5 added starred tuple unpacking, making it smaller that that one....
EXCEPT for Python 2 also got a smaller version today which is unbeatable :)
Unless Python adds range expressions to the language, which I am proposing here

M is for MAWP, 20 characters - Score: 24
[!43W8WM;1M!93WA?.%]

Explanation:
[        start of loop
!        duplicate top of stack
43W8W    push 96 to stack (4*3*8)
M        add 96 to number below
;        output top of stack as ASCII char
1M       add 1 to top of stack
!        duplicate top of stack
93W      push 27 to stack (9*3)
A        Difference of top two stack values
?.       is equal to zero, then terminate program
%        pop top of stack
]        end of loop

X is for x86-16 MS-DOS machine code - 16 bytes
This is hexdump from .COM file :
00000000  b4 02 b9 1a 00 b7 61 8a  d7 cd 21 fe c7 e2 f8 cd  |......a...!.....|
00000010  20                                                | |
00000011

Code I wrote :
.model small
.code
org 100h

start:

    mov ah, 02h
    mov cx, 26
    mov bh, 97

.loop:
    mov dl, bh
    int 21h
    inc bh
    loop .loop
    int 20h

end start

I use DOSBOX to run this proram

Tcl - 31 + 3 = 34
puts abcdefghijklmnopqrstuvwxyz

My shortest iterative is longer, 45 :time {puts [format %c [expr [incr i]+96]]} 26

Wake, 33 bytes, score 37
all: "abcdefghijklmnopqrstuvwxyz"

B is for Batch File, 31 characters → Score: 41
echo abcdefghijklmnopqrstuvwxyz

Ada, 92 characters -> Score: 95
with ada.text_io;use ada.text_io;procedure a is begin put("abcdefghijklmnopqrstuvwxyz");end;

F is for F#, 36 characters -> Score: 38
printf("abcdefghijklmnopqrstuvwxyz")

E, 26 characters → Score: 27
for x in'a'..'z'{print(x)}

This is based off Joey's answer.

Python, 36 + 6 = 42
print''.join(map(chr,range(97,123)))

Not the shortest...

V is for VBScript, 40 Characters → Score: 48
for i=97 to 122:a=a+chr(i):next:MsgBox a

P is, in fact, for PHP - 23 chars / 27 score
<?=join('',range(a,z));

P is for PHP - 33 characters - Score: 36
echo implode("",range("a", "z"));

V for VBA: 60
Sub VforVBA()
For i=1 To 26: a=a & Chr(64+i): Next: Debug.Print a
End Sub

Can you remove any of the spaces between the tokens?  E.g. For i=1To26:a=a&Chr(64+i):Next:Debug.Print a

@JoeyAdams edited as suggest

Did you test this?  Is "Fori" treated as "For i"?

@joeyAdams Yea you're correct, indeed the 1To26 and other parts won't work as well.  I have changed it back to origin answer

@Alex I think you can remove some spaces (i = 1, : a = a & Chr(64 + i), : Next: Debug)

C++: 32+3 = 35
char c=96;while(c++<122)cout<<c;

I almost want to score this as 32, given that your code contains "c++".  Alas, I didn't put this in the original rules.

@JoeyAdams You're right, I corrected it :)

C is for Clojure - (39 or 53) + 7 = 46 or 60
No, it doesn't stand for C. In Clojure, all functions form closures, so I would argue this is a complete answer, in 39 bytes.
(doseq[c(range 97 123)](print(char c)))

But if you really want it with the main function, 53 bytes.
(defn -main[](doseq[c(range 97 123)](print(char c))))

But, this isn't a Clojuric way to solve this problem. Let's try something simpler (could be golfed for 4 bytes).
(print (apply str (map char (range 97 123))))

Much better, isn't it?

U is for Unix Shell, 21 Characters → Score: 31
echo {a..z}|tr -d " "

I think printf '%s' {a..z} would shave off some chars

N is for Nu, 35 Characters → Score: 37
(puts 'abcdefghijklmnopqrstuvwxyz')

N is for Nim, 31 → Score: 34
for x in'a'..'z':stdout.write x

S is for SMBF, 10 chars -> Score: 14
SMBF stands for Self-modifying Brainf***, and both names are used interchangeably. The original interpreters were named smbf.c and smbf.rb.
\x1a is a hex literal (a single non-printable ASCII character) for the decimal number 26.
<[-<.+>]a\x1a

The \x1a is used as a loop counter. a is printed and incremented each time.

B is for Bash, 11 -> 15 24

echo {a..z}

echo {a..z}|tr -d \
                   ^
                 space

Already posted by Eelvex, but sadly it is not valid, because not produces the exact required output.

Don't take it the wrong way. Keep trying, keep posting. If you found this independently, you're very good. In the future, try answering less popular challenges. :-)

ETHproductions, done.

Mouse, 26 + 5 = 31
97a:(a.123<^a.&DUP !'1+a:)

Which outputs:
abcdefghijklmnopqrstuvwxyz

Note the lame way would be:
"abcdefghijklmnopqrstuvwxyz"

Which gets printed implicitly immediately (as string literals do, unfortunately), but it's 28 bytes.

J is for Java - score: 84 characters + 4 = 88
interface a{static void main(String[]A){for(char c=65;c<91;System.out.print(c++));}}

This prints ABCDEFGHIJKLMNOPQRSTUVWXYZ instead of abcdefghijklmnopqrstuvwxyz. If it's disallowed, one can simply set c to 97 (a) and loop until it reaches 123 ({) at the cost of one extra byte:
interface a{static void main(String[]A){for(char c=97;c<123;System.out.print(c++));}}

S is for seed7, 137 114 78 characters → Score: 83
const proc: main is func begin writeln("abcdefghijklmnopqrstuvwxyz");end func;

F is for Funge → 19 chars + 5 = 24
'\`#;1+::,"@9"+\`#@_;

Something that makes this unique is that it doesn't contain a single letter of the alphabet! Hence why I didn't shorten it by replacing "@9"+ with 'y. I'll take the points hit for it.
Try it with my interpreter here: BefungeSharp.

D is for D2, 2 + 6 = 8
!a[.+]

!a expand to 10 +, setting the current cell to 10 (a in base 36), and [.+] print the current cell as a base 36 string and increment the cell. Since the maximum value a cell can hold is 35, at 36 the cell is zeroed and the loop stop.

S is for Swift, 76 characters -> Score: 81
var s=""
for i in 97...122{s.append((Character(UnicodeScalar(i))))}
print(s)

Isn't it easier to just print a string containing the alphabet?

Of course, but that just wouldn't be as fun

my_string could be reduced to one letter.

good call @pppery

You should update the bytecount after golfing your answer.

R, 26 bytes (score 27)
paste(letters,collapse="")

Output:
[1] "abcdefghijklmnopqrstuvwxyz"

S is for SmileBASIC, 39 37 bytes
FOR I=65TO 90?CHR$(I);:NEXT

I do not believe you have properly read the scoring rules for this challenge. Your score is the length of your code plus the length of the language name.

Fixed, sorry. (padding)

You can save 2 characters by adding 65 to the start/end of the loop.

Y is for Yorick, 30+6 bytes → 36
system,"echo {a..z}|tr -d ' '"

Z is for Zsh, 21+3 → 24 bytes
echo {a..z}|tr -d ' '

Try It Online!

R is for R, 17 bytes Score -> 18
intToUtf8(97:122)

Try it online!

M is for M, 20 characters → Score: 21
let s={"a".."z"}in s

(M language reference)

Z is for Z80Golf, 9 bytes + 7 = 16
00000000: 3e61 061a ff3c 10fc 76                   >a...<..v

Try it online!
According to the Web Archive, Z80Golf code golf machine was created (at least) in December 2007.
Disassembly
start:
  ld a, 97  ; the char to print
  ld b, 26  ; loop count
loop:
  rst $38   ; 1-byte alias for putchar
  inc a
  djnz loop ; decrement b and jump to `loop` if nonzero
  halt      ; end program

Z is for Zsh, 19 characters -> Score: 22
19 character solution thanks to @GammaFunction.
<<<${(j::):-{a..z}}

Another 18 character solution using Perl.
perl -eprint\ a..z

Not sure whether that would qualify for Zsh, it's more "Zsh+perl" (which would have a much larger penalty). You can get a pure Zsh answer in 19 characters, though: <<<${(j::):-{a..z}}

I is for Io, 31 characters -> Score: 33
for($,65,90,$asCharacter print)

F is for Fish, 16 bytes; score 20
"a"r:o1+:"{"=?;r

F is for Forth (gforth), 26 + 5 = 31
'{ 'a [do] [i] emit [loop]

Try it online!
Two improvements over the submission by leancz 6 years ago:

An ASCII char prefixed with a quote gives the ASCII value of that char. So '{ saves a byte over 123. 'a is just for consistency.
The looping words including do and loop can't be used in interpreted mode, but gforth provides interpreted versions surrounded with brackets like [do] and [loop]. If a function uses three or less such words, using interpreted mode saves some bytes, as illustrated below.

\ using compiled mode
: a '{ 'a do i emit loop ; a
\ using interpreted mode
'{ 'a [do] [i] emit [loop]

P is for Pyth, 1 character -> Score: 5
G

Try it out!
That's it - just 1 letter. This is how it works:

The variable G is by default initialised to abcdefghijklmnopqrstuvwxyz in this language.
By default, the value returned by a program is printed out to the standard output.

ink, 26 bytes, score: 29
Glad to hear that newer languages are allowed.
abcdefghijklmnopqrstuvwxyz

Try it online!

Jelly, 2 bytes, score: 7
Jelly has a built-in.
Øa

Try it online!

Pyth, 1 byte, score: 5
Pyth has a shorter built-in than Jelly.
G

Try it online!

Pip, 1 byte, score: 4
z

Try it online!

V (vim), 3 bytes, score: 4
¬az

Try it online!

Wren, 58 bytes
The iteration method
System.printAll((97..122).map{|i|String.fromCodePoint(i)})

Try it online!
Wren, 42 bytes
The boring method
System.print("abcdefghijklmnopqrstuvwxyz")

Try it online!

Ni, 13 bytes, score: 15
#61>#1a{<!+>}

Try (the snippet) online!
Explanation
#61           Set Current as 'a'
   >          Move the pointer right
    #1a       Set current as 26
       {      Repeat 26 times:
        <         Move left
         !        Print the letter
          +       Increment the letter
           >      Move right
            }     (Automatically decrement counter)

W, 3 bytes (score: 4)
Near built-in solution, intended to beat Wake.
'zk

Explanation
'z   Push the character z
  k  Generate a downwards character range for that character.

Befunge-93, 33 bytes
I thought I could beat Brachylog... never mind.
"a">:,1+:"{"-#v_@
   ^          <

Try it online!

Husk, 4 bytes → Score: 8
…"ab

Try it online!

…"ab saves a byte.

Ly, 11 bytes -> Score: 13
'Rrp['`+o]

Try it online!
Explanation
'          Push 26
  R          0-range
   r         reverse stack
    p        Pop 0
     ['`+o] Output the whole stack, added by 97

This less interesting, since it's brute force, but shorter https://tio.run/##y6n8/189Ub0qSC3//38A
which is this:   'a'zR&o

F is for Foo, 17 bytes, score: 20
&65>&26(-1<$c+1>)

Try it online!
Ties the Fish answer.

DOS, x86, 10 bytes + 3 = 13
This answer is fundamentally the same as Peter Cordes' x86, but uses DOS for I/O and as the "framework" of sorts to be able to "print[s] the alphabet" per the challenge description.
One could attempt to make the case that since this uses DOS API for said I/O that it one-step higher level than just x86.  After all, DOS is an operating system, programming API, interpreter and framework all rolled into one, right?  Also most every submission here eventually gets compiled down to machine code eventually to run, so aren't we really considering the submission to be the highest level required to produce the desired output?
Okay, feel free to call this rationalization baloney.  It's not shorter than Peter's earlier x86 so just thought I'd throw in another take, competing or not! :)
Binary:
00000000: b061 cd29 403c 7a7e f9c3                 .a.)@<z~..

Listing:
B0 61       MOV  AL, 'a'        ; start at 'a'
    CLOOP:
CD 29       INT  29H            ; write AL to console
40          INC  AX             ; increment letter
3C 7A       CMP  AL, 'z'        ; is <= 'z'?
7E F9       JLE  CLOOP          ; if so, keep looping
C3          RET                 ; return to DOS

And yes "DOS" can be considered a generic term for other different non-IBM PC Disk Operating Systems.  However Wikipedia's entry for "DOS" specifically refers  to IBM DOS and describes DOS as "a common shorthand for disk-based operating systems on IBM PC compatibles".

Q is for QuadR, 26 bytes, Score: 31
abcdefghijklmnopqrstuvwxyz

Try it online!

V for Vyxal, 2 bytes, score 2+5=7
ka

Try it Online!
Dunno someone has posted this already

K is for K (ngn/k), 9 bytes -> Score: 18
`c$97+!26

Try it online!
Bruh.

Fig, \$2\log_{256}(96)\approx\$ 1.646 bytes + 3 = 4.646
ca

Try it online!

N is for Nibbles, 2.5 bytes (5 nibbles) + 7 = score 9.5
|@\$l

Attempt This Online!
|           # filter
 @          # printable ASCII characters:
  \         #   is the character
   $        #   of each of them
    l       #   a lowercase letter?

Q is for QuadR, 8 bytes, score: 13
819⌶⎕A⋄⍵

Try it online!
Explanation
Lowercase (819⌶ - "BIg" without a boolean is un-BIg) the uppercase alphabet (⎕A). The ⋄ avoids any additional output, and the ⍵ means this line should be run as code, rather than as a regex transformation.

QuadR, 4 bytes, score: 9
I didn't realise it was allowed to use uppercase alphabet, which simplifies this greatly...
⎕A⋄⍵

Try it online!

Y is for Y, score 30 (29 bytes)
"abcdefghijklmnopqrstuvwxyz"p

Try it online by copy-pasting the code above and clicking the timeout run button.
Explanation:
"abcdefghijklmnopqrstuvwxyz"  # Push all characters between the "-quotes to the stack
                            p # Print the entire stack to STDOUT

M is for MATL, 3 bytes, Score 7
2Y2

Try it online!

vimscript
What does output mean?
Assuming output to the current vim buffer is ok:
:norm aabcdefghijklmnopqrstuvwxyz

Otherwise, output to stdout:
:!echo abcdefghijklmnopqrstuvwxyz

PHP, 26 + 3 = 29
<?=implode('',range(a,z));

AWK,33+3(Penalty)
END{for(;i<26;)printf"%c",97+i++}

JavaScript, 34 + 10 = 44
alert('abcdefghijklmnopqrstuvwxyz')

alert(8337503854730415241050377135811259267835n.toString(36)) ;)

H is for HTML -> 4+31
abcdefghijklmnopqrstuvwxyz

ps: browser will interpret the missing end tag

ABCDEFGHIJKLMNOPQRSTUVWXYZ is far better at 30.

T is for TI-BASIC, 27 + 8 = 35
"ABCDEFGHIJKLMNOPQRSTUVWXYZ

Can be run from command line, as a standalone program, or called as a function.

S is for Scala, Score: 40
print("abcdefghijklmnopqrstuvwxyz")

Racket, 46 bytes (score 52)
(for((i 26))(display(integer->char(+ i 97))))

B is for Bash, 25 bytes
echo {a..z}|tr -d ' '

(21 bytes of code plus 4 for the language name)

R is for REXX, 15 characters → Score: 19
say xrange(a,z)

U is for uBASIC, 36 bytes → Score: 42
1 PRINT "abcdefghijklmnopqrstuvwxyz"

Try it online!

S is for SmileBASIC, 27 bytes + 10 = 37
FOR I=65TO 90?CHR$(I);
NEXT

Prints the alphabet in uppercase. (I'm not sure whether this is allowed, but other people are doing it so...)
Just 1 character shorter than the (even more) boring answer:
?"abcdefghijklmnopqrstuvwxyz

F is for FALSE, 15 bytes +5 = 20
97[$'{-][$,1+]#

Doesn't use any letters!
Explanation:
97 {push 97 (ASCII for 'a')}
  [ {function start}
   $'{- {subtract '{' from the current letter}
       ] {function end}
        [ {function start}
         $, {print the current letter}
           1+ {add 1}
             ] {function end}
              # {while loop. Run the second function while the first doesn't return 0}

V is for VBA, 28 + 3 = 31
Anonymous VBE immediate window function that takes no input and outputs abcdefghijklmnopqrstuvwxyz to the VBE immediate window.
The two solutions below are of equal length and produce the same output
For i=97To 122:?Chr(i);:Next

Or
?"abcdefghijklmnopqrstuvwxyz

U is for uBASIC, 30 + 6 = 36
Anonymous function that takes no input and outputs abcdefghijklmnopqrstuvwxyz
0?"abcdefghijklmnopqrstuvwxyz"

Try it online!

I is for ICI, 37+3 bytes → 40
printf("abcdefghijklmnopqrstuvwxyz");

I is for Io, 35+2 bytes → 37
"abcdefghijklmnopqrstuvwxyz"println

C is for Common Lisp, Score 35 + 11 => 46
(princ"abcdefghijklmnopqrstuvwxyz")

Try it online!

P is for PowerShell, 15 bytes+10 = 25
-join('a'..'z')

Try it online!
Uses the character range feature added in 6.0 to improve upon past answers.

Canvas, 1 byte, score: 7
ｚ

Try it online!

CJam, 7 bytes, score: 11
Learnt this language just for solving this problem.
'{,'a,-

Try it online!

Stax, 2 bytes, score: 6
Also, Stax has a built-in.
Va

Try it online!

Gaia, 2 bytes, score: 6
₵a

Try it online!

MathGolf, 1 byte, score: 9
▄

Try it online!

Japt, 2 bytes, score: 6
;C

Try it online!

05AB1E, 1 byte, score: 7
A

Try it online!

Jsonnet (with -S), 37 characters, score: 44
std.repeat("%c",26)%std.range(97,122)

Sample run:
bash-5.0$ jsonnet -Se 'std.repeat("%c",26)%std.range(97,122)'
abcdefghijklmnopqrstuvwxyz

C is for C, 34 bytes + 1 = 35
c(i){for(i=26;i;)putchar(91-i--);}

33 bytes

X is for XJam, 6 + 4 = 10
'[,65>

What is XJam, you may ask? It's a language I started creating earlier this year and gave up before doing anything really interesting. It technically does fulfill its design criteria though, which is to be a version of CJam which adapts to the informal specification in the xkcd comic X. It accomplishes this by using a custom charset where Unicode characters representing variations on the letter X fill the top 32 slots in  what's otherwise standard 7-bit ASCII. Those characters are then the only ones which can be used as variables. It also happens to be perfect for this challenge, beating the previous x answer by two. (Sorry Peter Cordes, that x86 answer was great!)
Credit where it's due, the code is taken from Lynn's answer on a different question here. It doesn't use variables so it ports over perfectly.

Eso2D, 15 bytes + 5 = 20
2v
,>#1~5
@#,5<

Eso2D is a language starting with E that has a relatively short name and an instruction set very good for string construction that I found on the esolang wiki. This could probably be improved further, but it's more than enough for a new best E.
Explanation:
2v        Increment the accumulator by 97 and move down to the second row
,>#1~5    Loop (from wrapping): print num to char, add 50, check if > 170, decrement by 49 otherwise.
@#,5<     Once it hits 171, decrement by 49 and print one last time before stopping.

Foo, 11 bytes, score 14
&65(91$c+1)

Try it online!
&65(91$c+1)

&65           # Set current cell to 'A'
   (91    )   # While current cell != 'Z'+1
      $c      # Print ASCII of current cell
        +1    # Increment current cell

Beats the previous Foo answer by not using another cell.

G is for gs2, 1 + 3 = 4 bytes
à

Uses the CP437 encoding.
Hexdump:
85

P is for Pyt, 4 bytes
ɫ

Try it online!
Gotta love builtins

T is for Thunno, 2 + 6 = 8
Az

Attempt This Online!

B is for BQN, 7 bytes + 3 = score 10
'a'+↕26

Try it at BQN REPL
    ↕26     # range from 0 to 25
   +        # add to
'a'         # character 'a'

E is for ESMin, 2 Bytes, Score 2+5 = 7
ᶛ

Try it online, firefox only

O is for Ohm v2, 3 bytes, 6+3 = 9
αa,

Try it online!

RProgN, 1 byte, 6+1=7
a

Try it online!

Implicit, 7 bytes, 7+8=15
26¡"é64

Try it online!
26¡"é64
26¡      # range [1,26]
   "     # convert entire stack to ascii character
    é64  # increment each character by 64

Created with the help of Luminespire.

U is for Uiua, 6 bytes, Score 10
+@A⇡26

First Non-Vyxal answer


text:
Smallest Javascript CSS Selector Engine
Create a small acceptably efficient JS CSS selector engine.
Please post size of script, and function to call preferable $(selector,context) style.
EDIT:  All major browsers support document.querySelectorAll which makes this question irrelevant.

Try to beat jQuery: it is 85,000 bytes.

Sizzle, rather.

Would it hurt to write a requirements spec, or at least link to a description of precisely what is meant by "JS CSS selector engine"?

@PeterTaylor No it wouldn't hurt.  Feel free to propose an edit.

@LiamWilliam You misunderstand: Peter wants you to make the necessary changes yourself

QuerySelectorAll makes this question irrelevant

Funny, I just made one of these. It is quite efficient because it compiles selectors. I don't know if it's IE6-compatible but it should be, I think. It supports CSS3 too - bonus points? :)
if(![].indexOf)Array.prototype.indexOf=function(a,i){i=i||0;while(i<this.length)if(this[i++]===a)return i-1;return-1};
String.prototype.startsWith=function(s){return this.length>=s.length&&this.substring(0,s.length)===s};
String.prototype.endsWith=function(s){return this.length>=s.length&&this.substring(this.length-s.length)===s};

var Sprint = {
    Error: function(m) {
        this.message = m;
        this.toString = function() {
            return this.message;
        };
    },
    getAllElementsIn: function(element) {
        var r = [];
        var f = function recurse(l, arr) {
            from(l).each(function(k, v) {
                if(v.nodeType === 1) {
                    arr.push(v);
                    recurse(v, arr);
                }
            });
        };
        f(element, r);
        return r;
    },
    getAllElements: function() {
        return Sprint.getAllElementsIn(document.documentElement);
    },
    getSiblings: function(element) {
        return element.parentNode ? from(element.parentNode).where(function(k, v) { return v.nodeType === 1; }).toArray() : [element];
    },
    getInfo: function(selector) {
        var r = {ATTR: {}, CLASS: [], PSEUDO: []};

        var quotes = '\'"', nestable = '(){}', inAttribute = false, escaped = false, currentQuotes = null, currentNested = [], nonchar = /^[^a-zA-Z0-9_\-]$/, lastSplitter = null, i = -1, c, s = '';
        while(++i < selector.length) {
            c = selector.charAt(i);
            if(escaped) {
                escaped = false;
            } else if(c === '\\') {
                escaped = true;
                continue;
            } else if(currentQuotes) {
                if(currentQuotes === c) {
                    currentQuotes = null;
                }
            } else if(quotes.indexOf(c) > -1) {
                currentQuotes = c;
            } else if(currentNested.length) {
                if(nestable.indexOf(currentNested[currentNested.length - 1]) + 1 === nestable.indexOf(c)) {
                    currentNested.pop();
                }
            } else if(nestable.indexOf(c) > -1) {
                currentNested.push(c);
            } else if(nonchar.test(c)) {
                if(lastSplitter) {
                    switch(lastSplitter) {
                        case '#':
                            r.ID = s;
                            break;
                        case '.':
                            r.CLASS.push(s);
                            break;
                        case '[':
                        case ',':
                            if(inAttribute) {
                                var j;
                                if((j = s.indexOf('=')) > -1) {
                                    r.ATTR[s.substring(0, j)] = s.substring(j + 1);
                                } else {
                                    r.ATTR[s] = true;
                                }
                            }
                            break;
                        case ':':
                            r.PSEUDO.push(s);
                            break;
                    }
                } else {
                    r.TAG = s;
                }

                if(c === ']') {
                    inAttribute = false;
                } else if(c === '[') {
                    inAttribute = true;
                }

                lastSplitter = c;

                s = '';
                continue;
            }
            s += c;
        }

        if(lastSplitter) {
            switch(lastSplitter) {
                case '#':
                    r.ID = s;
                    break;
                case '.':
                    r.CLASS.push(s);
                    break;
                case '[':
                case ',':
                    if(inAttribute) {
                        var j;
                        if((j = s.indexOf('=')) > -1) {
                            r.ATTR[s.substring(0, j)] = s.substring(j + 1);
                        } else {
                            r.ATTR[s] = true;
                        }
                    }
                    break;
                case ':':
                    r.PSEUDO.push(s);
                    break;
            }
        } else {
            r.TAG = s;
        }

        return r;
    },
    compileSingle: function(info) {
        var f = 'var t=l.nodeName?l.nodeName.toLowerCase():"",i=l.id?l.id.toLowerCase():"",c=l.className?" "+l.className.toLowerCase()+" ":"",s=Sprint.getSiblings(l),ss=from(s).where(function(k,v){return v.nodeName?v.nodeName.toLowerCase()===t:false;}).toArray(),si=s.indexOf(l),ssi=ss.indexOf(l);return ';
        if(info.TAG && info.TAG !== '*') {
            f += 't===\'' + info.TAG.toLowerCase().replace(/[\\']/g, function(x) { return '\\' + x; }) + '\'&&';
        }
        if(info.ID) {
            f += 'i===\'' + info.ID.toLowerCase().replace(/[\\']/g, function(x) { return '\\' + x; }) + '\'&&';
        }
        if(info.CLASS) {
            for(var i = 0; i < info.CLASS.length; i++) {
                f += 'c.indexOf(\' ' + info.CLASS[i].toLowerCase() + ' \')>-1&&';
            }
        }
        if(info.PSEUDO) {
            for(var i = 0; i < info.PSEUDO.length; i++) {
                var p = info.PSEUDO[i], j, v = '';
                if((j = p.indexOf('(')) > -1) {
                    v = p.substring(j + 1, p.length - 1);
                    p = p.substring(0, j);
                }
                switch(p) {
                    case 'first-child':
                        f += '!si';
                        break;
                    case 'first-of-type':
                        f += '!ssi';
                        break;
                    case 'nth-child':
                        // TODO: Implement all nth-*** selectors.
                        break;
                    case 'nth-of-type':

                        break;
                    case 'last-child':
                        f += 'si===s.length-1';
                        break;
                    case 'last-of-type':
                        f += 'ssi===ss.length-1';
                        break;
                    case 'nth-last-child':

                        break;
                    case 'nth-last-of-type':

                        break;
                    case 'only-child':
                        f += 's.length===1';
                        break;
                    case 'only-of-type':
                        f += 'ss.length===1';
                        break;
                    case 'disabled':
                        f += 'l.disabled';
                        break;
                    case 'enabled':
                        f += '!l.disabled';
                        break;
                    case 'checked':
                        f += 'l.checked';
                        break;
                    case 'empty':
                        f += '!l.childNodes.length'; // TODO: Maybe restrict to elements (t 1) only?
                        break;
                    case 'not':
                        f += '!Sprint.isMatch(\'' + v.replace(/\\'/g, function(x) { return '\\' + x; }) + '\')(0,l)';
                        break;
                    default:
                        throw new Sprint.Error("Unrecognized pseudo-class \"" + p + "\".");
                }
                f += '&&';
            }
        }
        if(info.ATTR) {
            from(info.ATTR).each(function(k, v) {
                var c = k.charAt(k.length - 1);
                f += 'l.getAttribute(\'' + ('$^*~|'.indexOf(c) > -1 ? k.substring(0, k.length - 1) : k).replace(/\\'/g, function(x) { return '\\' + x; }) + '\')';
                if(typeof v === 'string') {
                    v = v.replace(/\\'/g, function(x) { return '\\' + x; });
                    switch(c) {
                        case '$':
                            f += '.endsWith(\'' + v + '\')';
                            break;
                        case '^':
                            f += '.startsWith(\'' + v + '\')';
                            break;
                        case '*':
                            f += '.indexOf(\'' + v + '\')+1';
                            break;
                        case '~':
                            f += '.split(\' \').indexOf(\'' + v + '\')+1';
                            break;
                        case '|':
                            f += '.split(\'-\').indexOf(\'' + v + '\')+1';
                            break;
                        default:
                            f += '===\'' + v + '\'';
                    }
                }
                f += '&&';
            });
        }

        if(f.substring(f.length - 2) !== '&&') {
            // It matches anything.
            f = 'return true  ';
        }

        return new Function(['l'], f.substring(0, f.length - 2) + ';');
    },
    compileTree: function(selector) {
        var t = Sprint.tokenizeSelector(selector), i = -1, j, splitters = ', >~+';
        while(++i < t.length) {
            if(splitters.indexOf(t[i]) > -1) {
                j = i;
                while(--j >= 0 && t[j] === ' ') t[j] = null;
                j = i;
                while(++j < t.length && t[j] === ' ') t[j] = null;
            }
        }
        return from(t).where().select(function(k, v) {
            return k % 2 ? v : Sprint.compileSingle(Sprint.getInfo(v));
        }).toArray();
    },
    matchSingleTree: function(element, tree) {
        if(!tree.length) {
            return true;
        }

        if(!tree[tree.length - 1](element)) {
            return false;
        }

        for(var i = tree.length - 3; i >= 0; i -= 2) {
            switch(tree[i + 1] || ' ') {
                case ' ':
                    while(true) {
                        if(!(element = element.parentNode)) {
                            return false;
                        }
                        if(tree[i](element)) {
                            break;
                        }
                    }
                    break;
                case '>':
                    if(!(element = element.parentNode) || !tree[i](element)) {
                        return false;
                    }
                    break;
                case '+':
                    while(true) {
                        if(!(element = element.previousSibling)) {
                            return false;
                        }
                        if(element.nodeType === 1) {
                            if(!tree[i](element)) {
                                return false;
                            } else {
                                break;
                            }
                        }
                    }
                    break;
                case '~':
                    while(true) {
                        if(!(element = element.previousSibling)) {
                            return false;
                        }
                        if(tree[i](element)) {
                            break;
                        }
                    }
                    break;
            }
        }

        return true;
    },
    matchTree: function(element, tree) {
        var c = [];
        for(var i = 0; i < tree.length; i++) {
            if(tree[i] === ',') {
                if(Sprint.matchSingleTree(element, c)) {
                    return true;
                }
                c = [];
            } else {
                c.push(tree[i]);
            }
        }
        return Sprint.matchSingleTree(element, c);
    },
    tokenizeSelector: function(selector) {
        var quotes = '\'"', nestable = '(){}[]', escaped = false, currentQuotes = null, currentNested = [], tokens = [], splitters = ', >~+', i = -1, c, s = '';
        while(++i < selector.length) {
            c = selector.charAt(i);
            if(escaped) {
                escaped = false;
            } else if(c === '\\') {
                escaped = true;
                continue;
            } else if(currentQuotes) {
                if(currentQuotes === c) {
                    currentQuotes = null;
                }
            } else if(quotes.indexOf(c) > -1) {
                currentQuotes = c;
            } else if(currentNested.length) {
                if(nestable.indexOf(currentNested[currentNested.length - 1]) + 1 === nestable.indexOf(c)) {
                    currentNested.pop();
                }
            } else if(nestable.indexOf(c) > -1) {
                currentNested.push(c);
            } else if(splitters.indexOf(c) > -1) {
                tokens.push(s);
                tokens.push(c);
                s = '';
                continue;
            }
            s += c;
        }
        tokens.push(s);

        return tokens;
    },
    isMatch: function(selector) {
        var f = Sprint.compileTree(selector);
        return function(key, element) {
            return Sprint.matchTree(element, f);
        };
    },
    select: function(selector) {
        return from(Sprint.getAllElements()).where(Sprint.isMatch(selector)).toArray();
    },
    selectIn: function(selector, element) {
        return from(Sprint.getAllElementsIn(element)).where(Sprint.isMatch(selector)).toArray();
    }
};

function from(x) {
    if(!x) {
        throw new Sprint.Error("null or undefined passed to Sprint:from().");
    }

    var r = {
        keys: [],
        values: []
    };

    if(x.length) {
        for(var i = 0; i < x.length; i++) {
            r.keys.push(i);
            r.values.push(x[i]);
        }
    } else if(x.childNodes) {
        return from(x.childNodes);
    } else {
        for(var y in x) {
            if(x.hasOwnProperty(y)) {
                r.keys.push(y);
                r.values.push(x[y]);
            }
        }
    }

    r.length = r.keys.length;

    r.where = function(f) {
        if(f) {
            if(typeof f === 'string') return this.where(new Function(['k', 'v'], 'return ' + f + ';'));

            var r = {};
            for(var i = 0; i < this.length; i++) {
                if(f(this.keys[i], this.values[i])) {
                    r[this.keys[i]] = this.values[i];
                }
            }
            return from(r);
        } else {
            return this.where(function(k, v) { return v; });
        }
    };

    r.select = function(f) {
        var r = {};
        for(var i = 0; i < this.length; i++) {
            r[this.keys[i]] = f(this.keys[i], this.values[i]);
        }
        return from(r);
    };

    r.each = function(f) {
        for(var i = 0; i < this.length; i++) {
            f(this.keys[i], this.values[i]);
        }
    };

    r.first = function() {
        return this.values[0];
    };

    r.last = function() {
        return this.values[this.length - 1];
    };

    r.splitBy = function(f) {
        if(typeof f === 'function') {
            var r = [], c = {};
            for(var i = 0; i < this.length; i++) {
                if(f(this.keys[i], this.values[i])) {
                    r.push(c);
                    c = {};
                } else {
                    c[this.keys[i]] = this.values[i];
                }
            }
            r.push(c);
            return from(r);
        } else {
            return this.splitBy(function(x) { return x === f; });
        }
    };

    r.limit = function(f) {
        var r = {}, i = -1;

        if(typeof f === 'function') {
            while(++i < this.length && f(this.keys[i], this.values[i])) {
                r[this.keys[i]] = this.values[i];
            }
        } else {
            while(++i < Math.min(this.length, f)) {
                r[this.keys[i]] = this.values[i];
            }
        }

        return from(r);
    };

    r.after = function(f) {
        var r = {}, i = -1;

        if(typeof f === 'function') {
            while(++i < this.length && !f(this.keys[i], this.values[i])) {
            }
            while(++i < this.length) {
                r[this.keys[i]] = this.values[i];
            }
        } else {
            if(f < this.length) {
                i = f - 1;
                while(++i < this.length) {
                    r[this.keys[i]] = this.values[i];
                }
            }
        }

        return from(r);
    };

    r.toArray = function() {
        return this.values;
    };

    return r;
}

You use it like so:
Sprint.selectIn("mySelector", element);

Or
Sprint.select("mySelector")

. The code is 6.89KB minified and 2.26KB gzipped.

Please note that all user contributions here are cc-wiki licensed, meaning that you grant everyone the right to use and remix the content. If you don't want your code to be "stolen", then don't post it here.

Besides, the minification is trivial to overcome. IE9 even includes a JS formatter in the developer tools. However, it cannot be »stolen« legally; CC-By-SA requires attribution when re-using content.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Polyomino generator
Write a program that prints the shapes of one-sided polyominoes.
Given input 4 (tetrominos), a sample output would be:
 *   *         *     *
 *   *    **   **   **  *
**   **   **    *   *  ***  ****

You are not restricted with respect to orientation, ordering or layout as long as polyominoes are not connected and not duplicated. (E.g. you can print the shapes in a column rather than a row)
Provide code that inputs a number from 3 to 6 and outputs the one-sided polyominoes of that size. The expected number of polyominoes output are 2, 7, 18, and 60 for 3, 4, 5, and 6 as inputs respectively.
Shortest code wins, present your solution for number 4.

I'm a little confused. The goal is a program that can print all triominos through all hexominos?

Actually you need to write program that takes number and outputs all polyominoes of that number.

@ralu Could you please clarify that in your post? The "Provide code that accepts number from 3 to 6 and displays proper polyomino" bit makes it seem like you only want triominos-hexominos.

You forgot the T tetromino.  I take it you mean "one-sided" polyominos?

It's polyominoes, not polynomials :D

@Lowjacker, oops. Mea culpa. Guess which of the two words I type more frequently...

Python, 398 392 chars
n=input()
r=range
T=lambda P:set(p-min(p.real for p in P)-min(p.imag for p in P)*1j for p in P)
A=[]
for i in r(1<<18):
 P=[k%3+k/3*1j for k in r(18)if i>>k&1]
 C=set(P[:1])
 for x in P:[any(p+1j**k in C for k in r(4))and C.add(p)for p in P]
 P=T(P)
 if not(C^P or P in A or len(P)-n):
  for y in r(4):print''.join(' *'[y+x*1j in P] for x in r(6))
  A+=[T([p*1j**k for p in P])for k in r(4)]

Polyominos are represented as sets of complex numbers representing the cells of the polyomino.  For example, T takes a polyomino and translates it so the minimum real and imaginary coordinates are 0.
The outer loop iterates through all 2^18 3x6 grids, generating a potential polyomino P, making sure P is connected (by computing C, the part of the polyomino connected to P[0]), checking that P isn't in the list A of previously found polyominos, and verifying that P has exactly n cells.  Any new polyomino is added to A in all 4 rotations.
It takes two minutes or so to run to completion.  Here's the result for n=4:
**
*
*

*
**
*

**
**

 *
**
*

*
*
**

*
**
 *

****

This is just Printing out **** when I try it. And n is a string so I get unsupported operand… error on line 10. Do you know how to fix it?

Ruby, 266 241 320 (227 without reflections)
Given the input restrictions, it's easier to just use a bitmap of all the polyominos.
puts [%w[13 3],%w[1vqxip 1s9b3b],%w[1j85qxc81ax0oxld 1db08aq5w1vdul13 172qaw25hgn8jn5t],%w[5l91ancci09g0iuurrdbkbrsl58jjiodia8irxlivoufjjse42o4l8hlcz 3qbvfj70ksz14cngk9exust0w1qjshykauo6yvyyn3j6oefyy1xc58hsoj 26c0102a8vw34q88pktwlkepxzcslicg6ydtrz4zhyyutd4bukh73187qb]][gets.hex-3].map{|n|n.to_i(36).to_s(2).tr'10','* '}

Old version (outputs just the free polyominoes):
puts [%w[13 3],%w[9iz3 a5z],%w[cfu9zai70z b3tsb0pge1 12t8eks810j],%w[5wgmz704fjqc593xfwrmkwb7k0j9ztr31v fr8weq5t88qdxp93hit2fh8899qcbr2a9f 10r578ajcw2n15dwywsm0ep601kiv41cco3]][gets.hex-3].map{|n|n.to_i(36).to_s(2).tr'10','* '}

Output for n=4:
** **  *    *  ****  **   *
**  ** *** ***      **  ***

@Ventero: Thanks. Wasn't sure whether it would give an advantage, since the bitmap is split in 10 parts.

Use %w notation to save about 10 characters (e.g. %w[13 3]). Also, since the input is a single digit, you can use gets.hex to save another char.

Where are missing reflections?

@ralu: I've added them, but if you want the reflections, you should say so in the question.

Golfscript, 221 chars
Also 221 bytes. Inspired by Lowjacker's approach, but moderately different in actual implementation (and produces one-sided rather than two-sided polyominos).
Because some of the characters used, while valid Unicode codepoints (and one byte each in UTF-8), are non-printable, I present the base-64 encoding of the script:
fidAQEAVRRVALVs9TUZFUwhgA0BrdjVXGm4VOl8aDgMZfBdoVQQzNk0YLQ9eXCciBhwQH0ADDW9E
KlomSXgoLBxxI1oEeB9XPm51GF43bHBKQzl3WQ5vXTJCTABfEz4bJBlaWX0XL2QVDF5ZXFw5BxpF
IzNUKmUtYwEEfQEKckMSbjAlQmhYHShQaAtjK1QFbnt5WQokFkNkHgNlL35cXCU6Hj8nIkAiLz0x
MjdiYXNlIDRiYXNlWzNdL3tbKVxbMl0vLi0xJUAqXXt7eyIgKiI9fSVuK30vbn0vfS8=

And the script itself with the magic strings substituted:
~"@@@Magic@strings@go@here""@"/=127base 4base[3]/{[)\[2]/.-1%@*]{{{" *"=}%n+}/n}/}/

Example execution:
$ golfscript.rb poly.gs <<<"4"
****

***
*

*
***

**
**

***
 *

**
 **

 **
**

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Textual maze solver
Given a maze on stdin and an entry point, write a program that prints a path to the exit on stdout. Any path is acceptable, as long as your program does not generate the trivial path (passing through every point in the maze) for every maze.
In the input, walls are marked by a # and the entry point by a @. You may use any characters to draw the maze and the path in the output, as long as they're all distinct.
You may assume that:

The entry and exit points are on the edges of the input
Every line of the input has the same length
The maze is solvable and has no cycles
There is only one exit point

Shortest solution by (Unicode) character count wins.
Examples
(note that the inputs are padded with spaces)
####
#  #
@ #####
#     #
#
#######

####
#  #
@*#####
#*    #
#******
#######

### ###################
###         #         #
##  #########      #  #
 #             #####  #
 ###############   #@##

###*###################
###*********#*********#
## *#########*     # *#
 # *********** #####**#
 ###############   #@##

Can I add a character for the endpoint, also? It would make it much easier for my program to know when to end.

@Peter Of The Corn: Sure. You don't have to use the same character to draw the entire path, it just has to be distinguishable from the rest of the output.

Ruby 1.9, 244 characters
l=*$<
i=l*""
e=[]
d=[1,-1,x=l[0].size,-x]
r=[f=9e9]*s=x*b=l.size;r[i=~/@/]=0
r.map{i.gsub(/ /){r[p=$`.size]=d.map{|u|p>-u&&r[u+p]||f}.min+1;e<<p if p%x%~-~-x*(p/-~x%~-b)<1}}
r[g=e.find{|i|r[i]<f}].times{i[g]=?*;g+=d.find{|l|r[g]>r[g+l]}}
puts i

Output for the two examples:
####
#  #
@*#####
#*    #
#******
#######

###*###################
###*        #     *** #
## *######### *****#* #
 # ************#####* #
 ###############   #@##

Edits:

(247 -> 245) Inlined e and renamed it to g
(245 -> 249) Fix a bug when the exit is directly above the entrance
(249 -> 246) Inlining + simplifications
(246 -> 244) Shorter way to iterate over every field

ANSI C (384 373 368 characters)
Here's my C attempt. Compiled and run on Mac OS X.
m[9999],*r=m,*s=m,c,R=0,*a,L;
P(){while(*s++)putchar(*(s-1));}
C(int*l){if((l-s+2)%R==0||(l-s)%R==0||l-s<R||l>r-R)*l=42,P(),exit(0);}
e(int*l){if(*l==32)C(l),*l=42,e(l-1),*l=32,*l=42,e(l-R),*l=32,*l=42,e(l+1),*l=32,*l=42,e(l+R),*l=32;}
main(){while(~(c=getchar()))*r++=c,R=!R&&c==10?r-s:R,L=c==64?r-s-1:L;L%R==0&&e(s+L+1);(L+2)%R==0&&e(s+L-1);L<R&&e(s+L+R);e(s+L-R);}

Sample output for a couple of tests:
####
#  #
@*#####
#*****#
#    *#
#####*#

###*###################
###*        #******** #
##**#########**    #* #
 #*************#####* #
 ###############   #@##

Limitations: Only works for mazes up to 1000 characters, but this can easily be increased. I just picked an arbitrary number rather than bother to malloc/remalloc.
Also, this is the most warning-laden code I've ever written. 19 warnings, though it looks like even more with the XCode code highlighting. :D
EDITS: Edited and tested to drop int from main, to use ~ instead of !=EOF and putchar instead of printf. Thanks for the comments!

You could use 9999 - it's the same number of characters

Good job! Omit the "int " before main and save 4 characters. Also use putchar(*(s-1)) instead of printf("%c",*(s-1)) to save 4 more.

You can also replace 0xA by 10 and != by ^.

Even better: you can use the ~ operator to check for EOF: while(~(c=getchar())

I can also drop the !L&& guard on setting L, the location in the maze of the '@'.

Python, 339 chars
import sys
M=list(sys.stdin.read())
L=len(M)
R=range(L)
N=M.index('\n')+1
D=2*L*[9e9]
D[M.index('@')+N]=0
J=(1,-1,N,-N)
for x in R:
 for i in[N+i for i in R if' '==M[i]]:D[i]=min(1+D[i+j]for j in J)
e=[i+N for i in R[:N]+R[::N]+R[N-2::N]+R[-N:]if 0<D[i+N]<9e9][0]
while D[e]:M[e-N]='*';e=[e+j for j in J if D[e+j]<D[e]][0]
print''.join(M)

Generates a shortest path through the maze.
Output for example mazes:
####
#  #
@*#####
#*    #
#******
#######

###*###################
###*        #     *** #
## *######### *****#* #
 # ************#####* #
 ###############   #@##

Why all the additions and subtractions by N?

It prevents the indexing D[i+j] in line 10 from going negative.  And D[e+j] in line 12.

Python - 510 421 chars
m=[]
i=raw_input
l=i()
x=y=-1
while l:
 if y<0:x+=1;y=l.find('@')
 m.append(list(l));l=i()
s=(x,y)
t={}
q=[s]
v={s:1}
while 1:
 try:(i,j),q=q[0],q[1:];c=m[i][j]
 except:continue
 if c==' 'and(i*j==0)|(i+1==len(m))|(j+1==len(m[0])):break
 for d,D in(-1,0),(0,-1),(1,0),(0,1):
  p=(i+d,j+D)
  if not p in v and'#'!=c:v[p]=0;q.append(p);t[p]=(i,j)
while(i,j)!=s:m[i][j]='*';i,j=t[(i,j)]
print'\n'.join(''.join(l)for l in m)

I'm getting a * on the bottom-right corner, on the first test case (python 2.6.1). Any thoughts?

@Lowjacker Thanks, it seems that while golfing I added a bug that made it look like it worked, but just for the test cases, and even then barely :P

Good, it works now. But you forgot to take out the print b,r and the print (i,j), which I presume were for debugging :)

Python 3, 270 bytes
import sys
def q(g,*s):w=len(g[0])+1;k='@'.join(g)+w*'@';*p,x=s or[k.find('#')];return'@'>k[x]and{x}-{*p}and[p,min((q(g,*s,x+a)or k for a in(-1,1,-w,w)),key=len)]['*'>k[x]]
g=''.join(sys.stdin.read());s=q(g.split('\n'))
for i,c in enumerate(g):print(end=[c,'+'][i in s])

Try it online!
Port of my answer to Find the shortest route on an ASCII road.
Uses '#' for start, '*' for end, '@' for wall and ' ' for empty space. In this, the function q is a helper function which returns a one-dimensional array with the shortest path in the maze. Function f can be shortened 4 bytes by not assigning the variable s. This is incredibly inefficient and will likely time out, since it calls the path-finding function for each character in the maze.

05AB1E (legacy), 23 22 bytes
[¾#4Føí„ *„@*δJ`:¬'*¢½

Try it online!
Modern 05AB1E, 26 bytes
[¾#4F€SøíJ„ *„@*â2ô`:¬'*¢½

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Find whether a number is happy or not?
A happy number is defined by the following process. Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers, while those that do not end in 1 are unhappy numbers (or sad numbers). Given a number print whether it is happy or unhappy.
Sample Inputs
7
4
13

Sample Outputs
Happy
Unhappy
Happy

Note: Your program should not take more than 10 secs for any number below 1,000,000,000.

Golfscript - 34 chars
~{0\`{48-.*+}/}9*1="UnhH"3/="appy"

Basically the same as this and these.
The reason for 9 iterations is described in these comments (this theoretically returns correct values up to about 10^10^10^974 (A001273)).

Ruby, 77 characters
a=gets.to_i;a=eval"#{a}".gsub /./,'+\&**2'until a<5
puts a<2?:Happy: :Unhappy

Ok, so I kinda get how this works (Literally taking each number, splitting it and adding the square of each digit), but what's with the stop condition of (a < 5) and using (a < 2) to decide if it's happy or not?  I don't question the validity, just the logic.

That is the same as a <= 4 and a <= 1. If the cycle has a 1 in it then it is happy, and if it has a 4 in it, then it is not happy. See the wikipedia section about the unhappy cycle. So once the value of a is 4 or less, he checks if a is -- the result of that is your answer.

C - 115
char b[1<<30];a;main(n){for(scanf("%d",&n);b[n]^=1;n=a)for
(a=0;a+=n%10*(n%10),n/=10;);puts(n-1?"Unhappy":"Happy");}

This uses a 230-byte (1GB) array as a bitmap to keep track of which numbers have been encountered in the cycle.  On Linux, this actually works, and efficiently so, provided memory overcommitting is enabled (which it usually is by default).  With overcommitting, pages of the array are allocated and zeroed on demand.
Note that compiling this program on Linux uses a gigabyte of RAM.

Why would you need anywhere close to that amount of memory for this problem?

@Peter: I suppose the approach is to (naively) catch a cycle for any number in the allowed input range from 1 to 1,000,000,000.  But I agree that in light of happy number theory, the only check necessary is if the number 4 is reached, because that's the only cycle that will ever occur.

I'm curious: why does compiling it require so much RAM?

Appears to work fine on Windows 7 with MSVC 10. Doesn't consume any notable amount of memory while compiling and only marks the array in the page file (something that sounds way safer than the story you linked about memory overcommitting suggests ;-)).

I love the naivety of this approach. And the abuse of for loops is beautiful.

Haskell - 77
f 1="Happy"
f 4="Unhappy"
f n=f$sum[read[c]^2|c<-show n]
main=interact$f.read

Golfscript, 49 43 41 40 39 chars
~{0\10base{.*+}/.4>}do(!"UnhH"3/="appy"

Every happy number converges to 1; every unhappy number converges to a cycle containing 4. Other than exploiting that fact, this is barely golfed at all.
(Thanks to Ventero, from whose Ruby solution I've nicked a trick and saved 6 chars).

Python - 81 chars
n=input()
while n>4:n=sum((ord(c)-48)**2for c in`n`)
print("H","Unh")[n>1]+"appy"

Some inspiration taken from Ventero and Peter Taylor.

better off doing a int(c) than ord(c)-48....

eTeX, 153
\let~\def~\E#1{\else{\fi\if1#1H\else Unh\fi appy}\end}~\r#1?{\ifnum#1<5
\E#1\fi~\s#1{0?}}~\s#1{+#1*#1\s}~~{\expandafter\r\the\numexpr}\message{~\noexpand

Called as etex filename.tex 34*23 + 32/2 ? (including the question mark at the end). Spaces in the expression don't matter.
EDIT: I got down to 123, but now the output is dvi (if compiled with etex) or pdf (if compiled with pdfetex). Since TeX is a typesetting language, I guess that's fair.
\def~{\expandafter\r\the\numexpr}\def\r#1?{\ifnum#1<5 \if1#1H\else
Unh\fi appy\end\fi~\s#1{0?}}\def\s#1{+#1*#1\s}~\noexpand

Javascript (94 92 87 86)
do{n=0;for(i in a){n+=a[i]*a[i]|0}a=n+''}while(n>4);alert(['H','Unh'][n>1?1:0]+'appy')

Input is provided by setting a to the number desired.
Credits to mellamokb.

Save 1 char: n==4?h="Unh":n==1?h="H":a=n+""}alert(h+"appy")

@mella Thanks. I also shaved another char off by changing || to |.

Save 8 chars: Remove n==4?h....  Change to do...while loop with condition while(n>4).  Then use this final statement instead: alert(["H","Unh"][n>1?1:0]+"appy")

@Mella Clever, I like it.

@Mella n needs to be defined before the while loop, I'm trying to think of how to not repeat n=0;

@Peter: Technically, it doesn't need to be defined: http://jsfiddle.net/8bqWF/

@Peter: You also have to change it from a while loop to a do...while loop in order for my code to work, so that the condition is checked at the end.

@Mella Ok, I see now. That saves me one more char. Maybe I can make it look shorter by replacing double wuotes with single quotes. :)

Python (98, but too messed up not to share)
f=lambda n:eval({1:'"H"',4:'"Unh"'}.get(n,'f(sum(int(x)**2for x in`n`))'))
print f(input())+"appy"

Way, way too long to be competitive, but perhaps good for a laugh.  It does "lazy" evaluation in Python.  Really quite similar to the Haskell entry now that I think about it, just without any of the charm.

dc - 47 chars
[Unh]?[[I~d*rd0<H+]dsHxd4<h]dshx72so1=oP[appy]p

Brief description:
I~: Get the quotient and remainder when dividing by 10.
d*: Square the remainder.
0<H: If the quotient is greater than 0, repeat recursively.
+: Sum the values when shrinking the recursive stack.
4<h: Repeat the sum-of-squares bit while the value is greater than 4.

Befunge, 109
Returns correct values for 1<=n<=109-1.
v v              <   @,,,,,"Happy"<      >"yppahnU",,,,,,,@
>&>:25*%:*\25*/:#^_$+++++++++:1-!#^_:4-!#^_10g11p

J (50)
'appy',~>('Unh';'H'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

I'm sure a more competent J-er than I can make this even shorter. I'm a relative newb.
New and improved:
('Unhappy';'Happy'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

Newer and even more improved, thanks to ɐɔıʇǝɥʇuʎs:
(Unhappy`Happy){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

You can get a character by not splitting out 'appy'. I think you can also remove the parentheses aroundd ("."0) - adverbs bind tighter than conjunctions.

I can't remove the parentheses around ("."0). That produces a rank error, but if I don't split 'Happy' and leave the result boxed, I can save a character.

The reason I can't leave out the parentheses around ("."0) is that conjunctions apply to the entire preceding train of verbs to which they're attached, which is not what I want. If I say +/@:("."0)@":, that is very different from +/@:"."0@:, which is actually (+/@:".)"0@:.

A massive necro, but you could save 4 chars by replacing 'Unhappy';'Happy' with Unhappy\Happy`.

@ɐɔıʇǝɥʇuʎs That works, but where is it documented that you can skip the quoting of strings with `?

Ah, I see. All this time I misunderstood gerunds. It appears to be strings all the way down. Fascinating.

http://www.jsoftware.com/help/dictionary/d610.htm

Thanks. I know the vocab well and visit it often. In fact, I went straight there when I saw that your suggestion worked. Unfortunately that vocab entry could be a little more explicit. It's natural to assume that the gerund conjunction joins the atom itself rather than converting it to a string first. That's what I always thought, but I'm "happy" to find out I'm wrong.

J, 56
'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)

A verb rather than a standalone script since the question is ambiguous.
Usage:
   happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
   happy"0 (7 4 13)
happy"0 (7 4 13)
Happy
Unhappy
Happy

Scala, 145 chars
def d(n:Int):Int=if(n<10)n*n else d(n%10)+d(n/10)
def h(n:Int):Unit=n match{
case 1=>println("happy")
case 4=>println("unhappy")
case x=>h(d(x))}

Wouldn't (n*n) be shorter as n*n , or does whitespace not suffice to separate an if-expression from the else?

Yes, I did so, Peter.

Here is a 126 bytes tail-recursive version, without pattern matching: def h(s: String):String=if(s=="1")"H"else if(s=="4")"Unh"else h(s.map(_.asDigit).map(a=>a*a).sum+"");print(h(readLine)+"appy")

@6infinity8: Why don't you post it as a new answer?

The initial post is old; I was just trying to improve your solution.

Python (91 characters)
a=lambda b:b-1and(b-4and a(sum(int(c)**2for c in`b`))or"Unh")or"H";print a(input())+"appy"

Common Lisp 138
(format t"~Aappy~%"(do((i(read)(loop for c across(prin1-to-string i)sum(let((y(digit-char-p c)))(* y y)))))((< i 5)(if(= i 1)"H""Unh"))))

More readable:
(format t "~Aappy~%"
        (do
          ((i (read)
              (loop for c across (prin1-to-string i)
                    sum (let
                          ((y (digit-char-p c)))
                          (* y y)))))
          ((< i 5) (if (= i 1) "H" "Unh"))))

Would be shorter to just return "Happy" or "Unhappy" right from the (do), but arguably that wouldn't count as a whole program

K, 43
{{$[4=d:+/a*a:"I"$'$x;unhappy;d]}/x;`happy}

Jelly, 17 bytes
D²SµÐLỊị“¢*X“<@Ḥ»

Try it online!
How?
D²SµÐLỊị“¢*X“<@Ḥ» - Main link: n
   µÐL            - loop while the accumulated unique set of results change:
D                 -   cast to a decimal list
 ²                -   square (vectorises)
  S               -   sum
                  - (yields the ultimate result, e.g. n=89 yields 58 since it enters the
                  -  "unhappy circle" at 145, loops around to 58 which would yield 145.)
      Ị           - insignificant? (abs(v)<=1 - in this case, 1 for 1, 0 otherwise)
        “¢*X“<@Ḥ» - dictionary lookup of ["Happy", "Unhappy"] (the central “ makes a list)
       ị          - index into
                  - implicit print

Perl 5 - 77 Bytes
{$n=$_*$_ for split//,$u{$n}=$n;exit warn$/.'un'[$n==1].'happy'if$u{$n};redo}

$n is the input value

Perl 5, 62 + 1 (-p) = 63 bytes
$_=eval s/./+$&**2/gr while$_>1&&!$k{$_}++;$_=un x($_>1).happy

Try it online!

05AB1E, 21 bytes
'ŽØs[SnOD5‹#}≠i„unì}™

Try it online or verify the first 100 test cases.
Explanation:
Each number will eventually result in either 1 or 4, so we loop indefinitely, and stop as soon as the number is below 5.
'ŽØ                    '# Push string "happy"
   s                    # Swap to take the (implicit) input
    [       }           # Loop indefinitely
     S                  #  Convert the integer to a list of digits
      n                 #  Square each
       O                #  Take the sum
        D5‹#            #  If this sum is smaller than 5: stop the infinite loop
             ≠i    }    # If the result after the loop is NOT 1:
               „unì     #  Prepend string "un" to string "happy"
                    ™   # Convert the string to titlecase (and output implicitly)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why 'ŽØ is "happy".

Python 2, 71 bytes
f=lambda n:n>4and f(sum(int(d)**2for d in`n`))or("H","Unh")[n>1]+"appy"

Try it online!
...or, for the same byte count:
f=lambda n:n>4and f(eval('**2+'.join(`n*10`)))or("H","Unh")[n>1]+"appy"

Try it online!

C++ 135 , 2 Lines
#include<iostream>
int n,i,j;int main(){for(std::cin>>n;n>1;n=++j&999?n*n+i:0)for(i=0;n/10;n/=10)i+=n%10*(n%10);std::cout<<(n?"H":"Unh")<<"appy";}

This is a modified version of the one I did here:
https://stackoverflow.com/questions/3543811/code-golf-happy-primes/3545056#3545056

What is the &999 do? And how does it work if j is a garbage value?

@Dgrin91, I wrote this 3 years ago, so i can't remember exactly how it works.  I think the &999 makes the statement if(j==999){n = 0;}else{n=n*n +i;}, j shouldn't be a garbage value, globals are zero initialized.

Yes, this challenge has three years; yes, it already has a winner answer; but since I was bored and done this for another challenge, thought I might put it up here. Surprise surprise, its long - and in...
Java - 280 264 bytes
import java.util.*;class H{public static void main(String[]a){int n=Integer.parseInt(new Scanner(System.in).nextLine()),t;while((t=h(n))/10!=0)n=t;System.out.print(t==1?"":"");}static int h(int n){if(n/10==0)return n*n;else return(int)Math.pow(n%10,2)+h(n/10);}}

Ungolfed:
import java.util.*;

class H {

    public static void main(String[] a) {
        int n = Integer.parseInt(new Scanner(System.in).nextLine()), t;
        while ((t = h(n)) / 10 != 0) {
            n = t;
        }
        System.out.print(t == 1 ? "" : "");
    }

    static int h(int n) {
        if (n / 10 == 0) {
            return n * n;
        } else {
            return (int) Math.pow(n % 10, 2) + h(n / 10);
        }
    }
}

C# 94 bytes
int d(int n)=>n<10?n*n:(d(n%10)+d(n/10));string h(int n)=>n==1?"happy":n==4?"unhappy":h(d(n));

For any given number (as int), h() will return the correct value. You can try the code on .NetFiddle.
Kudos to user unknown for the original algorithm.

Clojure, 107 97 bytes
Update: Removed unnecessary let binding.
#(loop[v %](case v 1"Happy"4"Unhappy"(recur(apply +(for[i(for[c(str v)](-(int c)48))](* i i))))))

Original:
#(loop[v %](let[r(apply +(for[i(for[c(str v)](-(int c)48))](* i i)))](case r 1"Happy"4"Unhappy"(recur r))))

First time using a nested for :o

R, 117 91 bytes
-16 bytes thanks to Giuseppe
a=scan();while(!a%in%c(1,4))a=sum((a%/%10^(0:nchar(a))%%10)^2);`if`(a-1,'unhappy','happy')

Use strtoi instead of as.numeric and paste instead of as.character, but there is a shorter approach to get the digits. If you use \if`(a-1,"unhappy","happy")` instead that should save another byte. Finally, you can make this anonymous to shave off a few more bytes.

Julia 1.5 , 188 bytes (without indent)
f(s)=sum([parse(Int64,i)^2 for i in string(s)])
function g(s)
         a=[f(s)]
         while true;h=f(last(a))
             if h in a
                 println("unhappy")
                 break
             elseif h==1
                 println("Happy")
                 break
             end
             append!(a,h)
         end
      end

Try it online!