HQ9+, 2 bytes

QQ

outputs

QQQQ

I think it is not forbidden here.

Python 2.6, 10

print`-.1`

Prints -0.10000000000000001, which is 20 chars.

Note that the string repr shows more precision. print-.1 just gives -.1, and print.1/3 gives 0.0333333333333 for only 13 digits of accuracy.

CJam, -17 bytes

r2e|i8,*

The source code is 8 bytes long and qualifies for the -25 bytes bonus.

Try it online.

How it works

r         Read a token from STDIN.
 2        Push 2.
  e|      Logical OR; keep the token if it's not empty, 2 otherwise.
    i     Cast to integer.
     8,   Push [0 1 2 3 4 5 6 7].
       *  Repeat it the corresponding number of times.

Mathematica, 1 byte

#

Prints #1.

Shakespeare, 768

Yeah, Shakespeare's not much of a golfing language. Outputs 1,536 spaces.

Rosencrantz and Guildenstern: A Series of Tedious Events.

Rosencrantz, a count of extraordinary determination.
Guildenstern, a spacy character.

Act I: The Long Conversation

Scene I: A Tortured Friendship

[Enter Rosencrantz and Guildenstern]

Rosencrantz:
 You are a gentle, noble, valiant, loyal, loving companion.

Guildenstern:
 You are nothing!

Scene II: Asking the Hard Questions

Rosencrantz:
 Speak your mind.

Guildenstern:
 You are as fair as the sum of yourself and a daisy. Are you as
 daring as the sum of a big, bold, fiery, feisty, rough, rowdy,
 ham-fisted, hawk-eyed, broad-shouldered, bright-eyed lad and a
 large, yellow, vicious, hairy, wild, scary, long-tailed,
 sharp-clawed, small-eared lion?

Rosencrantz:
 If not, let us return to scene II.

Recall, 17 bytes

................!

17 NOOPs. Then the debugger ! is invoked and dumps the memory to the console. The memory is empty, but the header is 34 bytes long:

-- STATE DUMP --
----------------

Try it here.

Matlab, 7 bytes

'a':'e'

Output:

The output contains newline ans = newline newline abcde newline, so 14 bytes.

Python 2, 11

print`id`*1

Print the string representation of the built-in id, which is 22 chars:

<built-in function id>

The *1 is to get the code to 11 chars. You could also do print id;00.

More boring alternative 11's are:

print'1'*22
print 9**21

Pyth, -15 -16

-1 by Dennis

**N9?zvz2

Prints [input]*9 quote characters, or 2*9 if the input is empty.

isaacg has a shorter answer here

Pyth, 1 byte

T

Prints 10. It's a built in variable that initializes to 10.

gs2, -18 bytes

CP437: W↕0!↨.2

Hex dump: 57 12 30 21 17 2e 32

W reads numbers from STDIN into a list. ↕0 appends a 2 to the list, and ! extracts the first element. Then ↨. (the list [0,1,2,3,4,5,6]) is repeated (2) this many times.

This is very similar to Dennis's CJam answer -- gs2 just combines r and i into one byte.

Note: I had to fix a bug in the gs2 implementation for this to work: previously, each program had a hidden newline appended to its output, which was entirely unintentional. It only surfaced after I tried to solve this program (the language was designed for anarchy golf, which ignores trailing newlines in all problems), and I only pushed a fix to master just now, so feel free to take this answer with a grain of salt.

dc, 10 - 25 = -15

2?A*Ar^1-n

Takes a blank line for "no input".

Calculates 10 ^ (10 * n) - 1, where n is the input, or 2 if input is empty. Prints a string of 9s of the required length.

• 2 push 2 to the stack in case input is empty
• ? push input to the stack
• A push 10 to the stack (dc has shortcuts A-F for 10 - 15)
• * pop twice and multiply (multiply input by 10)
• A push 10 to the stack
• r reverse top two stack elements
• ^ exponentiate 10 ^ (10 * input)
• 1- subtract 1 from the top of stack
• n print with no newline.

CJam, -9

q_,{i}{;2}?G*'X*

Explanation

• q_,

Reads the entire input and pushes it, then pushes the length.

• {i}{;2}?

If the length of the input is over zero, convert it to an integer. Otherwise, pop the input and push 2.

• G*

Pushes 16 (the program length), then multiplies it by 2 if there is no input, or by the input.

• 'X*

Pushes X and multiplies it by the top of the stack.

C, 27

main(){printf("%0.36f",0);}

prints 0.000000000000000000000000000000000000 which is 38 bytes long.

dc, 19 - 25 = -6

2?19*[1n1-d0<l]dslx

Takes a number (2 is pushed to the stack as backup) and multiplies it by 19. Prints a 1 (no newline) and decrements the number. Loops while the number is greater than 0.

Macaroni 0.0.2, 23 chars

print tobase pow 32 9 2

Prints 32⁹ in binary, which happens to conveniently turn out to be 46 characters long (it's 1000000000000000000000000000000000000000000000), without a trailing newline.

Perl, 27 bytes - 25 = 2

$n=pop||2;print"n"x($n*27);

Thanks to the excellent commentators for their help on this one :)

It produces 27 "n"'s multiplied by $n, which defaults to 2 if @ARGV is undefined.

TI-Basic, 3 bytes

1ᴇ5

Prints 100000.

Julia, 42 bytes - 25 = 17

print("@"^42((r=readline())>""?int(r):2))

This reads a line from STDIN using readline(). If it's empty, i.e. no input has been provided, then n is defined to be the input converted to an integer. Otherwise n is 2. We then print 42​n @s to STDOUT.

JavaScript ES6, 33 - 25 = 8

(a=2)=>Array(a*33).fill(0).join``

><>, 21 + 2 (-v flag) - 25 = -2 bytes

l0=?2f6+*v
-1o;?=0::<

test it here!

Thanks Cole for helping fix my errors

First checks the stack length, if it's 0 put 2 on the stack. Multiplies it by 21 (code length), then outputs the unicode representation of that number and decrements it by 1, loops until 0. (you'll have to inspect the output to see the characters, since the browser won't display them)

q, 10 3 bytes

3#0

Outputs 6 bytes: "0 0 0\n".

Perl, 18 - 25 = -7

print$=x(<>*9||18)

The special variable $=, a.k.a. $FORMAT_LINES_PER_PAGE, begins its life as 60, and therefore only needs to be duplicated half as many times as byte output needed.

JavaScript (ES6), 23 bytes - 25 = -2

(n=2)=>'x'.repeat(23*n)

Just for fun here's a quine version with a score of 27 bytes -25 =2

a=(n=2)=>`a=${a}`.repeat(n)

JavaScript, 4 bytes

~$ cat main.js
+1/0
~$ nodejs main.js
Infinity

I think this is the shortest possible JS solution without ES6 :P

Ruby, 24 - 25 = -1

$><<?x*24*(gets||2).to_i

JavaScript (ES6), 50-25=25

a=prompt();alert("0".repeat(48*(isNaN(a|0)?2:+a)))

Bubblegum, 1 byte

Ä

prints

!#

JavaScript (ES6), 24 30 - 25 = 5 bytes

alert('s'.repeat(30*prompt()))

JavaScript (ES5), 68 bytes - 25 bonus = 43

alert(Array(1+(+prompt()||2)).join(document.scripts[0].textContent))

This script only works in a browser following at least DOM3 (with Node.textContent) and ECMAScript 5 (or perhaps an older version). I tried to make is as standard conforming and compatible as possible. It also assumes that the script is in the first script element of the document.

It actually concatenates multiple copies of the script itself, which is pretty awesome. Note that the snippet tool on SE puts extra whitespace around the script. We could ignore that whitespace with .trim() but I don't find it necessary considering the program is perfect without SE's meddling. Just save this HTML5 file if you want to see it run perfectly.

<!DOCTYPE html>
<html>
  <head>
    <title>Minimalist HTML5 page</title>
    <script>alert(Array(1+(+prompt()||2)).join(document.scripts[0].textContent))</script>
  </head>
</html>

This script uses prompt and alert because console.log is not part of any standard, even if most modern browsers use it. If the number of repetitions passed is not a valid number or is empty, it defaults to 2. If the input is a decimal number, the program crashes due the the invalid array length.

The code uses a few interesting features of JavaScript:

• Array(1+(+prompt()||2))

  • Array(INT) creates an Array of INT cells.

  • +prompt() takes an input and turns it into a number. If we passed the input as a string, the Array function would simply wrap it in a one-element array.

  • +prompt()||2 returns the input if it is truthy, else it returns 2.

  • This whole code creates an array of N empty elements, where N is one more than the amount of repetitions asked.

• .join(document.scripts[0].textContent)

  • The array's join(STRING) method creates a string by concatenating all the cells, putting the provided STRING between values. In this program, there are N+1 empty elements in the array, or exactly N in-between spots. The result will be a string containing N times the provided STRING.

  • document.scripts[o] is the first <script> element of the document.

  • The textContent of Node instances returns the whole text found inside them and their child nodes, including scripts.

Ruby, 6 bytes

p ?a*9

Prints "aaaaaaaaa" (including the quotes) and a newline.