text:
Sabotage the coding standards
There are various coding standards enforced at software companies which have the goal of increasing code reliability, portability, and, most importantly, readability in code written jointly by different developers.
Two notable examples are the MISRA C, and the C++ standard developed for the JSF project.
These are usually in the following form, after carefully specifying what the words "must", "shall", "should", "might", etc. mean:
Example:

Rule 50: Floating point variables shall not be tested for exact
equality or inequality.
Rationale: Since floating point numbers are subject to rounding and truncation errors, exact equality may not be achieved, even when
expected.

These coding standards pose restrictions, usually on code which would be legal from the compiler's point of view, but it is dangerous or unreadable, and is therefore "considered harmful".
Now let's abuse this!
You are accepted as a member of a small standardizing committee at your company, which is intended to design the new coding standards every developer at the company will be required to use. Unbeknown to the others, you are secretly in the employ of a sinister organization and have as your mission to sabotage the company.
You have to propose one or more entries to the coding standard which will later hinder the developers. However, you must be careful to not make this immediately obvious, otherwise you risk it not being accepted into the standard.
In other words, you must introduce rules to the coding standard which look legitimate and have a good chance of being accepted by the other members of committee. After the projects are started and countless man-hours are invested in the code, you should be able to abuse these rules (for example, by a technicality, or by a very literal interpretation) to flag otherwise normal and good quality code as being against the standard. So they must put a lot of effort in to redesign it, and the rules will hinder them from this point on, but as the rules are active for quite some time now, pure momentum will keep these roles alive, and as there are significant conflicts of interests between different levels of management, the other managers will probably keep the rules alive (they would be foolish to admit their mistake!), therefore hindering the company! Mwahahahahaaa!
Scoring
The highest voted answer after approximately 2 weeks from the first valid entry wins. I have an idea for a good answer, but I will only post it a few days later, as someone else might come to the same idea, and I don't want to rob them from the pleasure. Of course, my own answer will not be accepted above any other, no matter the score.
Voters are encouraged to score answers based on how well the loopholes are hidden, and how frustrating to the developers they would be.
Rules and regulations

The rule or rules must look professionally written, like in the above example
The rules should look genuine (so things like "all variables must contain at least one underscore, one upper case letter, one lower case letter and two numbers" are not accepted. They would indeed hinder developers, but would most likely not be accepted by the committee) and if their merit is not immediately obvious, you should give a good rationale.
You should be able to find a way to use/abuse your rules to sabotage the developers later on. You might abuse any ambiguity in other rules, or you might use multiple rules which are harmless on their own, but diabolical once combined!
You should post an explanation in spoiler tags at the end of your post about how you could abuse the rules
The language used must not be an esoteric language. A language widely used in real projects must be chosen, so languages with C-like syntax (instead of things like Golfscript) are preferred.

Just to let you know, there are some rather "unconventional" languages which are used in real projects, like APL.

@MartinBüttner : I only wanted to exclude esoteric and joke languages. A language with universally understood syntax is preferred, but not exclusively required. However, I guess most people wouldn't vote on answers which need to explain the basic syntax of the language itself.

Why not just standardise tabs in Java? :-)

Python, Ruby, Haskell, Makefile, XML, etc. are some languages used in lots of real projects which don't have a C-like syntax.

@JanDvorak Because that can be fixed with a few lines of program - just replace tabs/spaces with the new version.

@KennyTM : please read my previous comment. I didn't say the languages on your list are forbidden.

This question appears to be off-topic because it isn't a programming contest.

@PeterTaylor : the definition includes "Programming puzzles" which doesn't mean the answer must be a piece of software code. Nowhere in the definition of the site is it written that it's only about "programming contests". The definition is : "Code golf / Programming puzzles / Other programming contests or challenges"
"

@PeterTaylor it looks like a contest about programming to me; in cops & robbers challenges the robbers don't code either (and if your argument is that robbers comment, then be sure to comment on the meta post that suggests splitting cops and robbers challenges to two separate questions)

@JanDvorak, it looks like a contest about using the English language to me. (As for cops and robbers, I've been ignoring them since the first one, because the conclusion I drew from my participation in that one is that it's not a good format).

@PeterTaylor It's using the English language to create programming standards. I'm new to PPCG, but i've looked at contests before from the Hot Network Questions list, and i seem to remember other contests regarding English.

Reading both of these pages http://codegolf.stackexchange.com/help/on-topic , http://codegolf.stackexchange.com/help/dont-ask  I still don't find any rule regarding questions on this site must have software code as answers. If so, it would be called "programming contest", bit this term only shows up as "other", and "programming puzzles" precedes it. But I don't necessarily want to play a rules lawyer, so I expect from others to not do it either. So, sincerely, what is it what you don't like in this question, and how do you think it could be improved?

@Scimonster, the people who aren't new to PPCG will know that I think that being on the HNQ is negatively correlated with being a good question, and I believe that some of them share that opinion. But I can't recall seeing any other questions like this one. If you can remember enough keywords to find them, I would be interested to see.

@PeterTaylor  On the other hand, if requiring the answers to include some software code is what makes questions on-topic, than I can answer that as well. A good answer is expected to have the rule or rules described, and after that, a code example which shows a reasonable code which is clear, useful, and in common style, probably the best way to solve a problem, but which would fail to adhere to the company standard because of the loopholes you built into it.

@vsz, I'm not quite sure what you're quoting - none of the instances of other in the pages you link seems to fit the context. The lack of specific wording in the on-topic page doesn't constitute carte blanche: it probably just means that the topic hasn't come up before - this meta question might be the closest we've seen. I'm not sure that the question can be fixed, but if you want to try then I suggest that the place to do it is the sandbox.

@Scimonster: Do you mean Sort a list and write some English!? That question is about disguising code as a business letter.

@PeterTaylor then why isn't it called "coding contest", or just purely "programming contest". Why puzzles? But we can discuss it, I'm listening to your arguments. Just here and now it seems that you are the one who is just rules-lawyering. Should we ask in meta what constitutes a "programming puzzle"? I think this site would be boring if we only allowed questions like "solve this basic problem in an obscure language with as few characters as possible". Why not include puzzles which are indeed about programming. I doubt this question would be more on-topic on english.stackexchange.com

In fact, it would definitely not be on topic on [english.se]. This seems to be a programming puzzle, that only fits on this SE site.

If you had let me post my example (which I postponed only to let others figure it out) you would have seen how this question can be answered in an on-topic way, by actually programming / writing code.

I voted to reopen. It seems like we still have some questions where we can't agree on whether they are on topic. This reminds me of that art related one that got closed then reopened twice. I do have an idea for an answer for this question and it is definitely programming related. This question even fits 2 of the tags on the site.

I'm not saying that requiring the answers to include some software code makes questions on-topic: that isn't sufficient, as is being discussed on meta in the context of "art questions". The reason for this site's name is that it was originally created to move code golf questions off StackOverflow, and in area51 and very early meta discussions the scope was widened to include more than just code golf. But that doesn't mean that the scope is widened to include anything which has a connection to programming.

I agree that this question wouldn't be on topic on english.stackexchange.com, but that doesn't mean that it must therefore be on topic here. There are many questions which aren't on topic on any site in the StackExchange network.

The first answer only serves to reinforce my feeling that this is only superficially related to programming.

"by a technicality, or by a very literal interpretation" seems reminiscent of code-trolling and the standard loopholes.

I remember, that in the early days, almost all popularity contests and underhanded challenges (basically everything not a code-golf) were voted to be closed.

I was on the fence about this question, but the clever answer posted by the OP sold me on it as a programming puzzle.

Voting for reopen. It's certainly an on the edge of off topic but I do believe it is related enough and could be fun. At the very least it could serve as an example for either side of the argument on meta.

This is so much fun thank you for re-opening!  Do my managers secretly play this game?  I think so!

@ErlVolton I'm wondering if vsz is playing this game with the rules and regulations in the question, considering the use of "must" and "should". :P (I kid, they're clear to me)

I'm voting to close this question as off-topic because underhanded challenges are no longer on topic: http://meta.codegolf.stackexchange.com/a/8326/45941

C / C++

Rule 1: octal constants shall not be used
Rationale: octal constants can be a cause of confusion. For example, a
  casual glance over the line
  const int coefficients[] = {132, 521, 013, 102};
  might miss the fact, that one of the numbers in the array
  is defined in octal.

If you want to be even more evil, add the following:

Rule 2: hexadecimal constants shall only be used in the context of bit manipulation.
Rationale: If a constant represents a numerical value, it's more
  readable if it's in decimal. A hexadecimal constant should indicate
  that it represents a bit mask, not a numerical value.

How it can be abused:
Take the following simple program which will add the first 10 elements of an array. This code would not be standard-conforming.
sum = 0;
for (i = 0; i < 10; i++)
{
    sum += array[i];
}

 Note, that 0 is, per definition, an octal constant. Per rule 1, requiring it to be written as 0x00 all through the code is frustrating. Per rule 2, even more frustrating.

Could you link to the coding standard definition that says that 0 is an octal constant? I presume that it's because it starts with character 0. It would strengthen your hypothetical pedant's argument.

http://stackoverflow.com/questions/6895522/is-0-a-decimal-literal-or-an-octal-literal
http://stackoverflow.com/questions/26625311/is-0-an-octal-or-a-decimal-in-c

This is for a Node.JS project.

Section 3 - Speed and efficiency are of essence
Rule 3.1: Files should be kept to a maximum of 1kb. Files bigger than
  this take too long to parse.
Rule 3.2: Don't nest functions more than 3 levels deep. The V8 engine
  must keep track of many variables, and deep closures like this make it
  work harder, slowing down general interpretation.
Rule 3.3: Avoid require() runarounds.
Rule 3.3.1: Any modules require()d should not require() to a depth
  of more than 3. Deep require() chains are expensive both in terms of
  memory usage and speed.
Rule 3.3.2: Core modules count as a single require(), no matter how
  many times they require() internally.
Rule 3.3.3: External modules count as a maximum of 2 require()s. We
  cannot afford the same leniency as with core modules, but can assume
  that module authors are writing efficient code.
Rule 3.4: Avoid synchronous calls at all cost. These often take a long
  time, and block the entire event loop from continuing.

How it can be abused:

 Rules 3.1 and 3.3 do not work well together. By keeping a maximum of 1kb and 3 require()s down the chain, they will be hard-pressed to succeed.
 Rules 3.2 and 3.4 are almost incompatible. 3.4 bans synchronous calls; 3.2 makes advanced asynchronous work difficult by limiting the number of callbacks.
 Rule 3.4 is, in all honesty, a rule that is good to follow for real. 3.1, 3.2, and 3.3 are complete bogus.

Python
Rule 1: All code must be byte-compiled using the -OO flag, which optimizes the bytecode.  We want optimized bytecode for size and efficiency!
Rule 2: Tests must be run against the same "artifact" of code that will be put into production.  Our auditors require this.

 Using -OO removes assert statements.  Combined with rule 2, this effectively bans the use of assert statements in tests.  Have fun!

This also removes docstrings, meaning you don't get anything out of help() at the REPL, and informal REPL-testing is still testing.

Nope. If you write a proper test framework, it will use the unittest or module, which implements its own assertions not depending on the __debug__ flag. Doctests will silently not run however. Sneaky!

JavaScript (ECMAScript)

7.3.2: Regular expression literals
Regular expression literals must not be used.  Specifically, the source code
  must not contain any substring matching the RegularExpression nonterminal
  defined below.
RegularExpression     :: '/' RegularExpressionBody '/'
RegularExpressionBody :: [empty]
                         RegularExpressionBody [any-but-'/']

[empty] matches the empty string and [any-but-'/'] matches any single-character string except the one containing '/' (slash, U+002F).
Rationale
Regular expressions are often discouraged for readability reasons.  It is
  often easier to understand code with traditional string operations rather than
  by resorting to regular expressions.  More importantly however, many regular
  expression engines offer subpar performance.  Regular expressions have also
  been associated with security issues in the context of JavaScript.
However, the Organization™ recognizes that regular expressions occasionally
  is the best tool for the job.  Therefore, the RegExp object itself is not
  forbidden.

(The syntax of the grammar excerpt itself [not the one it defines] corresponds to that of the ECMAScript
specification.  This would of course be defined more rigourously at
another point of the hypothetical specification.)
The trick
The following program is non-conforming:
// sgn(x) is -1 if x < 0, +1 if x > 0, and 0 if x = 0.
function sgn(x) {
  return x > 0?  +1
       : x < 0?  -1
       :          0
}

 The productions for the RegularExpressionBody nonterminal given above
 shows a common way of expressing lists in BNF by relying on explicit
 recursion.  The trick here is that I "accidentally" allow the empty string
 as a RegularExpressionBody, such that the string // is forbidden in the
 source code.

 But who needs single-line comments anyway?  C89 and CSS seem
 to do all right while allowing only /* */ block comments.

It's actually even more evil than that: the code may not contain block-comments either, nor more than one division operator per file.

Oh yeah, you're right. I didn't even think of that. :P

C#

12.1 Static methods that affect the state of the program are forbidden
This is because it is hard to reliably test the results of a static method, especially one that changes some state.
12.2 Static methods must be deterministic
If the static method takes an input and gives an output the result must be the same each time the static method is called with the same input.

Why

 The entry point for a C# program is the private static method 'main'. By the first rule this is now forbidden because the rule forgets to state that only public, protected or internal methods should follow this rule. If testing really is the concern only public methods should follow rule 1. Main may also break rule 2 as the program will give an error code if the program fails, this may occur independent of the input parameters. For example the program might not find a file or may have dependencies on other systems that are not setup correctly.

JAVA/SPRING

4.2 Use of Reflection in Production Code
Because Reflection can be used to access otherwise restricted parts of our source code
use of reflection in Production Code is strictly prohibited.

The Trick

Spring technically uses reflection to instantiate and manage the objects that it supports. By enforcing this rule, all Spring utility would have to be removed.

Website encoding

666.13 UTF-8 must not be used and shall be replaced by UTF-7
  Rationale: UTF-7 is more efficient than UTF-8, especially when targeting users from Arabic countries which we do.

How it can be abused:

 HTML5 specifically disallows UTF-7. That means, modern browsers won't support it. If all the testing is done on a browser such as IE 11, nobody will notice this until it is too late.

JavaScript Bitwise Operators

1.9 You shall not use multiplication or division or flooring unless they are considerably faster than their bitwise counterparts. They shall be replaced by the bitwise operators <<, >> and ~~ respectively.
  Rationale: The bitwise operators are more efficient.

How it can be abused:

 Using << or >> instead of multiplication or division will cause troubles when handling large numbers. Also, they ignore operation precedence and decimal points. The double tilde will return different values when you give it a negative number.

I think it's already obvious that x = (x<<10) + (x<<8) + (x<<5) + (x<<4) + (x<<3) + (x) is inferior in every way (possibly even speed) to x *= 1337, and that replacing division by a non-power of two with sums of bitshifts is even worse.

@Thomas Kwa I edited my answer appropriately. Thank you for pointing this out. I am new to bitwise operators.

JavaScript (ECMAScript)

7.3.1: Identifier conventions
Restrictions are placed on identifiers depending on what type of identifier
  it is.  Identifiers are split into the types Variable, Constant,
  Function and Constructor; see 5.3.  The restrictions are given below.

Variable:     The first character must be a lowercase letter character.
                   Camel-case (see 1.3) should be used to separate words
                   within an identifier.
Constant:     The identifier must consist of only uppercase letter
                   characters and underscores ('_', U+005F).  Underscores
                   should be used to separate words within an identifier.
Function:     Functions must follow the same rules as the Identifier
                   type.
Constructor:  The first character must be an uppercase letter character.
                   Camel-case (see 1.3) should be used to separate words
                   within an identifier.

Rationale
Readable identifier names is very important for maintainability.  Restricting
  the identifiers to well-known conventions also eases transition between
  different code bases.  These particular conventions are modelled after the
  standard conventions for the Java™ programming language [1].

The trick

 I regret to inform the jQuery team that the most common name for their
 "global jQuery object" clashes with this name convention.  Luckily, they've
 already thought of that and provide both $ and jQuery as global names
 referring to the same object.  I imagine that the userbase might not be as
 keen to switch from $ to jQuery everywhere, though.

»Functions must follow the same rules as the Identifier type.« – do you mean »as the Variable type«?


text:
Break Stack Exchange
Trick the user that StackExchange is broken:

It can be done in several ways:

Your program starts a browser in some certain way (with a proxy server, for example);
Your program shows static picture;
Your program is executed in address bar using javascript:.
(your other creative way)

StackExchange error page should be displayed to user one way or another. It may appear immediately or after user tries to do something (i.e. to post a comment). The program should look like some useful StackExchange enhancer (e.g. a userscript that highlights happy posts, i.e. posts containing the word happy).
Try to aim for the shortest program (original tag was code-golf) and/or obfuscated code. You may depend on some concrete browser (Firefox, Chromium, Opera).
Encouraged:

Preserving address line "normal";
Finding actual faults in StackExchange software;
Making it "hard to fix" (on this computer), e.g. making it cached;
Making it show different error depending on on which site do I start the program (if it is a in-browser snippet);

Discouraged:

Simply redirecting to http://.../error. You can still try to sneak it underhanded-style.
Trying to permanently mess with user's StackExchange account.

(inspired by this)

This seems to be too vague for me. "As closely as possible" is not really an objective criterium.

Is this a duplicate? http://codegolf.stackexchange.com/questions/12340/make-stackoverflow-explode-bookmarklet

@Quincunx No, that is very different - it allows much more than displaying errors.

@IngoBürk Yeah, I would suggest removing that line and just saying "Must display an image of the error page"

@isaacg But then it comes down to golfing a picture. We've had that before. Quite recently, even, I think.

I'm voting to close this question as off-topic because underhanded challenges are no longer on-topic on this site. http://meta.codegolf.stackexchange.com/a/8326/20469

@cat, Is PPCG definition shifting (or shifted) compared to two year ago? I though the sole reason of PPCG is to offload funny code trickery with away from StackOverflow. Underhanded contests or code trolling definitely feel like a funny trickery...

@Vi. Yes. undefined and undefined are now discouraged, as they don't provide an objective primary winning criterion. Did you read the meta post I linked?

source: Stack Exchange

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

authors: 大唐皇朝娱乐代理--平台总代

authors: 天火3娱乐代理--平台总代

authors: 摩天2娱乐代理--平台总代

sort: votes


text:
Print the ASCII table
The task is to display n characters of the ASCII table.
You may write a function (or a program that takes the argument as a parameter, STDIN is allowed as well) that takes a parameter n, which will be the index of the last character to print.
The task is quite simple, so as an example here's a possible implementation in Python 2.7:
(lambda n:map(chr, range(n)))(256)

As I said it's a simple task. So this is code-golf and the shortest codes wins!
EDIT
As some of you pointed out this code doesn't print the result. It's just an example since I might struggle explaining the problem in english ;-).
EDIT2
Feel free to post the answer in any programming language, even if it's not the shortest code. Maybe there are some interesting implementations out there!
EDIT3
Fixed the example so it prints the result.

Does it have to be a function? 2. According to your reference code, n would be the first character that is not printed.

Actually the reference code prints nothing. It just returns a list of the characters and lets the REPL do whatever it wants with the result.

@Dennis I updated my question, you are allowed to use the parameter as an program argument. And you are correct, n is the first char that is not printed.

@manatwork You are correct. But when it's executed in the console you see the resulting array. So basically it's just an example since I might struggle explaining something in english ;-)

So, it has to be a command-line argument? STDIN is not allowed?

@Dennis Updated the question again, STDIN is allowed as well

Can somebody please explain the downvote? I am sorry if my english isn't that good. If there's something unclear within the question please tell me.

for x in range(input()):print chr(x) Would actually print the characters, if you want to edit your example.

nota [i for i in range(n)] is quite similar to range(n)

In BF the code is very simple:  ,[->.+<], with a tiny problem: it can't parse real numbers!!!1!11!!oneone!!1!!!11

@ciu Did you see my answer or did you just think of that yourself? In case it's the latter, I actually solved this in brainfuck :D

You didn't say we had to output them in ascending order, so is outputting the characters backwards allowed? How far can I bend the rules?

True ASCII is 7 bit, not 8 bit

What is the desired range? 0—n-1, 0—n, 1—n?

CJam, 4 bytes
ric,

Full program that reads from STDIN (input field in the online interpreter).
This simply executes range(chr(int(input()))), taking advantage of the fact that , gives a return an array of characters if its argument is a character.
I call dibs on c, (2 bytes), just in case that assuming the input is already on the stack turns out to be allowed.

Do you have to specify some input? The online runner just outputs the code itself.

@manatwork: Just a sec. You have to hurry when you post these... ;)

I am a little confused by this.  The character at 0 ( aka 0c )prevents anything else from being printed after it.  ric,( seems to work fine.  This means the code doesn't work.

@kaine: I've tested this with Chrome, Firefox and the Java interpreter. It works just fine for me.

Interesting I am using the linked interpreter but internet explorer (I know pity me but that is all i can use here).  There is no output for any integer input.  If it works on yours though, i'd still count it as working. "In C library and Unix conventions, the null character is used to terminate text strings; such null-terminated strings can be known in abbreviation as ASCIZ or ASCIIZ, where here Z stands for "zero"."  This quote is probably why.

@kaine: Internet Explorer is written in C++, which does not use null-terminated strings. According to this, null characters are parse errors in HTML 5; the browser must replace it with a � or abort processing the document.

Keep in mind that you have to enter a sufficiently large n, because the first few dozen of ASCII characters are non-printable characters. Fun fact: this program also outputs the Unicode table, for example n=9999

brainfuck - 169 146 142 bytes
-[+>+[+<]>+]>+>>,[>,]<[<]<[->>[->]<[<]<]>>>[[<[-<+<+<+>>>]+++++++++[<[-<+>]<<[-<+>>>+<<]<[->+<]>>>>-]]<,<<,>[->>>+<<<]>>>---------->]<-[->.+<]

Limitations:

EOF must be 0
Requires 8-bit wrapping cells
Because of ^, mods input by 256

Not the shortest answer here, but hey, brainfuck! This would be a really, really good brainfuck challenge, except for the fact that it requires human readable input without guaranteeing the number of digits. I could have required input to have leading zeroes to make it 3 characters long, but what fun is that? :D One major problem with taking input this way is that brainfuck's only branching or looping structure checks if the current cell is zero or not. When the input can contain zeroes, it can cause your code to take branches it shouldn't be taking. To solve this problem, I store each digit of input plus 1, then subtract the excess at the last possible second. That way, I always know where my zeroes are.
I did say that this would have been a great brainfuck challenge without having to parse input. Why is that? Well, let's pretend that we don't take a numeric input. We'll say the challenge is "Given a byte of input, output all ASCII characters below that byte". Here's what my answer would be:

brainfuck - 8 bytes
,[->.+<]

It's quite a difference! The real program uses 135 instructions to collect the input (over 95% of the program!), just because it's a human typing it. Store the number as a byte and give that to me, and it only takes one.
(Fun fact: If you understood the hypothetical program, then congratulations! You understand brainfuck in its entirety. The whole language has only eight commands, and that program happens to use each one exactly once.)
Explanation
-[+>+[+<]>+]>+               abuse 8 bit wrapping to put 47 in cell 4

>>,[>,]                      starting in cell 6; get each character of input

<[<]<[->>[->]<[<]<]          subtract the value of cell 4 from each input character
                             '0' has an ascii value of 47 so subtracting 47 from each
                             digit gives you that digit's value plus 1

>>>[                         if the number is in more than one cell
                             (when the program first starts this means "if the input has
                             more than one digit")

[<[-<+<+<+>>>]               copy first input cell to 3 new cells

+++++++++[<[-<+>]<<          do some fancy addition magic to multiply that value by 10
[-<+>>>+<<]<[->+<]>>>>-]]

<,<<,>                       clean up a bit (abusing comma to set cells to 0)

[->>>+<<<]>>>                add the value to the next cell of input

----------                   because we multiplied (the digit plus 1) by 10; the answer
                             is 10 too high; so subtract 10

>]                           if the input is still in multiple cells; do the song and
                             dance again (multiply by 10; add to next cell; subtract 10)

<-                           we never got a chance to fix the final digit; so it's still 1
                             too high

               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
               ;;         we have now finished processing input         ;;
               ;;     the tape is empty except for the current cell     ;;
               ;;  the current cell contains the number that was input  ;;
               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

[                            while the cell containing input != 0

-                            subtract 1 from it

>.+                          go a cell to the right; output that cell; then add 1

<]                           repeat

Nice! Definitely +1 for the effort :-)

You could save some bytes on the outputting part: >[-]<[->.+<] Set cell next to current cell to 0, then count down the current cell while increasing the cell next to it and simultaneously printing the value.

@shu That's an excellent point! I didn't think of that at all. In addition to being shorter, it fixes the problem I had with choking on large inputs and it's probably faster! Thanks :)

Yeah, it's much, much faster now. I also didn't need the >[-]< part because I was already next to an empty cell. :)

.+[.+] shorter this prints always 256 chars

Because it's not specified which order the characters had to be in, you could golf the printing part from [->.+<] down to [.-], saving 3 bytes.

Also, your second answer is valid.

Pyth, 4 bytes
VQCN

Basically a translation of the Python 3 program:
for N in range(eval(input())):print(chr(N))

Befunge 93 - 23 21
&> :#v_,>:#,_@
 ^-1:<

Befunge 93 - 15 13 (by Ingo Bürk)
This one prints the list in reverse, but OP only said we need to print the first n characters, not that it has to be in order.
&>::>v
@^-1,_

Might not be golfable any further without moving on to Befunge98 (for the ";" operator, see @Kasran's answer)
Try it here:

function BefungeBoard(source, constraints) {
    constraints = constraints || {
        width: 80,
        height: 25
    };

    this.constraints = constraints;
    this.grid = source.split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/).map(function (line) {
        return (line + String.repeat(' ', constraints.width - line.length)).split('');
    });
    for (var i = this.grid.length; i < constraints.height; i++) {
        this.grid[i] = String.repeat(' ', constraints.width).split('');
    }

    this.pointer = {
        x: 0,
        y: 0
    };

    this.direction = Direction.RIGHT;
}

BefungeBoard.prototype.nextPosition = function () {
    var vector = this.direction.toVector(),
        nextPosition = {
            x: this.pointer.x + vector[0],
            y: this.pointer.y + vector[1]
        };

    nextPosition.x = nextPosition.x < 0 ? this.constraints.width - 1 : nextPosition.x;
    nextPosition.y = nextPosition.y < 0 ? this.constraints.height - 1 : nextPosition.y;

    nextPosition.x = nextPosition.x >= this.constraints.width ? 0 : nextPosition.x;
    nextPosition.y = nextPosition.y >= this.constraints.height ? 0 : nextPosition.y;

    return nextPosition;
};

BefungeBoard.prototype.advance = function () {
    this.pointer = this.nextPosition();
    if (this.onAdvance) {
        this.onAdvance.call(null, this.pointer);
    }
};

BefungeBoard.prototype.currentToken = function () {
    return this.grid[this.pointer.y][this.pointer.x];
};

BefungeBoard.prototype.nextToken = function () {
    var nextPosition = this.nextPosition();
    return this.grid[nextPosition.y][nextPosition.x];
};

var Direction = (function () {
    var vectors = [
        [1, 0],
        [-1, 0],
        [0, -1],
        [0, 1]
    ];

    function Direction(value) {
        this.value = value;
    }

    Direction.prototype.toVector = function () {
        return vectors[this.value];
    };

    return {
        UP: new Direction(2),
        DOWN: new Direction(3),
        RIGHT: new Direction(0),
        LEFT: new Direction(1)
    };
})();

function BefungeStack() {
    this.stack = [];
}

BefungeStack.prototype.pushAscii = function (item) {
    this.pushNumber(item.charCodeAt());
};

BefungeStack.prototype.pushNumber = function (item) {
    if (isNaN(+item)) {
        throw new Error(typeof item + " | " + item + " is not a number");
    }

    this.stack.push(+item);
};

BefungeStack.prototype.popAscii = function () {
    return String.fromCharCode(this.popNumber());
};

BefungeStack.prototype.popNumber = function () {
    return this.stack.length === 0 ? 0 : this.stack.pop();
};

function Befunge(source, constraints) {
    this.board = new BefungeBoard(source, constraints);
    this.stack = new BefungeStack();
    this.stringMode = false;
    this.terminated = false;

    this.digits = "0123456789".split('');
}

Befunge.prototype.run = function () {
    for (var i = 1; i <= (this.stepsPerTick || 10); i++) {
        this.step();
        if (this.terminated) {
            return;
        }
    }

    requestAnimationFrame(this.run.bind(this));
};

Befunge.prototype.step = function () {
    this.processCurrentToken();
    this.board.advance();
};

Befunge.prototype.processCurrentToken = function () {
    var token = this.board.currentToken();
    if (this.stringMode && token !== '"') {
        return this.stack.pushAscii(token);
    }

    if (this.digits.indexOf(token) !== -1) {
        return this.stack.pushNumber(token);
    }

    switch (token) {
        case ' ':
            while ((token = this.board.nextToken()) == ' ') {
                this.board.advance();
            }
            return;
        case '+':
            return this.stack.pushNumber(this.stack.popNumber() + this.stack.popNumber());
        case '-':
            return this.stack.pushNumber(-this.stack.popNumber() + this.stack.popNumber());
        case '*':
            return this.stack.pushNumber(this.stack.popNumber() * this.stack.popNumber());
        case '/':
            var denominator = this.stack.popNumber(),
                numerator = this.stack.popNumber(),
                result;
            if (denominator === 0) {
                result = +prompt("Illegal division by zero. Please enter the result to use:");
            } else {
                result = Math.floor(numerator / denominator);
            }

            return this.stack.pushNumber(result);
        case '%':
            var modulus = this.stack.popNumber(),
                numerator = this.stack.popNumber(),
                result;
            if (modulus === 0) {
                result = +prompt("Illegal division by zero. Please enter the result to use:");
            } else {
                result = Math.floor(numerator / modulus);
            }

            return this.stack.pushNumber(result);
        case '!':
            return this.stack.pushNumber(this.stack.popNumber() === 0 ? 1 : 0);
        case '`':
            return this.stack.pushNumber(this.stack.popNumber() < this.stack.popNumber() ? 1 : 0);
        case '>':
            this.board.direction = Direction.RIGHT;
            return;
        case '<':
            this.board.direction = Direction.LEFT;
            return;
        case '^':
            this.board.direction = Direction.UP;
            return;
        case 'v':
            this.board.direction = Direction.DOWN;
            return;
        case '?':
            this.board.direction = [Direction.RIGHT, Direction.UP, Direction.LEFT, Direction.DOWN][Math.floor(4 * Math.random())];
            return;
        case '_':
            this.board.direction = this.stack.popNumber() === 0 ? Direction.RIGHT : Direction.LEFT;
            return;
        case '|':
            this.board.direction = this.stack.popNumber() === 0 ? Direction.DOWN : Direction.UP;
            return;
        case '"':
            this.stringMode = !this.stringMode;
            return;
        case ':':
            var top = this.stack.popNumber();
            this.stack.pushNumber(top);
            return this.stack.pushNumber(top);
        case '\\':
            var first = this.stack.popNumber(),
                second = this.stack.popNumber();
            this.stack.pushNumber(first);
            return this.stack.pushNumber(second);
        case '$':
            return this.stack.popNumber();
        case '#':
            return this.board.advance();
        case 'p':
            return this.board.grid[this.stack.popNumber()][this.stack.popNumber()] = this.stack.popAscii();
        case 'g':
            return this.stack.pushAscii(this.board.grid[this.stack.popNumber()][this.stack.popNumber()]);
        case '&':
            return this.stack.pushNumber(+prompt("Please enter a number:"));
        case '~':
            return this.stack.pushAscii(prompt("Please enter a character:")[0]);
        case '.':
            return this.print(this.stack.popNumber());
        case ',':
            return this.print(this.stack.popAscii());
        case '@':
            this.terminated = true;
            return;
    }
};

Befunge.prototype.withStdout = function (printer) {
    this.print = printer;
    return this;
};

Befunge.prototype.withOnAdvance = function (onAdvance) {
    this.board.onAdvance = onAdvance;
    return this;
};

String.repeat = function (str, count) {
    var repeated = "";
    for (var i = 1; i <= count; i++) {
        repeated += str;
    }

    return repeated;
};

window['requestAnimationFrame'] = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function (callback) {
    window.setTimeout(callback, 1000 / 60);
};

(function () {
    var currentInstance = null;

    function resetInstance() {
        currentInstance = null;
    }

    function getOrCreateInstance() {
        if (currentInstance !== null && currentInstance.terminated) {
            resetInstance();
        }

        if (currentInstance === null) {
            var boardSize = Editor.getBoardSize();
            currentInstance = new Befunge(Editor.getSource(), {
                width: boardSize.width,
                height: boardSize.height
            });
            currentInstance.stepsPerTick = Editor.getStepsPerTick();

            currentInstance.withStdout(Editor.append);
            currentInstance.withOnAdvance(function (position) {
                Editor.highlight(currentInstance.board.grid, position.x, position.y);
            });
        }

        return currentInstance;
    }

    var Editor = (function (onExecute, onStep, onReset) {
        var source = document.getElementById('source'),
            sourceDisplay = document.getElementById('source-display'),
            sourceDisplayWrapper = document.getElementById('source-display-wrapper'),
            stdout = document.getElementById('stdout');
        var execute = document.getElementById('execute'),
            step = document.getElementById('step'),
            reset = document.getElementById('reset');
        var boardWidth = document.getElementById('board-width'),
            boardHeight = document.getElementById('board-height'),
            stepsPerTick = document.getElementById('steps-per-tick');

        function showEditor() {
            source.style.display = "block";
            sourceDisplayWrapper.style.display = "none";
            source.focus();
        }

        function hideEditor() {
            source.style.display = "none";
            sourceDisplayWrapper.style.display = "block";

            var computedHeight = getComputedStyle(source).height;
            sourceDisplayWrapper.style.minHeight = computedHeight;
            sourceDisplayWrapper.style.maxHeight = computedHeight;

            sourceDisplay.textContent = source.value;
        }

        function resetOutput() {
            stdout.value = null;
        }

        function escapeEntities(input) {
            return input.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
        }

        sourceDisplayWrapper.onclick = function () {
            resetOutput();
            showEditor();
            onReset && onReset.call(null);
        };
        execute.onclick = function () {
            resetOutput();
            hideEditor();
            onExecute && onExecute.call(null);
        };
        step.onclick = function () {
            hideEditor();
            onStep && onStep.call(null);
        };
        reset.onclick = function () {
            resetOutput();
            showEditor();
            onReset && onReset.call(null);
        };

        return {
            getSource: function () {
                return source.value;
            },

            append: function (content) {
                stdout.value = stdout.value + content;
            },

            highlight: function (grid, x, y) {
                var highlighted = [];
                for (var row = 0; row < grid.length; row++) {
                    highlighted[row] = [];
                    for (var column = 0; column < grid[row].length; column++) {
                        highlighted[row][column] = escapeEntities(grid[row][column]);
                    }
                }

                highlighted[y][x] = '<span class="activeToken">' + highlighted[y][x] + '</span>';
                sourceDisplay.innerHTML = highlighted.map(function (lineTokens) {
                    return lineTokens.join('');
                }).join('\n');
            },

            getBoardSize: function () {
                return {
                    width: +boardWidth.innerHTML,
                    height: +boardHeight.innerHTML
                };
            },

            getStepsPerTick: function () {
                return +stepsPerTick.innerHTML;
            }
        };
    })(function () {
        getOrCreateInstance().run();
    }, function () {
        getOrCreateInstance().step();
    }, resetInstance);
})();
.container {
    width: 100%;
}
.so-box {
    font-family:'Helvetica Neue', Arial, sans-serif;
    font-weight: bold;
    color: #fff;
    text-align: center;
    padding: .3em .7em;
    font-size: 1em;
    line-height: 1.1;
    border: 1px solid #c47b07;
    -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
    text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
    background: #f88912;
    box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
    display: inline-block;
    border-radius: 6px;
    float: left;
    margin-right: 25px;
    cursor: pointer;
}
.option {
    padding: 10px 20px;
    margin-right: 25px;
    float: left;
}
input, textarea {
    box-sizing: border-box;
}
textarea {
    display: block;
    white-space: pre;
    overflow: auto;
    height: 75px;
    width: 100%;
    max-width: 100%;
    min-height: 25px;
}
span[contenteditable] {
    padding: 2px 6px;
    background: #cc7801;
    color: #fff;
}
#controls-container, #options-container {
    height: auto;
    padding: 6px 0;
}
#stdout {
    height: 50px;
}
#reset {
    float: right;
}
#source-display-wrapper {
    display: none;
    width: 100%;
    height: 100%;
    overflow: auto;
    border: 1px solid black;
    box-sizing: border-box;
}
#source-display {
    font-family: monospace;
    white-space: pre;
    padding: 2px;
}
.activeToken {
    background: #f88912;
}
.clearfix:after {
    content:".";
    display: block;
    height: 0;
    clear: both;
    visibility: hidden;
}
.clearfix {
    display: inline-block;
}
* html .clearfix {
    height: 1%;
}
.clearfix {
    display: block;
}
<div class="container">
    <textarea id="source" placeholder="Enter your Befunge-93 program here" wrap="off">&> :#v_,>:#,_@
 ^-1:<</textarea>
    <div id="source-display-wrapper">
        <div id="source-display"></div>
    </div>
</div>
<div id="controls-container" class="container clearfix">
    <input type="button" id="execute" class="control so-box" value="► Execute" />
    <input type="button" id="step" class="control so-box" value="Step" />
    <input type="button" id="reset" class="control so-box" value="Reset" />
</div>
<div id="stdout-container" class="container">
    <textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea>
</div>
<div id="options-container" class="container">
    <div class="option so-box">Steps per Tick: <span id="steps-per-tick" contenteditable>500</span>

    </div>
    <div class="option so-box">Board Size: <span id="board-width" contenteditable>80</span> x <span id="board-height" contenteditable>25</span>

    </div>
</div>

I hope you don't mind that I used an inline interpreter from here :)

The question doesn't state that we must print it in any order, so this is five byte shorter: &> #- #1:# :#,_@ (it just prints it in reverse)

I shaved off another bytes for a total of 15. Because of newlines I will edit it into your post.

Well played on the extra golfing :) As for the inline interpreter, I wasn't aware there was one. It's great, thanks :)

The interpreter is new from the linked challenge. I just thought I'd actually use it when I saw your answer. :)

@JamesHolderness Well spotted. I've edited the answer accordingly.

Java, 151 128 77 62 56 bytes
First try at code-golfing.
void f(int n){for(char i=0;++i<=n;System.out.print(i));}

Usage:
import java.util.Scanner;
class A {

    public static void main(String[] a) {
        int num = new Scanner(System.in).nextInt();
        new A().f(num);
    }

    void f(int n) {
        for (char i = 0; ++i <= n; System.out.print(i));
    }
}

Thanks to @Shujal, @flawr, @Ingo Bürk and @Loovjo for the serious byte reduction.

You can save some chars by declaring the int while opening the scanner: int i,n=new Scanner(... and changing the loop to for(;++i<n;). Also, you don't need to invoke Character.toString. You can just feed System.out a char value and it will happily output it.

@Shujal I have much to learn yet. Thanks!

The challenge allows the use of your a as input. And I think you can shorten the for loop by abusing the increment place as loop body: for(;++i<n;System.out.print((char)i)); (but you might have to change the initialization or end value by +- 1)

You are allowed to write a function, so no need for an entire class and everything.

@IngoBürk I'm dumb enough to write the whole thing and not read that I can and cannot do. Oh well...

@RodolfoDias You can drop the public keyword and honestly, the static as well. It's still a function/method. You can also replace ++i<n+1 with ++i<=n.

@IngoBürk Hmm, if I don't put the i+1, the function prints the n-1 first ASCII charachters. At least, it's what it's happening here :/

@RodolfoDias Are you sure? Obviously, ++i<n+1 should be equivalent to ++i<=n. Note the = in there, however! It just saves one byte. It works for me.

@IngoBürk Damn it, next time I have to double our triple-read comments before posting. Of course it's the same think... hides

So we come down to void f(int n){int i=0;for(;++i<=n;System.out.print((char)i));} which is 62 bytes. At least I don't see more to golf now. :)

56 bytes: void f(int n){for(char i=0;++i<=n;System.out.print(i));}

@Loovjo 55 bytes actually if you remove the = and post-increment instead of pre-increment: void f(int n){for(char i=0;i++<n;)System.out.print(i);}

@JackAmmo You're right that you can change the <= to < by also changing ++i to i++. However, you then also have to change the char i=0; to char i=1;. So this: void f(int n){for(char i=1;i++<n;)System.out.print(i);} (and indeed 55 bytes) Try it here.

APL,5
⎕UCS⍳

Example usage:
⎕UCS⍳256

You don't have to make a dfn. Just ⎕UCS⍳ would work fine.
So 5 chars

You don't have to support code points over 127. Just ↑⎕AV would work fine. So 4 chars

JavaScript, ES6 - 52 58 56 53 44 42 bytes
n=>String.fromCharCode(...Array(n).keys())

Paste this into the Firefox console. Run as f(NUM).
Had to make it longer because the first didn't properly accept input.
Down 3, thanks edc65! Down to 44 thanks to Swivel!

This doesn't really handle neither parameter nor input.

Just change the 70 to a different number; that's the input.

Okay, i updated it to take input, at the cost of 6 bytes.

Much better. But the parenthesis around fat arrow function's single argument is not necessary: f=n=>….

Thanks for that. This is the first time i've really done ES6.

-2: f=n=>[...Array(n)].map((v,i)=>String.fromCharCode(i))

@edc65 -3 by my count, thanks!

Remind me what [...Array(n)] does?

@WallyWest It creates an empty array of length n, then populates it with 0s via the spread operator, so that map will work.

44 Characters! f=n=>String.fromCharCode(...Array(n).keys())

@Scimonster No +1 for 9 byte weight loss assistance? :P

You don't need the f=, unnamed functions are allowed.

Haskell, 17 23 bytes
flip take['\0'..]

Not sure if it is possible to do any better without imports.
Edit
My first solution didn't actually print the result, so allow 6 more chars for that:
print.flip take['\0'..]

Also, not shorter (25 chars with printing, 19 without), but an interesting alternate approach (it requires 'Data.List', though):
print.((inits['\0'..])!!)

This doesn't actually print the result.

@nyuszika7h now it does

(`take`['\0'..]) saves a byte.

Perl, 17 bytes
say chr for 0..$_

Too many parenthesis. print chr for 0..$ARGV[0]

You're right! It has been a while since I used perl

You can use shift instead of $ARGV[0] to save 2 bytes.

If you are allowed to print the characters on different lines, you can use say. Also, the character count is shorter if you do it as a one-liner with -n. echo "90" | perl -nE'say chr for 0..$_' would count as 18 characters. 17 for say chr for 0..$_ plus 1 for the n.

You're right. But say won't work with every version of perl.

@Demnogonis say was introduced in 5.14 and you're allowed to use it on here to save 2 bytes if you want to.

You should remove the old versions instead of using strikethrough. That's what the revision history is for.

@nyuszika7h Old habits die hard. I was forced to work with active perl 5.6 until last year.

You can avoid the +1 for -n by using <> in place of $_.

awk - 27
{while(i<$0)printf"%c",i++}

To give the parameter on stdin run it like:
awk '{while(i<$0)printf"%c",i++}' <<<96

Just for fun: The "think positive version" starting with a definitive yes:
yes|head -96|awk '{printf"%c",NR-1}'

NR-1 is needed to print (char)0 for NR==1.     :-(
And why don't we have a no command? That's kinda mean!

alias no='yes no'

...but then I'd have to count the chars of that alias definition too... :-(

This made my day. @nyuszika7h.  My gosh XD thanks for this

Bash+BSD common utilities, 9 bytes
jot -c $1

GNU dc, 20 bytes
?sc_1[1+dPdlc>m]dsmx

C, 31 30 28 27
k;f(n){putch(k++)<n&&f(n);}

Since putch is nonstandard, here's the fully compliant version:
k;f(n){putchar(k++)<n&&f(n);}

Must be called from main:
main(){f(255);}

EDIT: Improved by taking advantage of putchar return value
EDIT 2: Reduced by another character through recursion

putch is a non-standard function. Also, may I ask why this answer was downvoted?

@Stuntddude I'll add an alternatve version that uses putchar, and no idea why this is downvoted. After all, it is one of the shorter ones.

CJam, 3
,:c

I assumed the argument to be the top stack element.
Example usage:
256,:c

ri,:c

Ruby, 30 characters
puts (0..$*[0].to_i).map &:chr

J - 5 bytes
{.&a.

{. is Head, a. is Alphabet ( a list of all chars) and & Bonds them, generating a monadic verb called like:
{.&a. 100 NB. first 100 characters

Note: It seems this does not work interactively: Jconsole and jQt seems to set up a translation, outputting box characters instead of some control characters. In a script or from the commandline, it does work though:
  ijconsole <<< '127 {. a.' | hd

Notice that the alphabet is not exactly ASCII.

Up to {.&a. 127, it is no?

No because J has box drawing characters instead of some of the control characters.

Actually, writing this to a file and inspecting it with a hex viewer tells me that J outputs the correct values (0x00 0x01, ...) . it's only the J interpreter/ IDE interpretting those values as boxdrawing characters instead of control characters. It does exactly the same as all other languages using char or equivalents do.

That's weird because I tested it on my UNIX box and it did indeed output Unicode characters for some of the code-points.

Let us continue this discussion in chat.

Oh please not...

gs2, 2 bytes
V.

This should be competing, I think! It would’ve worked even in the early days of gs2. Try it here.

Successfully tested with this version, which predates the challenge by a month.

Brainfuck, 44 bytes

,
[
  <[>++++++++++<-]
  -[>-<-----]
  >+++>,
]
<[>.+<-]

Expects a decimal string without a trailing newline.
Try it online.
Reading integers in the range [0, max_cell_size] in brainfuck is not difficult. I encourage you to invent a clean method on your own. I consider this a beginner level exercise. (The reverse operation of printing a cell's numeric value is more involved, and could be considered an intermediate level task.)
Here's a 58-byte version that can handle 256 on 8-bit implementations:

,
[
  <[<+> >++++++++++<-]
  -[>-<-----]
  >+++>,
]
<[>]
-<<[>.]
>[>+.<-]

Why haven't I thought of this??? This is ingenious!!!

Can I borrow this to use on future answers?

@FinW I'm guessing you don't know about this meta post.

√ å ı ¥ ® Ï Ø ¿ , 3 bytes
Note: Language post-dates challenge
IrW

Explanation
I   › Take input from command line, evaluate and push to stack
 r  › Push the range from 0 to top value + 1
  W › Output the whole stack as Unicode characters

Alternate Solution
As pointed out by @FlipTack in his Java answer, it is not clear if the OP wants us to print up to and including the input or excluding the input.
If the second is true, the solution below is the correct answer.
IrPW

Explanation
I    › Take input from command line, evaluate and push to stack
 r   › Push the range from 0 to top value + 1
  P  › Pop the top value from the stack
   W › Output the whole stack as Unicode characters

Link to language?

@user Added: https://github.com/cairdcoinheringaahing/UnprintableName

Golfscript - 5
Thanks to @Dennis
~,''+

~,""+ is shorter and correctly processes input from STDIN.

@Dennis That doesn't produce any output for me...

Are you using the online interpeter? To correctly simulate input from STDIN, you have to use, e.g., ;"65", since the input from STDIN will always be a string.

@Dennis Oh thanks that works now!

Lua - 43 41 Bytes
for i=1,arg[1]do print(string.char(i))end

You can shorten this by a byte
a=""for i=1,arg[1]do print(a.char(i))end

You can shorten this by 2 bytes for i=1,arg[1]do print(("").char(i))end

Befunge 98, 22
&:00pv>0gk,@
0::-1<^j`

Kind of sad that this is so long.
&:00p        ; gets numerical input, stores a copy at cell (0,0)               ;
     v       ; IP goes down                                                    ;

     <       ; IP goes left, so I execute 1-::0`j^                             ;
 ::-1        ; (1-::) subtract one from our number and duplicate it twice      ;
0       `    ; (0`) compare the number with 0, push 1 if greater else 0        ;
     <^j     ; if the result was 0, go up, otherwise continue going left       ;

      >0gk,  ; get the value at cell (0,0), print that many numbers from stack ;
           @ ; terminate program                                               ;

T-SQL: 68 63
As a print loop
DECLARE @i INT=64,@ INT=0A:PRINT CHAR(@)SET @+=1IF @<=@i GOTO A

T-SQL: 95 86
As a query
DECLARE @ INT=64SELECT TOP(@+1)CHAR(ROW_NUMBER()OVER(ORDER BY 0/0)-1)FROM sys.messages

Edit:  Made changes and fixes pointed out by Muqo.  Thanks.
Fixes and golfing suggested by @t-clausen.dk

For the loop, you can save 5 or so characters converting the WHILE to a GOTO with label.  For the query, maybe specify msdb.sys.objects to guarantee enough objects.  Also, it doesn't output CHAR(0).  However, as consolation you can ORDER BY @.

Second answer is invalid. You can rewrite it this way and golf 9 characters: DECLARE @ INT=64SELECT TOP(@+1)CHAR(ROW_NUMBER()OVER(ORDER BY 0/0)-1)FROM sys.messages

@t-clausen.dk not sure how I let that one through.  Thanks for that.

Ruby, 23
f=->n{puts *?\0..n.chr}

Explanation

Input is taken as the argument to a lambda. It expects an Integer.
The "destructuring operator" (*) invokes #to_ary on the Range to print every character on its own line.

Python 3.4 - 36 bytes / 43 bytes
print(*map(chr,range(int(input()))))
print(*map(chr,range(int(input()))),sep='')

255
input()
How this works is:

Get upper limit of range
Generate a range of the table.
Map the range to chr function ( takes int, returns ascii ).
Consume the map via splat argument expansion ( number -> character -> print! )

The second one just removes the space separating each character in exchange for 7 bytes.

You could very much make this into a lambda, as the question states this, and in Python 2, map returns a list, so you could just do f=lambda i:map(chr,range(i))

That's true, and my initial solution was similar but I didn't want to use a lambda so that I could immediately print output. I wish map kept the trend of returning a list instead of an iterator, even if it is more pythonic that way.

Pascal 87
program _;var c:char;n:byte;begin n:=0;readln(n);for c:=chr(0)to chr(n)do write(c);end.

Pascal 73
program _;var c,n:byte;begin readln(n);for c:=0to n do write(chr(c));end.

Builds and runs fine from http://www.onlinecompiler.net/pascal

FreePascal (and if I remember correctly, Turbo Pascal too) only needs 60 of those characters: var c,n:byte;begin read(n);for c:=0to n do write(chr(c))end. http://pastebin.com/aFLVTuvh

Quite possibly, I've only used Delphi.  But someone edited that out of the title.

x86 ASM (Linux) (many many bytes unless you compile it)
Written as a function, assumes parameter is passed in AX (I forget the number for the read syscall)
Also doesn't preserve [SP] or BX.
test ax,ax
jz @Done
mov [sp],ax
@Loop:
mov ax,4
mov bx,1
mov cx,sp
mov dx,1
int 0x80
sub [sp],1  ; Can I do this?  Or do I need to load/sub/store separately?
jnz @Loop
@Done:
ret

(I should have put a F00F exploit in there, it's not like anyone will run it anyway)

I was going to run this. I'm not going to run this now.

Perl - 29
sub f{print map{chr}0..shift}

Julia: 20 characters (REPL)
This is close to the question's example: just generates the characters and let the REPL to do whatever it wants with them.
f(n)=map(char,[0:n])

Julia: 33 characters
Prints each character in a separate line.
print(map(char,[0:int(ARGS[1])]))

M (MUMPS) - 21
R n F i=1:1:n W $C(i)
In expanded form: READ n FOR i=1:1:n WRITE $CHAR(i)

BrainFuck - 140 112 Bytes
,>,>,>-[>+<-----]>---[<+>-]<[<<<->->->-]<[>+<-]<[>>++++++++++<<-]<[>>>>++++++++++[<++++++++++>-]<<<<-]>>>[>.+<-]

Try It Here!
Saved 28 bytes by changing [<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-] to [<<<->->->-].
What it does
,>,>,>                                                              Takes three inputs
                                                                    in three separate cells

-[>+<-----]>---[<+>-]<[<<<->->->-]<                                 Takes 48 off of each to
                                                                    convert them to decimal

[>+<-]<[>>++++++++++<<-]<[>>>>++++++++++[<++++++++++>-]<<<<-]>>>    Combines them into a
                                                                    three digit number by
                                                                    multiplying the first
                                                                    by 100, the second by
                                                                    10 and then adding all
                                                                    three

[>.+<-]                                                             Repeatedly prints the
                                                                    value of the adjacent
                                                                    cell and then adds one
                                                                    to it until it reaches
                                                                    the input value.

Ruby - 35 33 bytes
Please note that I can't Ruby at all:
$*[0].to_i.times{|i|puts i.chr()}

As far as I know there is an alias for "puts" that is simply "p". So -3 bytes if that's correct?

@Forlan07, not really an alias. p is equivalent to puts whatever.inspect.

@manatwork OK, nice to know :-)

This prints every character on a separate line. Shouldn't it be print?

Fixed and 3 bytes shorter: puts (0..$*[0]).map(&:chr)*''

Sorry, that should be $*[0].to_i, which makes it 2 bytes longer rather than 3 shorter.

PowerShell - 20
%{0..$_|%{[char]$_}}

Usage:
56 | %{0..$_|%{[char]$_}}

A bit debatable to call a piece of syntax that isn't even valid a program or function ;-) (you cannot use ForEach-Object standalone like that). The function part of that is the script block, but it won't ever work as a function, because the context ($_) is provided by ForEach-Object. You can shorten it a bit by casting the range to an array, by the way.

Java, 125 bytes
class M{public static void main(String[]a){p(256);}static void p(int l){int i=-1;for(;i++<l;){System.out.println((char)i);}}}

Simply puts in the number of characters to print from the ascii table @ p(n) where n is the number of characters.

Befunge-98, 26 20
0&;1-::0`j;;,$>:#,_@

It's longer than the other Befunge-98 answer, but it's not self-modifying and only uses one line. (Also, the pointer only moves to the right until it gets to the print loop.)
This is shorter now. Also, it's still not self-modifying. Hooray, jumping trickery!

Rebol - 35 34
for n 0 do input 1[prin to-char n]

If I'm allowed to have another answer in a different language, here goes...
Pascal: 91 bytes
PROGRAM A;VAR i,n:Integer;BEGIN
n:=0;readln(n);FOR i:=0 TO n DO
Write(chr(i));readln;END.

(just for kicks, really, I haven't messed in Pascal in ages)

Posting multiple answers is perfectly fine.

@Dennis is well aware of this. Just check all the questions he's answered

You can re‑use your input/length variable n as the counter variable in the for-loop:
program p(input,output);var n:integer;begin read(n);for n:=1 to n do write(chr(n))end.

Python 3 — 51 bytes
lambda n:sys.stdout.buffer.write(bytes(range(n+1)))

This is a variation of a line I keep in my shell history for when I need to refer to the ASCII table.
It first calls range(), passing n + 1 as the sole argument. When used like this, range() returns an iterable of integers between 0 (inclusive) and the argument (exclusive—hence the need for the +1). The iterable is then passed to bytes(), which returns a bytestring, interpreting each integer as one byte. The bytestring is then written directly to the buffer for stdout (passing it to sys.stdout.write() or print() would result in an exception; those accept strings, not bytestrings).
Note that n must not be greater than 255. If it is, bytes() will raise an exception, because values greater than 255 do not fit in a single byte.
Also note that this doesn't bind the function to a name. I'm assuming that's acceptable, given that it does still create the function.

There's no need for all of that: lambda n:print(str(bytes(range(n+1)))) is just 38 characters. 2. If you go with your current method, you need to include import sys.

Actually, just lambda n:print(bytes(range(n+1))) works perfectly well.

PHP - 47 bytes
<?=join(array_map('chr',range(0,$argv[1])));

Usage:
php ascii.php n

join does the same as implode and is 3 bytes shorter.

@Titus good catch, updated!

LiveScript - 47
f=->alert String.fromCharCode.apply(,[0 to it])

PHP - 36
If PHP Notice are set to off then this:
<? for(;$i<$argv[1];)echo chr($i++);

PHP - 42
Otherwise:
<? for($i=0;$i<$argv[1];$i++)echo chr($i);

I think you can remove the PHP tag. JS answers typically don't include script tags, either.

OK, ty. First post so not sure how it goes :)

@IngoBürk That may be because Node.js doesn't need any script tags. You need <?php (or <? if short tags are enabled) for any PHP script, though.

@nyuszika7h Node doesn't support ES6 and yet ES6 answers don't include tags.

I don't see your point. It does have partial support via --harmony, but that doesn't have to be counted unless perhaps the answer relies on Node-specific APIs. Script tags are just a way to include JavaScript in a HTML file, on the other hand even standalone PHP scripts need an opening tag or they won't work.

@nyuszika7h You're right. Although it can at least be the short tag <? without a closing tag. Sorry for the wrong suggestion, Dexa.

@IngoBürk not a problem at all. Few chars more or less wont make any difference, other languages do this much better anyway :)

-1: omit the whitespace after <?. I have read somewhere in meta that warnings are ok; cannot find it at the moment though.

@Titus -1 for this? I'll just smile and walk away :)

@Dexa -1 bytes. But actually it´s -3 with the unnecessary PHP tags.

@Titus Oh I meant you downvoted because of this. No problem.

F# - 66 characters
[<EntryPoint>]
let m a=
 for x in char 0..a.[0].[0]do printfn"%c"x
 0

PowerShell, 20
[char[]](0.."$args")

C# - 65 63 52
c=>{for(var i='\0';i<=c;)System.Console.Write(i++);}

Inspired by Java solution
Usage:
public class Program
{
    public static void Main()
    {
        new System.Action<char>(c => {for(var i='\0';i<=c;)System.Console.Write(i++);})((char)255);
    }
}

Thanks to Martin for the help.

You can probably save two bytes by a) using var instead of char and b) by doing ...Write(i++) and leaving the third section of the for statement empty.

I just saw a python solution using lambdas. So would this be a valid solution: c=>{for(var i='\0';i<=c;)System.Console.Write(i++);}?

I'm not very familiar with C#'s lambdas, but I think so.

MATLAB: 13 bytes
@(n)char(0:n)

This is an anonymous function that prints the string.
MATLAB: 17 bytes
This one takes STDIN.
char(0:input(''))

I think these are pretty short for a non-golf language. :)

The standard tips for casting to chars when golfing in MATLAB / Octave: @(n)[0:n,'']. =) Saves you a byte!

x86 DOS (11 bytes)
Takes parameter in CL
-u100
07AD:0100 mov ah,02
07AD:0102 cwd
07AD:0103 int 21
07AD:0105 inc dx
07AD:0106 cmp dl,cl
07AD:0108 jb 103
07AD:010A ret
07AD:010B

Pip, 3 bytes (not competing)
The language is newer than the question, but happens to do very well with it:
C,a

a is the first command-line argument. The unary range operator , constructs a range of all numbers 0 <= n < a. Finally, C converts them to characters. The resulting list is autoprinted, by default without any delimiter. Works into Unicode range too!

Perl 6, 25 22 bytes
put (^@*ARGS[0])».chr

Japt, 7 bytes
Uo md q

Test it online!
How it works
      // Implicit: U = input integer
Uo    // Create the range [0..U).
md    // Map each item X in this range to X.d().
      // If X is a number, this turns into the character with that char code.
q     // Join the array with the empty string.
      // Implicit: output last expression

ES6, 42 bytes
Sorry for the necro.
n=>String.fromCharCode(...Array(n).keys())

If you need it as a program, 54 bytes:
alert(String.fromCharCode(...Array(+prompt()).keys()))

However for some reason I can't get the above to work as a Stack Snippet.

F#, 43 bytes
fun n->Seq.iter(printf"%c")['\x00'..char n]

That is...
fun n->                                     // A function that takes n
                           ['\x00'..char n] // Generates a list of chars from NUL to n
       Seq.iter(          )                 // For each one,
                printf"%c"                  // Print it!

I tried using \0 for NUL, but it doesn't work in F#. I couldn't get it under 4 characters, in any case. =P

Lua, 37 Bytes
a=...for i=1,a do print(a.char(i))end

Jelly, 2 bytes
ḶỌ

Try it online!
According to current reference implementation as of time of posting.

Jelly, 3 bytes
‘ḶỌ

Try it online!
Inclusive. Reference implementation is exclusive.

@ASCII-only Well, I may update the links here, but it's not just the certificates.

PHP, 35 34 bytes
<?=join(range(a^a,chr($argv[1])));

yup. PHP can create a range of characters.
Takes argument from command line. Save to file, execute.

Pushy, 2 bytes
Input is given on the command line, $ pushy asciitable.pshy 90. Note that this will not work for numbers larger than 127.
X"

Explanation:
    \ Implicit: Input number on stack
X   \ Get range [0, n)
 "  \ Interpret as charcodes and print

><>, 14 bytes
0:o1+:r:@=?;$!

Try it here!
Explanation
0              push 0 to the stack                [n, 0]
 :             duplicate the top value            [n, 0, 0]
  o            output it                          [n, 0]
   1+          add one                            [n, 1]
     :         duplicate top value                [n, 1, 1]
      r        reverse the stack                  [1, 1, n]
       :       duplicate the top value again      [1, 1, n, n]
        @      move the top value back twice      [1, n, 1, n]
         =?;   pop top two values, if equal, end  [1, n]
            $  swap top two stack values          [n, 1]
             ! skip next instruction (0)

or
0:o1+$1-:?!;$!

Try it here!
Explanation
0              push 0 to the stack                [n, 0]
 :             duplicate the top value            [n, 0, 0]
  o            output it                          [n, 0]
   1+          add one                            [n, 1]
     $         swap top two values                [1, n]
      1-       subtract one                       [1, n-1]
        :      duplicate top value                [1, n-1, n-1]
         ?!;   if n is 0, end                     [1, n-1]
            $  swap top two stack values          [n-1, 1]
             ! skip next instruction (0)

For both simply place n on the stack and the result will be outputted.

Tcl, 47 bytes
set i 0
time {puts [format %c $i];incr i} $argv

Try it online!

Making the user set n is not valid

@ASCII-only: I am in the process of reviewing my older answers. Thanks for pointing out

SmileBASIC, 31 bytes
INPUT N
FOR I=.TO N?CHR$(I)NEXT

. is read as 0.0, and I could have just used 0 in this case, but . looks cooler.

J, 8 bytes
f=:{.&a.

Explanation:
f=:{.&a.
f=:      define a function f
      a. the ascii sequence
     &   attach it to the next operator
   {.    take the first n items of
         you'll notice I don't say how many,
         that's because in J you can leave blanks and the interpreter fills them in

I trust that you did something, but I don't see what changed.

Riley's edit formatted the header by prefixing # so it would be styled as a header (larger font, bold).

evil, 10 bytes
I've been playing around with evil lately, and this is my first PPCG submission (albeit 2.5 years late). I find it a fun esolang to use partially because it seems nobody uses it!
ramlwalusb

Explanation
r   // Store input character to Accumulator as byte
a   // Since we are writing then adding, add 1 to Accumulator
m   // Drop a loop marker
l   // Swap Wheel and Accumulator
w   // Output Accumulator
a   // Increment Accumulator
l   // Swap Wheel and Accumulator
u   // Decrement Accumulator
sb  // Go back to m if A != 0

evil is also an easy language to write an interpreter for. I think there's a javascript one floating around somewhere, but I ended up just writing my own.
EDIT: Try it online!

Cool answer! Welcome to the site!

R, 24 bytes
cat(intToUtf8(1:scan()))

Try it online!

Excel VBA, 26 bytes
An anonymous VBE immediate window function that takes input from cell [A1]
For i=1To[A1]:?Chr(i):Next

Yabasic, 34 bytes
Input""n
For i=1To n
?Chr$(i)
Next

Try it online!

Kotlin, 42 bytes
{n:Int->for(c in 0..n-1)print(c.toChar())}

Try it online!

Check, 2 bytes
,o

Try it online!
Check has:

Implicit input
A range builtin
A builtin to output a list of codepoints as characters

Momema, 25 bytes
0*-8j0j+1-=*0-9*00+-1*0j1

Outputs the characters in reverse order. Try it online!
Explanation
0   *-8     #            [0] = read num
j   0       #  label j0: goto j0
j   +1-=*0  #  label j1: goto j(1 - !![0])
-9  *0      #            print char [0]
0   +-1*0   #            [0] = 1 + [0]
j   1       #  label j2: goto j0

Keg, 4 bytes (SBCS)
¿ï(,

TIO
Push input, output ASCII table.

Snap!, 121 bytes

when gf clicked
set[a v]to(
ask[]and wait
for[i v]=(1)to[answer v]
set[a v]to join[a v]unicode[i v]as letter
end
say[a v]

Snap! is quite better than scratch, but I am having problem at the scratchblocks2 syntax because Snap! has some extra blocks.

A0A0, 122 bytes
I0A3L0S1M4V0G0D1A0
G-1A0A0
A0C4G1G1A0
A0
A0G1G1G1V0P0S1A0
A0A1G-4G-4A0
G-4

A0A0
C3G1G1A0C3G1G1A0
A0G-6A0
A0A1G-3G-3A0
G-3

Works by creating a loop where one line counts how many iterations (from x to 0) have been done and the other line prints each character (from 0 to x). The first line is constructing during run-time based on the inputted number in the first line of the code.
L0 S1 M4 V# G0 D1 ; first line, the # indicates user number
L0                ; compares 0 to the inputted number
   S1             ; adds 1 to the comparison result
      M4          ; multiplies this result with 4
         V#       ; sets this result to the G0
            G0    ; jumps this result of lines below
               D1 ; subtract one from the inputted number

G1 G1 G1 V0 P0 S1 ; second line
G1 G1 G1          ; no-ops to align the instructions with the first line
         V0       ; the operand, sets the value of the next instruction
            P0    ; prints the value set by the operand
               S1 ; adds 1 to the operand

For the jumping, jumping by 4 (we hit the last number) will jump to an empty line, halting the program, while jumping by 8 (we're not finished yet) gets us into a loop below which jumps back up to the first loop.

Stax, 1 byte
r

Run and debug it
Integer arrays are auto printed as strings.

Japt -P, 2 bytes
od

Try it
od     :Implicit input of integer
o      :Range [0,input)
 d     :Get the character at each codepoint
       :Implicitly join & output

Thunno 2 B, 1 byte
L

Attempt This Online!
Thunno 2, 3 bytes
LCJ

Attempt This Online!
Explanation
L  # Implicit input
L  # Lowered range
   # B flag casts the list of ordinals
   # into a string of characters
   # Implicit output

LCJ  # Implicit input
L    # Lowered range
 C   # Cast to characters
  J  # Join into a string
     # Implicit output

Haskell - 16 22 characters
(`take`['\0'..])

Edit
Now printing the result
print.(`take`['\0'..])

nice trick to get rid of a character

This doesn't actually print the result.

@JanDvorak he pretty much removed the space, as (``) does the same thing as flip here, in just as many characters...

Lua
for i=0,255 do
    print(string.char(i))
end

This is code golf, so please include the byte count of your submission in the answer. Also, you don't need the line breaks. You can put all of this in one line like for i=0,255 do print(string.char(i)) end.

This is not valid solution as it not handles input/parameter as required.

C, 31 bytes
i;f(n){for(;i<n;)putchar(i++);}

Use:
i;f(n){for(;i<n;)putchar(i++);}

int main(void)
{
    f(34);   //Call the function
    return 0;
}

The challenge says to output all ASCII characters, not just the printable ones, and also to print "n ACII characters", not "ASCII characters up to n", so you could save 4 characters by letter i default to 0 and changing the loop condition to <.
And you could save 1 (or 2, depending how eager you are to invoke undefined behavior) character by moving the call to putchar() into the loop condition.

Thanks. Does the program look ok now?

@Stuntddude In whch way moving the putchar inside the loop condition would trigger UB?

PL/SQL 59
select chr(rownum)from dual connect by rownum<=&i

Didn't see a requirement that said output had to be a concatenated string, so this should work?

JavaScript, 65 bytes
First code golf, but here's my simple JavaScript implementation:
function f(n){for(i=1;i<n;)console.log(String.fromCharCode(i++))}

Not great but decent. ;)
Usage:
f(x) // x could be any number, but generally numbers
     // greater than 0 are better. ;)

The output is rather long so I'm not going to copy it but if you run it I think you'll get the idea. :P
Uncompressed:
function f(n) {
    for (i = 1; i < n;)
        console.log(String.fromCharCode(i++)); // by using i++ we increase
                                               // i right as we get it
}

Welcome to PPCG! I don't think you need those braces, and you do the i++ when call the function like ...fromCharCode(i++) and then leave the third section of the for statement empty.

However, I just noticed that your answer isn't quite valid. You should write a function which takes 256 as a parameter.

Also, I think you should start the loop at 0 rather than 1.

Ah, I'll update to fit what you guys have pointed out. :)

C#, 112 | 83 bytes
Full program, 112 bytes:
class P{static void Main(string[]a){for(int i=0;i<int.Parse(a[0]);i++){System.Console.Write("{0}\n",(char)i);}}}

A function, 83 bytes:
static void f(int n){for(int i=0;i<n;i++){System.Console.Write("{0}\n",(char)i);}}}

Microscript, 9 bytes
i1{d1s}ah
Or alternatively:
i1cs1]fah

Excel VBA - 143
For i = 1 To 127
Cells(i, 1) = i
Cells(i, 2) = Evaluate("DEC2HEX(" & i & ")")
Cells(i, 3) = Evaluate("DEC2OCT(" & i & ")")
Cells(i, 4) = Chr(i)
Next

K: 8 bytes
{10h$!x}

Q: 11 bytes
{10h$til x}

Gema, 43 characters
*=@set{i;0}@repeat{*;@int-char{$i}@incr{i}}

Sample run:
bash-4.3$ gema '*=@set{i;0}@repeat{*;@int-char{$i}@incr{i}}' <<< 96 | xxd
0000000: 0001 0203 0405 0607 0809 0a0b 0c0d 0e0f  ................
0000010: 1011 1213 1415 1617 1819 1a1b 1c1d 1e1f  ................
0000020: 2021 2223 2425 2627 2829 2a2b 2c2d 2e2f   !"#$%&'()*+,-./
0000030: 3031 3233 3435 3637 3839 3a3b 3c3d 3e3f  0123456789:;<=>?
0000040: 4041 4243 4445 4647 4849 4a4b 4c4d 4e4f  @ABCDEFGHIJKLMNO
0000050: 5051 5253 5455 5657 5859 5a5b 5c5d 5e5f  PQRSTUVWXYZ[\]^_

Hassium, 45 Bytes
func a(n)for(x=0;x<n;print((x++).toChar())){}

Run and see expanded here

Oracle SQL 11.2, 48 bytes
SELECT CHR(LEVEL)FROM DUAL CONNECT BY LEVEL<=:1;

DUP, 21 bytes
[1+a:0[$1+$a;<][^,]#]

Try it here!
Anonymous lambda. Usage:
256[1+a:0[$1+$a;<][^,]#]!

Explanation
[                     {start lambda}
 1+a:                 {inputnum is end of range (saved to a)}
     0                {0 is start of range}
      [       ][  ]#  {while loop}
       $1+$a;<        {dup, increment, check if top of stack < a}
                ^,    {if so, output char}
                    ] {end lambda}

Pylons, 9
0{d1+,i}c

How it works:
0     # Push 0 to the top of the stack.
{     # Start a for loop.
 d    # Duplicate the top of the stack.
  1   # Push 1 to the stack.
   +  # Add the top two elements of the stack.
 ,    # Switch to for loop iterators.
  i   # Get input
   }  # End for loop
c     # Print stack as joined array of chars and exit.

Java 76 74 70
Thanks to Mego for saving 4 bytes.
public void f(int x){for(int u=0;u<x;u++)System.out.println((char)u);}

Previous versions:
class f{public void f(int x){for(int u=0;u<x;u++)System.out.println((char)u);}}
class f{public f(int x){for(int u=0;u<x;u++)System.out.println((char)u);}}

The second version needs to be called by new f(n);
Feel free to give me ideas for making it even smaller.

You can do a standalone function: public void f(int x){...}. For even less bytes, if you're working with Java 8, you can use a lambda: x->java.util.stream.IntStream.range(0,x).mapToObj(n->(char)n);

In fact, you don't even need the public - a default-scoped function is fine.

QBIC, 14 bytes, NC
:[a|?chr$(b-1)

Takes a number form the command line and loops from 1 to that number, feeding each iteration into CHR$.
Non-competing, QBIC was thought of a year after this challenge was posted.

Perl 6, 9 bytes
(^*).chrs

The header and code alone are too short, so have this extra sentence.

Java 8, 45 bytes
A lambda expression which takes an integer and prints the table to STDOUT. Golfing suggestions welcome!
x->{for(char i=0;i<x;System.out.print(i++));}

It's not clear whether OP wants x to be the last character printed, or the first character not printed. If it's the second, just change i<x to i<=x :)

QC 18 bytes
'00901)01016010003
'00 Read from stdin and store in memory at address 00
901 Print memory from address 01 until 0 is reached
)0101 Increment memory at 01 by 1
6010003 Jump to 03 if value at 01 and 00 are not equal

Edited because of invalid amount of bytes

Python, 30 bytes
An unnamed lambda function which returns the result as a string.
lambda n:('%c'*n)%(*range(n),)

Try it online!
This uses the printf-style string formatting: when '%c' is formatted with an integer, it converts the integer to a character and displays that. So, we multiply the string by n, and format it with all values in range(n).
29 bytes
If we want to be cheeky and return a list of characters instead of a string, we can get 1 byte shorter:
lambda n:[*map(chr,range(n))]

Try it online!

REXX, 28 bytes
say xrange('0'x,d2c(arg(1)))

Sinclair ZX81 171 bytes for the listing (method 1):
 1 LET N$=""
 2 GOTO 2+(INKEY$<>"")
 3 LET A$=INKEY$
 4 IF A$=CHR$ 118 THEN GOTO 9
 5 IF CODE A$<28 OR CODE A$>37 THEN GOTO 2
 6 PRINT A$;
 7 LET N$=N$+A$
 8 GOTO 2
 9 LET N=VAL N$
10 IF N>255 THEN LET N=255
11 PRINT AT 0,0;
12 FOR I=0 TO N
13 PRINT CHR$ N;
14 NEXT I

This is using the INKEY$ command to build a string of numbers, which is checked by comparing each input to the character range from 0 to 9 inclusing in line 5. Each character is stored in the N$ variable and outputted to the screen. CHR$ 118 is the ZX81 equivalent of a new line "\r\n" in PHP for instance.
There is a check to see if you have entered a valid range once you have pressed NEW LINE (0 to 255 inclusive) - as you can only enter numbers, the range is not going to be below zero.
Then there is a simple FOR...NEXT loop from line 12 to output the non-ASCII compatible character set. So I lose points because the ZX81 does not handle ASCII without some conversion tables.
Also, the ZX81 character set is incomplete to upper-case and inversed upper-case only; the remaining characters are either graphical symbols or they are ZX81 BASIC keywords, such as PI, INKEY$, PRINT etc... There is a much simpler method that I will post later, but is more prone to human error.
Method 2, 34 bytes for the listing, no error checks and sanitizing inputs:
 1 INPUT N
 2 FOR I=0 TO N
 3 PRINT CHR$ I;
 4 NEXT I

Of course I'm sure that someone has already pointed out that true ASCII is 7 bit and the first 8 bit compatible ASCII set was PETSCII.

Commodore 64/128
This solution uses PETSCII which is an 8-bit wide ASCII-compatible character set.
Solution 1 - 42 BASIC bytes used (35 bytes for the listing)
0 printchr$(14);:fori=0to255:poke1024+i,i:next

Solution 2 - 10 bytes assembled, ~72 bytes source code
* = 49152
lda #$00
tax
.loop
    sta $0400,x
    dex
    txa
bne loop
rts

The assembly is doing what the BASIC listing is doing (without switching the character set to business mode first), but is obviously many times quicker. As the 6502 (6510/85xx) processor has an 8-bit accumulator and [8-bit] registers, we start at zero and count down, so 0 - 1 is 0xff. Each character is stored in the screen RAM located at 0x0400 (1024) and sta $0400,x says store the content of X to location $0400 + x. The bne loop will branch back based on the zero flag, once that is set (i.e., x=0x00) it will drop out of the loop and return to BASIC with rts.
Once assembled, run with sys 49152 - this solution should work on the C64 and 128. It will work on other Commodore machines as long as you move the routine to a free area of RAM and relocate the starting point of the screen RAM from 1024.

05AB1E, 3 bytes
L<ç

Try it online!
L<ç  # full program
  ç  # convert...
     # (implicit) each element of...
L    # [1, 2, 3, ...,
     # ..., implicit input...
L    # ]...
     # (implicit) with each element...
 <   # decremented...
  ç  # to chars
     # implicit output

C
I still get better,
hopefully.
#include <stdio.h>
int main() {
    for(int i='a';i<='z';printf("%d\n",i),i++);
  return 0;
}

Pxem, Filename: 19 bytes + Content: 0 bytes = 19 bytes.
Now the debut of lazypxem.min.posixism.

Filename (escaped some): ._.c.w\001.-.c.c.a.s.p
Content is empty.

Try it online!
The footer has |od -vtu1 to be commented; uncomment it to inspect the exact output.

Factor, 16 bytes
[ <iota> print ]

In modern versions of Factor, you can output sequences directly as strings. Here's a pic:

To get it to run on build 1525 (the one TIO uses), you'd have to convert the range to a string like this:
Factor, 21 bytes
[ iota ""like print ]

Try it online!

C (gcc), 27 bytes
f(c){c&&f(c-1),putchar(c);}

Try it online!
C (MSVC), 25 bytes
f(c){c&&f(c-1),putch(c);}

Ly, 7 bytes
n[:o,]o

Try it online!
This one, like at least one previous entry, prints the numbers from largest codepoint to 0, which wasn't disallowed in the rules as far as I can tell.
 n        - read the number of characters to print
  [   ]   - loop until the top of stack is 0
   :      - duplicate the top of stack
    o     - print it
     ,    - decrement the top of stack
       o  - print the x'00' entry

Vyxal s, 2 bytes
ʁC

Try it Online!

authors: خيال بعد المجرة

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

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


text:
Decompose a number into a sum of repdigits
Repdigits are numbers of the form a * (10^n - 1)/9 with  a in [-9,9]\{0} (in other words 111, -3333, 66, numbers which are made by repeating only one digit)
Goal: Write a program or function which takes a single positive integer N and prints N = s_1 + s_2 + ... + s_k. There should be one number per line and the numbers need to be right-aligned. No two summands should have the same number of digits and adding zeros is not allowed. The output should be ordered in ascending or descending order (by number of digits)
Examples:
in:
24192
out:
24192 =
22222 +
 2222 -
  222 -
   33 +
    3

in:
24192
out:
    -7
   -22
  +888
 +1111
+22222
=24192

in:
113
out:
113=    NOT  111+  no empty lines  111+
111+          00+
  2            2                     2

As you can see there can be multiple solutions and some artistic freedom is allowed. Leading and trailing whitespace in each line is allowed
Shortest byte count wins

Should you declare some rules to prevent e.g. just printing N ones?

This is covered already: "No two summands should have the same number of digits"

These numbers are also called repdigits.

perl 5 - 97 92 93 86
$x=$_=pop;{printf"%15s
",$_;$_=$x,s!\d!//,$&!eg,$x-=$_,$i++?s/^\b/+/:s/^/=/;/0/||redo}

Input given as a parameter:
$perl a.pl 2224192
     2224192
    =2222222
       +1111
        +888
         -22
          -7

It doesn't print anything if the number has a 0 in it. Maybe it's the /0/ looping condition.

Thanks, indeed that is the case. I confused myself with the perl shortcut loops. They have condition at the end but still check it at the first iteration. I have to look for "+0" then.

Actually I can simulate do ... while() with just one extra character using redo.

CJam, 55 50 bytes
'=l:L+Li{_W>"-+"=1$zs(\,)*+:Ii-L,_S*I+\~>\}h;]W%N*

Test it here.
Uses the output format
      -7
     -22
    +888
   +1111
+2222222
=2224192

I might golf this more once I'm beaten.
Explanation:
'=l:L+Li{_W>"-+"=1$zs(\,)*+:Ii-L,_S*I+\~>\}h;]W%N*
'=                                                 "Push = character.";
  l:L                                              "Read STDIN and store in L.";
     +L                                            "Concatenate, push new copy of L.";
       i                                           "Convert to integer.";
        {                                 }h       "Do-while loop. Leaves the condition on the
                                                    stack. I will use the remainder for that.";
         _W>                                       "Duplicate remainder, compare with -1.";
            "-+"=                                  "Select appropriate sign character.";
                 1$                                "Copy remainder again.";
                   zs                              "Take abs() and convert to string.";
                     (                             "Shift off first digit.";
                      \                            "Swap with string.";
                       ,                           "Get length.";
                        )                          "Increment.";
                         *                         "Repeat digit that often.";
                          +                        "Concatenate with sign.";
                           :I                      "Store in I.";
                             i-                    "Convert to integer. Subtract from remainder.";
                                                   "Now we'll right-justify I.";
                               L,                  "Load input, get length.";
                                 _                 "Duplicate.";
                                  S*               "Repeat space that often.";
                                    I+             "Load string and concatenate.";
                                      \~           "Swap with length. Bitwise complement.";
                                        >          "Take that many characters from the right.";
                                         \         "Swap with remainder.";
                                            ;      "Discard final remainder (0).";
                                             ]     "Wrap in array.";
                                              W%   "Reverse.";
                                                N* "Join with line feeds.";

The resulting array is printed automatically at the end of the program.

JavaScript ES6 - 145
i=0;f=n=>{return g=n<0,n=Math.abs(n)+'',l=n.length,r=l-1?n[0].repeat(l):n,(i>0?g?'-':'+':n+'=')+'\n'+' '.repeat(i++)+(l-1?r+f((+n-r)*(g?-1:1)):r)}

Paste into Firefox console. Run as f(24192).
Output for f(24192):
24192=
22222+
 1111+
  888-
   22-
    7

With the input 55 it includes a 0 in the sum (which is a bug).

GolfScript 77
~.[{..0>2*(.@*`.,\[0=]*''+~*.@\-.}do;]-1%{[.0>' +'=\`n].1=,2$`,\-' '*\+}%'='@

Online demo links:

24192
2147483648
1 trillionth prime

A slightly more readable version (if GolfScript can be called readable) with unit tests version is available here.


text:
Convert x-illion into standard form
Given a string, consisting of a prefix and then "illion", convert this number into standard form.
For example:
"million" -> 10^6
"trillion" -> 10^12
"quattuordecillion" -> 10^45

The program needs to be able to handle input going up to Centillion, which is 10^303. A  list of names and their standard form values can be found here - note that this gives values for every 10^3 increment up to 10^63, but then gives them in 10^30 increments, however the pattern is fairly straightforward.
The program needs to handle all 100 cases (even the ones not explicitly given by the website provided) - here are some examples of this:
"sexvigintillion" -> 10^81
"unnonagintillion" -> 10^276
"octotrigintillion" -> 10^117

Input can be given via STDIN, function argument or hard-coded as a string.
This is code-golf, so shortest code wins!

What would 10^70 be?

10^70 doesn't have a representation because 3 isn't a factor of 70 - but 10^69 would be sexvigintillion. 10^70 would be 10 sexvigintillion.

Actually, doevigintillion = 10^69, and sexvigintillion = 10^81.

@Remy I would guess that you use the long scale (if that's right)? It sounds like this question uses the short scale.

@Cole Johnson: The question's provided list of names says vigintillion = 10^63, and shows that un- adds 3 to the power, doe- adds 6, sex- adds 18, etc.

@Remy You are absolutely right, apologies.

Besides, in the long scale, one vigintillion would be 10^120.

Python 2 (384 368 365 348 347 bytes)
def c(s):
 s=s[:-6].replace('int','');k=0;d=dict(un=1,doe=2,tre=3,quattuor=4,quin=5,sex=6,septen=7,octo=8,novem=9,b=3,tr=4,quadr=5,qu=6,sext=7,sept=8,oct=9,non=10,dec=11,vig=21,trig=31,quadrag=41,quinquag=51,sexag=61,septuag=71,octog=81,nonag=91,cent=101)
 for p in(s!='m')*list(d)*2:
    if s.endswith(p):s=s[:-len(p)];k+=3*d[p]
 return 10**(k or 6)

(The if line is indented with a single tab, and the rest with single spaces.)
Here c('million') == 10**6 has to be a special case because 'novem' also ends in 'm'.
Examples:
c('million') == 10**6
c('trillion') == 10**12
c('quattuordecillion') == 10**45
c('novemnonagintillion') == 10**300
c('centillion') == 10**303

Thanks to Falko for obfuscating it down to 350 bytes.

For practice I tried rewriting this as a one-liner using lambdas. It's 404 398 390 384 380 379 bytes:
c=lambda s:(lambda t=[s[:-5].replace('gint',''),0],**d:([t.__setslice__(0,2,[t[0][:-len(p)],t[1]+3*d[p]])for p in 2*list(d)if t[0].endswith(p)],10**t[1])[1])(un=1,doe=2,tre=3,quattuor=4,quin=5,sex=6,septen=7,octo=8,novem=9,mi=2,bi=3,tri=4,quadri=5,qui=6,sexti=7,septi=8,octi=9,noni=10,deci=11,vii=21,trii=31,quadrai=41,quinquai=51,sexai=61,septuai=71,octoi=81,nonai=91,centi=101)

+1 for abusing OP's lack of specification of whether "10^x" should be printed or whether just returning the numerical value is sufficient.

Thanks, although return'10^'+str(3*k) would only be 4 bytes more.

Since this is python 2, you could use a space indent for the first level, and tab for the second. You can also move both a and b into the function as keyword arguments.

1000**k is shorter than 10**(3*k). Incrementing k by 3*d[p] is also equally short.

You can save a few characters by avoiding the early exit using if'm'==s:k=6;d=[] instead of a second lengthy return statement.

Two more bytes: if(s!='m')*s.endswith(p) and return 10**[k,6][k<1] saves you the other if statement. That's it for tonight. :)

JS (ES6), 292 270
Understands only the numbers written in the given list. The OP isn't clear about the others.
z=b=>{a="M0B0Tr0Quadr0Quint0Sext0Sept0Oct0Non0Dec0Undec0Doedec0Tredec0Quattuordec0Quindec0Sexdec0Septendec0Octodec0Novemdec0Vigint0Trigint0Quadragint0Quinquagint0Sexagint0Septuagint0Octogint0Nonagint0Cent".split(0);for(i in a)if(~b.indexOf(a[i]))return"10^"+(20>i?3*i+6:93+30*(i-20))}

Example:
z("Billion") // "10^9"
z("Centillion") // "10^303"

You can remove the zeroes in the string and replace split(0) with match(/[A-Z][a-z]*/g) to use regexes to match each string.

This only handles the "un, doe, tre, etc" prefixes for decillion. It should also handle cases like unvigintillion = 10^66 and novemnonagintillion = 10^300

You can shorten this by using ES6 functions =>.

thanks for the tips. @Remy are you sure? the OP doesn't seem to ask that

Seems clear to me that all multiples of 3 are required: "... this gives values for every 10^3 increment up to 10^63, but then gives them in 10^30 increments, however the pattern is fairly straightforward" in the OP. Also OP gives an example of "sexvigintillion" in a comment.

I thought I had made it pretty clear in my question description - see the "note" part after I give the link - however I will clarify.

C, 235
Handles all 100 cases.
Program uses stdin and stdout.
Who needs regexes for camel-case splitting?
char*Z="UUUi+W<)E(<7-7-++*)('&%$,*$&%$",u[999]="\0MBRilDriPtiNiUnOeReTtUiXTeCtVeCiGRigRaUagInquiXaXsexPtuOgOoNaCeCeK1",s[99],*U=u+67;
main(n){
for(gets(s);*--U;)
*U<95?
*U|=32,
n+=!!strstr(s,U)*(*Z++-35),
*U=0:
3;puts(memset(u+68,48,3*n)-1);
}

Example
octoseptuagintillion
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

This thing doesn't even look like C anymore... I'm amazed.

Why the space (*U<95 ?) and all the newlines?

@tomsmeding The space was an oversight. The newlines make the code "readable" and are not included in the count.

Clojure, 381 377 bytes
(defn c[x](let[l{"M"6"B"9"Tr"12"Quadr"15"Quint"18"Sext"21"Sept"24"Oct"27"Non"30"Dec"33"Undec"36"Doedec"39"Tredec"42"Quattuordec"45"Quindec"48"Sexdec"51"Septendec"54"Octodec"57"Novemdec"60"Vigint"63"Trigint"93"Googol"100"Quadragint"123"Quinquagint"153"Sexagint"183"Septuagint"213"Octogint"243"Nonagint"273"Cent"303}v(l(clojure.string/replace x #"illion$" ""))](Math/pow 10 v)))

Example:
(c "Septuagintillion") ;; 1.0E213

Haskell, 204 bytes (+9 for formatted String)
import Data.List
x s=10^(f$[a|k<-tails s,i<-inits k,(b,a)<-zip["ce","ad","un","do","b","mi","vi","tr","at","ui","x","p","oc","no","ec","g"]$100:4:1:2:2:[1..],b==i])
f[]=3
f(x:11:r)=30*x+f r
f(x:r)=3*x+f r

In GHCi:
*Main> x "decillion"
1000000000000000000000000000000000

Replacing 10^( with "10^"++(show. adds another 9 bytes:
import Data.List
x s="10^"++(show.f$[a|k<-tails s,i<-inits k,(b,a)<-zip["ce","ad","un","do","b","mi","vi","tr","at","ui","x","p","oc","no","ec","g"]$100:4:1:2:2:[1..],b==i])
f[]=3
f(x:11:r)=30*x+f r
f(x:r)=3*x+f r

In GHCi:
*Main> x "decillion"
"10^33"

Edit: I had to correct for "quinquagintillion" which contains "qua".