text:
Print the lyrics to Caius' Theme (Final Fantasy XIII-2)
Print or return these lyrics:
Dea Mortis, iuravi
Carissimam servaturum.
Dea Mortis, servabo
Ut tempora recte ducam.

Etsi cor in Chaos,
Aut Fortuna bella ferat,
Occurram et obviam ibo.

The line break must be preserved, and trailing newlines are allowed.
+20% if you omit the end-of-line punctuation, +30% if you omit all punctuation, +20% if you change any capitalization, -40% if you also print the English translation right after the normal lyrics, separated by a blank line:
Goddess of Death, I vowed
That I would protect the most dear one.
Goddess of Death, I will protect her,
As I lead time straight.

Even if there is a heart in Chaos,
Or if Fortune may bring wars,
I will resist and go to fight against it.

If you print just the English version, add +30%.
And the actual song on YouTube.
Code-golf, so fewest bytes win.

Can we have a +30% if we only print the english?

And does it have to be capitalized correctly?

I don't see anything that makes this different from existing text compression challenges. The text has little structure.

@CONORO'BRIEN I updated the question.

@xnor It's Final Fantasy, and it sounds creepy. :D

"Creepy" and "Final Fantasy" doesn't make a basic text compression task appreciably distinct from another.

TeaScript, 123 + 1 = 124 bytes 142
+1 byte for "Safely handle unicode" checkbox
Ld`Dea MÆ³s, i¨avi
Càmm  rvÂxum.
Dea MÆ³s,  rva¾
Ut ÛZa c Ýóm.

Et£ ¬r  Cos,
A© FÆ·na Þ)a fÀ,
Occ¨m et obviam i¾.`

Try this in the interpreter. Make sure to check "Safely handle unicode" under options.
Pastebin because StackExchange messed up the special characters.
The compression algorithm used encodes similar items in the text rather than a simple base encoding. The general code is pretty simple though:

dammit noooooooo

@quartata >:D .

Bubblegum, 116 bytes
00000000: 4d 4d b5 19 82 41 0c ed 33 c5 eb 91 19 f0 0a a9  MM...A..3.......
00000010: 18 20 77 fc 2e e1 8b dc fa 58 45 95 3c 3f 54 8c  . w......XE.<?T.
00000020: 8b a8 77 b6 44 17 ca a5 a3 3d 6b 67 d6 4d 3c c1  ..w.D....=kg.M<.
00000030: 2a 2d ec a1 31 ad e9 df f9 e3 93 d0 dd e1 d5 f4  *-..1...........
00000040: 14 65 68 95 bd c2 23 32 7f bc 74 74 eb 90 45 d1  .eh...#2..tt..E.
00000050: cd d8 b7 2c b6 a4 6d 38 4e 9f 7c cc 8c 54 8d 23  ...,..m8N.|..T.#
00000060: a3 ae 94 7d 49 b7 9c 43 f5 b3 56 39 24 95 ee f3  ...}I..C..V9$...
00000070: 75 49 d6 6f                                      uI.o

The above is a hexdump, which can be reversed with xxd -r.
I used zopfli for compression, which uses the DEFLATE format, but achieves a better compression ratio than gzip and zlib.

JavaScript (ES6), 252 bytes
btoa`
æ2íÅÖêÚ¾&j¸¬²)k®öº»¦eÞic(®Ø¬]k®ö¡-Z×¦¦ÚZ·µå¹Æ¦e¶ÈrÖuª,].µah®Û§ifÞV}êÚµvqË«©zÕ¨nøh¡`.replace(/[W-Z=]/g,c=>` ,
.`["WXYZ".search(c)]||"")

Note the first newline is a carriage return.
Hexdump:
00000000: 6274 6f61 600d c3a6 c296 32c2 8ac3 adc2  btoa`.....2.....
00000010: 8ac3 85c3 96c2 8ac3 aac3 9ac2 be26 026a  .............&.j
00000020: c2b8 c2ac c2b2 29c2 9ac2 996b 1ec2 aec3  ......)....k....
00000030: b6c2 adc2 bac2 bbc2 a665 c280 c39e 6963  .........e....ic
00000040: 28c2 aec3 98c2 ac5d 6b1e c2ae c3b6 c29b  (......]k.......
00000050: c2a1 c285 2d5a c397 c2a6 c2a6 c28a c39a  ....-Z..........
00000060: 5ac2 b7c2 9cc2 b5c3 a5c2 9dc2 b9c3 86c2  Z...............
00000070: a665 c286 04c2 b6c3 88c2 9672 c28a c396  .e.........r....
00000080: c28a 75c2 82c2 85c2 aa2c 5dc2 802e c2b5  ..u......,].....
00000090: 6168 c2ae c39b c2a7 6966 c39e c296 56c2  ah......if....V.
000000a0: 967d c3aa c39a c2b5 760e 71c3 8bc2 abc2  .}......v.q.....
000000b0: adc2 a9c2 967a c395 c2a8 6ec3 b8c2 9ac2  .....z....n.....
000000c0: 9968 c29b c2a1 c296 602e 7265 706c 6163  .h......`.replac
000000d0: 6528 2f5b 572d 5a3d 5d2f 672c 633d 3e60  e(/[W-Z=]/g,c=>`
000000e0: 202c 0a2e 605b 2257 5859 5a22 2e73 6561   ,..`["WXYZ".sea
000000f0: 7263 6828 6329 5d7c 7c22 2229            rch(c)]||"")

Edit: I found out that pasting into Firefox console changes carriage returns into line feeds. (Face-palm) Here is a whitespace safe version for two more bytes:
btoa`\ræ2íÅÖêÚ¾&j¸¬²)k®öº»¦eÞic(®Ø¬]k®ö¡-Z×¦¦ÚZ·µå¹Æ¦e¶ÈrÖuª,].µah®Û§ifÞV}êÚµvqË«©zÕ¨nøh¡`.replace(/[W-Z=]/g,c=>` ,\n.`["WXYZ".search(c)]||"")

Ran the Base-64 encoded version in firefox and the output seems to be wrong.

@Vɪʜᴀɴ Fixed. Apparently when I pasted the string into the console to Base-64 encode it, Firefox changed the carriage return into a new line and I didn't notice the difference. Escaping it fixed the problem.

+1 One does not simply eÞic in Base64.

Stuck, 128 bytes
So riddled with unprintables I'm not going to even post the raw source code. Here's the hexdump instead:
0000000: 2278 da4d 8d41 0ec2 300c 04ef 79c5 3e20  "x.M.A..0...y.>
0000010: ea1f 500b 37c4 8907 38a9 1196 9a1a 3976  ..P.7...8.....9v
0000020: de4f c489 db68 35ab d998 7057 73e9 1912  .O...h5...pWs...
0000030: 4643 d24a 26bd 4ba3 86ce 36c8 c3a2 2d69  FC.J&.K...6...-i
0000040: fb33 7f7b d1f4 7438 b78f 1ac1 b83a 638f  .3.{..t8.....:c.
0000050: 4ad3 4d57 ef82 aa06 39b1 be49 7b4e 9770  J.MW....9..I{N.p
0000060: dce6 3f4e 42e1 e320 bcd8 c873 7ad4 1a66  ..?NB.. ...sz..f
0000070: b3c6 0e2d 4326 49d1 e50b 7fc1 35fe 2244  ...-C&I.....5."D

Chaîne, 154 148 bytes
(Linked interpreter currently only works properly on Firefox)
Dea Mortis, {<~}iuravi
Carissimam servaturum.
{}servabo
Ut tempora recte ducam.

Etsi cor in Chaos,
Aut Fortuna bella ferat,
Occurram et obviam ibo.

Doing the bonus doesn't grant me anything extra (229.2 bytes):
Dea Mortis, iuravi
Carissimam servaturum.
Dea Mortis, servabo
Ut tempora recte ducam.

Etsi cor in Chaos,
Aut Fortuna bella ferat,
Occurram et obviam ibo.

Goddess of Death, I :/E@:
That I :/eY: :*uk: the most dear one.
Goddess of Death, I will :*uk: her,
As I lead time :-Ep:.

Even if :.&L: is a heart in Chaos,
Or if :%u?: may bring wars,
I will :+XU: and to go to fight :5$: it.

"Dea Mortis," occurs twice. Is there not even a way to compress that in Chaine? BTW, I couldn't run the code at that link. Is Chaine your own language? if so you should really include some documentation in an easy to access place (webpage, not downloadable) so people can get a feel for the syntax and see if they like it.

@steveverrill Chaine only works on FireFox, due to a weird parsing error that is not fixed yet. There is documentation on the github, if you looked for it. ALSO I was working on golfing it, was kind of busy.

OK, +2 for writing your own language, but -1 for not saying at the beginning that it only works on firefox. So that's a total of +1. User Experience counts. Found the documentation now. After a couple of failed attempts to run your code, User gave up and wasn't going to click anything else to try to find the documentation.

@steveverrill Sorry about your inconvenience. I am striving on browser equality, but I haven't found the time. (I'm so ADD, am working on three different languages ;-; once I've finished what I'm working on in it, I'm going to let it lie for a bit.)


text:
Proto space invaders (can you blit it?)
Proto space invaders
This is a graphical output challenge where the task is to give the shortest code per language.
Task
Your code should allow the user to move the following alien around the screen/window.

Your code can simply load it from a local file.  Feel free to convert it to another standard image format or even to fix the small pixel errors in the image that were pointed out in the comments.
The background should be white and the window/screen must be at least 400 pixels by 400 pixels.  If your language doesn't support windows/screens that large then use the largest size it does support as long as that is not less than 200 by 200.
To move the alien around the screen the code should support up/down/left/right using the arrows keys on a standard keyboard.
Your code should be a full program.
Restrictions/constraints
The alien should stop at the borders.  It should also move at a uniform rate smoothly with no visible flickering or stuttering and be shown at at least 24fps. It should take between 2 and 5 seconds to go from one side of the screen/window to the other.
Languages and libraries
You can use any language or library you like (that wasn't designed for this challenge). However, I would like to be able to test your code if possible so if you can provide clear instructions for how to run it in Ubuntu that would be very much appreciated.
Catalog
The Stack Snippet at the bottom of this post generates the catalog from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

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

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

Can we construct the alien ourselves? If so, do we have to include the pixel errors (i guess?) from the picture?

@mınxomaτ It isn't limited to linux! Note "if possible".

@nimi Thanks. Added that you can load it from a local file.

@mınxomaτ You can construct it yourself or just load it  from a local file.  I hadn't noticed the pixel errors but I assume that loading it will be less code in any case.

Can you define "stop at the borders"? Does the entire alien need to be visible at all times, or can it stop partially outside the border?

The whole alien should be visible at all times.

@timothymh I am not sure I understand the question but I think the answer is no. The alien should move as in the python solution below, if that helps.  That is it should move while a key is pressed and stop as soon as it is released.

@ThomasKwa I am afraid the answer is no. I have been told I need to be strict with my rules. 24fps is the minimum.

Can it be ASCII art if I choose a programming language without a platform-independent graphical API?

@PeterLenkefi No! :)  That's a different challenge.

Is it acceptable to convert the image to a different format (such as GIF)?

@Moose Yes it is. You can even fix the small pixels errors that were pointed out in the image.

Scratch, 221 217 bytes

Click the image to view it in action. The movement is determined by keystrokes, so it will be smoother the faster your key repeat is set.
The image is included within the project, but Scratch bytes are usually counted from the golfed textual representation, per this meta post. If there is disagreement as to whether this is acceptable (or whether the movement is smooth enough) let me know and I will try to work around it.

This answer is a lot of fun!

How did you measure the size of this program?

@Lembik see the second paragraph.

generates in 217 bytes: http://scratchblocks.github.io/#when%5Bup%20arrow%20v%5Dkey%20pressed%0Achange%20y%20by(9%0Awhen%5Bleft%20arrow%20v%5Dkey%20pressed%0Achange%20x%20by(-9%0Awhen%5Bany%20v%5Dkey%20pressed%0Aif%20on%20edge%20bounce%0Awhen%5Bdown%20arrow%20v%5Dkey%20pressed%0Achange%20y%20by(-9%0Awhen%5Bright%20arrow%20v%5Dkey%20pressed%0Achange%20x%20by(9

@ev3commander Good catch, thanks — I accidentally pasted the wrong version!

Does the alien stop at the borders of the window?

@Mauris Yes, that's what the "if on edge, bounce" command takes care of. You can play the demo by clicking on the image!

Ah, I see. ^^ Scratch appears to be down for maintenance, so I figured I'd ask.

Ah, I just posted a Scratch A to another Q. I had no idea how to count, I'll have to fix that

Processing 2, 219 199 241 220 219 bytes
int a,x=0,y=0;void setup(){size(500,500);}void draw(){background(-1);image(loadImage(".png"),x,y);if(keyPressed){a=keyCode;if(a==38)y--;if(a==37)x--;if(a==40)y++;if(a==39)x++;}x=constrain(x,0,436);y=constrain(y,0,454);}

Requires the image saved as .png in the same directory as the .pde

Python 2, 262 253 246 240 bytes
from pygame import*
init()
key.set_repeat(1)
p=[0,0]
d=display
c=d.set_mode((400,)*2)
while c.fill((255,)*3):
 e=event.get(2);c.blit(image.load("I"),p);d.flip()
 if e:x=e[0].key+1;q=x&2;b=q/2;p[b]=max(0,min(336+b*16,p[b]+(1-q)*(1-(2*x&2))))

Wow. What a lot of hackery.
Uses the module 'pygame' found at http://pygame.org.
Explanation
key.set_repeat(1) - Send repeat key events through the event system every millisecond
c=d.set_mode((400,)*2) - Create the 400x400 display surface
while c.fill((255,)*3): - Effectively while 1: but clears the screen as well
e=event.get(2);c.blit(image.load("I"),p);d.flip() - Only collect keyboard events, load the image stored in a png file called I and draw it. Update the screen
if e:x=e[0].key+1;q=x&2;b=q/2;p[b]=max(0,min(336+b*16,p[b]+(1-q)*(1-(2*x&2)))) - If there was an event, work out which arrow key was pressed (does weird stuff if you press other keys), and then change the position of the surface depending on which key you pressed.

I really like your solution.

@Lembik So a single byte file name is allowed? (I.e. without extension?). If so, I suggest to exclude filenames completely from the byte count.

@mınxomaτ I single byte file name is allowed but I don't want to invent a new scoring scheme.

@Lembik Processing can't handle single-byte filenames... so this is unfair.

@TheDoctor This just in: Different languages are different! I propose we also disallow challenges that take input from stdin, you know, because it's unfair that it takes so many characters to do that in Python...

Haskell, 410 bytes
import Graphics.Gloss
import Graphics.Gloss.Interface.Pure.Game
main=do b<-loadBMP"b";play(InWindow""(400,400)(0,0))white 200((0,0),id)(b#)e(%)
e(EventKey(SpecialKey k)Down _ _)(c,_)|k==KeyUp=(c,fmap(+1))|k==KeyDown=(c,fmap(+(-1)))|k==KeyLeft=(c,((+(-1))?))|k==KeyRight=(c,((+1)?))
e(EventKey _ Up _ _)(c,_)=(c,id)
e _ w=w
_%(c,f)=(s?(s<$>f c),f)
s=min 200.max(-200)
b#((x,y),_)=Translate x y b
f?(a,b)=(f a,b)

The picture of the alien is expected in a file named b in .bmp format.
I'm new to the Gloss library, so maybe this is not optimal. Does anyone know if I can check if a key is pressed instead of tracking KeyUp/KeyDown events?
How it works: the last four parameters of play are the world state (initialized with ((0,0),id), a function to draw a picture from a state (#), an event handler (e) and a function that changes the state over time (%).
The state is a pair of x-y-coordinates and a function how to change them whenever % is called.
# moves the bitmap (b) to the current coordinates and draw it.
e looks for either KeyDown events of the cursor keys and sets appropriate functions in the state or for KeyUp of any key to reset the function in the state to the identity function.
% applies the function from the state to the current coordinates and checks the boundaries.

I am always amazed you can even do this sort of thing in Haskell. Thank you!

Elm, 240 bytes
import Graphics.Element as G
import Keyboard as K
import Time
import Signal exposing(..)
c=min 800>>max 64
i(x,y)=G.container x y G.middle(G.image 64 48"https://i.stack.imgur.com/CUweU.png")
main=i<~foldp(\{x,y}(v,w)->(c v+x,c w-y))(99,99)(sampleOn(Time.fps 200)K.arrows)

Try it here. Byte count is after replacing the URL with .png.

I might have to learn Elm now. Thank you.

AutoIt, 269 267 bytes
#include<Misc.au3>
GUICreate(0,-1,-1,-1,-1,-1,34078728)
$0=GUICtrlCreatePic("b.bmp",0,0,64,48)
GUISetState()
Dim $1,$2
$3=_IsPressed
Do
$1+=$3("27")-$3("25")
$2+=$3("28")-$3("26")
$1=($1>336)?336:($1<0)?0:$1
$2=($2>352)?352:($2<0)?0:$2
GUICtrlSetPos($0,$1,$2)
Until 0

Requires the picture to be saved as b.bmp in the script directory. If you want to use a picture with actual transparency, you have to to convert it from PNG to a 32bit Bitmap (OT: a really unappreciated format).
Explanation
We need to import Misc.au3 to get access to _IsPressed. A function that accepts a key code and returns True or False when the key is pressed.
The spec of the challenge is quite cool in the way that we have to create a 400px square window. The default (denoted as -1 or Default) size parameters are 400x400. The extended windows style is set to 34078728. This forces the window to be double-buffered and drawn from bottom to top. This is necessary to eliminate flickering as per the challenge requirement. In Windows 10, this unusual (and somewhat undocumented) combination of styles breaks the window title bar (all hovering effects are disabled).
$1 and $2 are declared and will hold the x and y offset of the picture loaded by the control $0. $3 becomes a pointer to the function _IsPressed to shorten the code significantly.
Since it is not required to be able to exit the program, this script runs in an infinite loop (Until 0).
$1+=$3("27")-$3("25") abuses the variant datatype in AutoIt by dynamically casting the boolean value returned from _IsPressed to an integer that can be added or sub'ed from the x offset. Same for y. $1=($1>336)?336:($1<0)?0:$1 uses the ternary operator known from C-like languages to perform a bounds check to stop the alien at the borders.
GuiCtrlSetPos moves the picture control to the new coordinates.
Here's a screenshot with a transparent alien (you can even move diagonally):

Your background is not white!

SpecBAS - 285 255 bytes
1 GRAPHIC NEW v LOAD "inv8.bmp" TRANSPARENT 15
2 PALETTE COPY v,0,1 TO 5: GRAPHIC REMAP v
3 LET x,y=100
4 CLS : WINDOW PUT GRAPHIC v,0,x,y
5 LET x=x+KEYST(39)-KEYST(37),y=y+KEYST(40)-KEYST(38)
6 LET x=CLAMP(x,1 TO 400),y=CLAMP(y,1 TO 400)
7 WAIT SCREEN
8 GO TO 4

Loads the image - colour 15 is bright white, so that becomes transparent.
Using the original image and default SpecBAS palette made it come out a bit odd, so line 2 switches them around to match the input image. Below image shows how it looks without line 2 and after.

The CLAMP command limits the graphic between 1 and 400 in both directions, saves on several IF...THEN statements.
Line 9 just waits for things to catch up and prevents flickering.
It moves one pixel at a time based on a boolean check of which key is pressed, so takes slightly longer than 5 seconds to go from side to side.

Ruby with Shoes, 252 243 characters
Shoes.app{background white
i=image'i'
m=[0,0]
a=[:width,:height]
animate(99){i.left+=m[0]<=>i.left
i.top+=m[1]<=>i.top}
keypress{|k|d,v={?u=>[1,-1],?d=>[1,1],?l=>[0,-1],?r=>[0,1]}[k[0]];m[d]=[[m[d]+v*4,self.send(p=a[d])-i.send(p)].min,0].max}}

This uses a resizable window starting at default 600 x 500. If you resize the window so the invader is left out, will come back when the next movement key is pressed.
The trick to satisfy the requirements is that invader's position is changed in increments of 4, but the actual movement is made with increment of 1 at 99 frames per second.

Lua + LÖVE, 291 characters
x=0
y=0
l=love
g=l.graphics
l.window.setMode(400,400)
i=g.newImage("i")
function l.update()d=l.keyboard.isDown
if d("left")and x>0 then x=x-1 end
if d("right")and x<336 then x=x+1 end
if d("up")and y>0 then y=y-1 end
if d("down")and y<352 then y=y+1 end
end
function l.draw()g.draw(i,x,y)end

This uses an unresizable 400 x 400 window. I had no success with adjusting love.keyboard.setKeyRepeat() to speed up the key reading, so I did the recommended way, polling each key's status.
As my relation with Lua for is not the best, neither this time managed to make looping shorter than the dump hardcoding of each key's condition.

Tcl/Tk, 242 bytes
grid [canvas .c -w 400 -he 403 -bg #FFF -highlightt 0]
.c cr i 30 24 -i [image c photo -fi .png] -t p
lmap {k b x y} "Up 1]>25 0 -5 Right 0]<368 5 0 Down 1]<376 0 5 Left 0]>30 -5 0" {bind . <$k> "if \[lindex \[.c coo p] $b {.c move p $x $y}"}

To run it in any Linux: you must have Tcl and Tk installed; then copy the code to a file, let's say invaders.tcl; you need also to have the image saved as .png in the same folder. To run the script type wish invaders.tcl  in a shell. PS : It can be more golfed if code is instead pasted into an interactive shell, as it supports by default abbreviated commands.

JavaScript (using paper.js), 215 bytes
v=new Raster("https://i.stack.imgur.com/CUweU.png",99,99);p=new Size(4,0)
onFrame=e=>{if(!v.isInside(view.bounds)){p=-p};v.position+=p}
onKeyDown=e=>{p=new Size([[0,-4],[0,4],[-4,0],[4,0]]["udlr".indexOf(e.key[0])])}

paper.js is a JS graphics framework, which means it features many useful features regarding image manipulation. To run, just copy the above into the section on the left here, then, to move the alien around, click once in the right section to give it focus. If your browser can handle it, it should run at 60fps.

source: Stack Exchange

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

sort: votes


text:
Avoid repeating letters between five simple programs
Your challenge is to write 5 different full programs for the 5 following tasks:

Print Hello, World!.
Given an input on STDIN, output the factorial (you can assume that the input is an integer ≥ 0).
Given an integer N, calculate the sum of the primes ≤ N.
Given an input on STDIN, output the letters used in the input.
For example: the input is Hello world, you need to output helowrd.
Note that the output is in lowercase.
You can assume that the input is always alphabetic with white spaces, the white spaces are ignored.
Output the following diamond exactly like this:
   *
  ***
 *****
*******
 *****
  ***
   *

All these challenges are probably very easy, but there is a catch.
Every letter you use cannot be used again in the other programs.
This is not prohibited, but will give you a penalty of +8 bytes.
For example, if this is your program for the first task:
print("Hello, World!");

Then you cannot use the following letters (in uppercase or lowercase form): p, r, i, n, t, h, e, l, o, w, d in the other programs.
If you do have to use them, you can “buy” each letter for 8 bytes.
So if you want to use the letter l again in another program, you receive a penalty of 8 bytes.
After you have paid the penalty, you can use each letter as many times as you want in this program.
Other characters don’t matter.
Also, all 5 programs should be in the same language.
This is a code-challenge, least amount of bytes wins!

This is a slightly different spin on challenges we've already had, but not different enough for it to not to be a multi-dupe in my eyes.

Does 8 bytes permit you to use a given letter as much as you like in the next program?

@Mego I'd vote to close this as a multi-duplicate without the restriction, but the restriction makes it a whole new game.

If you use a given letter in 3 programs, do you pay the 8 byte penalty twice (16 bytes)?

@trichoplax, yes you pay 16 bytes

@trichoplax Hardly. The existing solutions for the duped problems will still be competitive. The top solutions here will just be the concatenation of the duped questions' solutions, with a higher score from the penalty.

In TI-BASIC, there are tokens that display using certain letters (for example, sin( displays like sin(. However, they are not stored in memory that way (its token code is C2). Can we repeat the letters displayed without penalty?

Are we allowed to have trailing spaces on the lines of Task 5?

@ThomasKwa, the displayed letters don't matter, only the code matters. Also, trailing whitespaces are not allowed in task 5.

@Mego although the existing solutions will be competitive at first, I would expect variations tailored to the new restriction to win eventually. I can't tell in advance though.

There just aren't enough versions of Print...

CJam, 73 bytes
"Obkkh+'Phukc&"7f^
q~m!
ri){'j3+_3++~},:+
lS-el_&
4{_' *4@-Y*('**+}%_1>W%\+N*

Each line is a full program. Try them online: 1 | 2 | 3 | 4 | 5
Letter map
 bc  f h  k   op    u       18
            m   q            4
        ij       r          17
    e      l      s          7
             n        w y   27

If you want (and each of your programs fits in a line), you can use this CJam program to create a letter map for your own submission.

Proof that osascript wasn't built for this: Your entire submission is less than 2 of my programs. XD +1, nice job.

Pyth, 90 bytes
First attempt...
Task 1: 20 bytes
+"Hello, "+C87"orld!

Task 2, 3 bytes
.!Q

Task 3, 9 bytes
sf}TPTSvz

Task 4, 6+8=14 bytes
@G{rw0

Task 5, 44 bytes
"   *
  ***
 *****
*******
 *****
  ***
   *

osascript, 759 Bytes
I knew this was going to be a lot when I started. o-o
Task 1: 15 Bytes
"Hello, World!"
I knew that it was going to be bad from this point.
Task 2: 64 + 8*4 = 96 Bytes
on run a
set o to 1
repeat a
set o to a*o
set a to a-1
end
o
end
Oh gawd.
Task 3: 170 + 8*13 = 274 Bytes
on run a
set o to 0
set t to false
repeat with i from 2 to a
set t to true
repeat with c from 2 to i-1
if i mod c=0 then set t to false
end
if t then set o to o+i
end
end
Dennis ≠ outgolfed.
Task 4: 225 + 8*13 = 329
on run a
set o to""
repeat with i in items of a
repeat with c in characters of i
if c is not in o then
if ASCII number of c<91 then
set o to o&(ASCII character of(ASCII number of c+32))
else
set o to o&c
end
end
end
end
o
end
...
Task 5: 45 Bytes
"   *
  ***
 *****
*******
 *****
  ***
   *"
So, yeah. I knew I was gonna lose from the start. But it was interesting, I'd be interested to know if there's a way to do this in fewer characters. Character map (as provided by Dennis):
   de  h   l  o  r    w     15
a cdef hi  lmnop rstu w    160
a  de        nop rstu       57
abcdef hi  lmnop rstu w    214
                            39
                             0
The character count above is slightly off - newlines made it have issues, as the newlines were uncounted.
NOTE: The reason for not using stuff like a's characters or the like is that the ' character has to be used when executing from the osascript command line. If I had used ', I'd have to use \' or something similar, which wouldn't have helped me at all. Also, it only recognizes " as string capturers, so I was kinda screwed there as well. But that was fun.

Itr, 83 bytes, no characters repeated between programs
The five programs separated by newlines:
"Olssv'^vysk("7-

P

µf«äµL1=×S

32|ÍÌM64á<F¥

»   *
  ***
 *****
*******
 *****
  ***
   *

online interpreter:
1
2
3
4
5
The letters in problem 4 are printed in alphabetical order instead of the order they appear in, I did not find any rule against that
Explanation
"Olssv'^vysk("7- ; Hello World! shifted by 7 to avoid space

P ; product over the 1-based range to the input

µf«äµL1=×S
µf«         ; replace the numbers in the range 1 : input with their prime-factorisation
   äµL1=×   ; only keep the elements with a length of one
         S  ; sum up the array

; assumes that the input consists of ASCII letters and white-spaces
32|ÍÌM64á<F¥
32|          ; or with 32 -> converts uppercase ascii to lowercase
   ÍÌ        ; get a list of all unique elements
     M64á<F¥ ; print the elements that are larger that 64 (filters out white spaces)
     M       ; for all elements
      64á<   ; is the the number greater than 64
          F  ; repeat that many times
           ¥ ; print

; string-literal containing the required output
; all possibilities to loop are used up by the previous answers
»   *
  ***
 *****
*******
 *****
  ***
   *

NARS2000 APL, 144 bytes (85 characters)
Task 1, 21 bytes (17 characters)
⎕←"Hello, World!"

Task 2, 10 bytes (4 characters)
⎕←!⎕

Task 3, 22 bytes (11 characters)
⎕←+/¯2π⍳2π⎕

Task 4, 53 bytes (29 characters)
⎕←∪Q[26∣Q⍸⍞∩Q←⎕AV[97+⍳26]∪⎕A]

Task 5, 38 bytes (24 characters)
⎕←" *"[1+4<∘.+⍨(⍳3),⊖⍳4]

Are those actually full programs? I don't know NARS2000 (and it's not available on my platform), but all dialects I know require assigning to ⎕ to print outside a REPL.

@Dennis Sorry, forgot I was fiddling inside the REPL.

You're not allowed to output trailing spaces for the diamond.

Jelly, 46 bytes (non-competing)
“3ḅaė;œ»
Ɠ!
ÆRS
ɠQḲŒl
4Ḷ¤‘+¤ṖṚṭ×”*Fµ4Ḷṭ4ḶṚṖ¤F×⁶+⁸Y

Try it online! (Copy/paste each snippet)
Apparently, the restriction did not restrict golfing :) Just suggestions for the last one, of course, please.

Ruby -rprime, 398 bytes
I don't know why I decided to try this.
-rprime flag loads the Prime library for task 3. As per the meta post on program flags, adding flags treats it as a "different language", so I can't add -n or -p for some tasks and remove it for others, even if it would save bytes. (Tasks 1 and 5 take no input, and no input means programs with those flags won't run, which is why they can't be used.)
Task 1, 47 bytes
Backslash-escaped almost every letter to free letters up for usage in later tasks. $> is an alias for STDOUT, which will be used later.
$><<"H\x65\154\154\x6f\54\40W\x6f\x72\154\x64!"

Attempt This Online!
Task 2, 31 bytes
3+9+~9 == 2 to avoid reusing 2.
p((3+9+~9..gets.to_i).inject:*)

Attempt This Online!
Task 3, 28 bytes + 56 (().ceis) = 84
Since this is the only task that doesn't say to take input from STDIN, this one is a lambda instead so I don't need to take a huge penalty from doing things with gets.to_i or something similar. This is probably the only time where lambda saves bytes over its stabby syntax ->, which has to buy back > and uses up the - needed in Task 4.
lambda{|e|Prime.each(e).sum}

Attempt This Online!
Task 4, 67 bytes + 96 (*.<achinrstu) = 163
This one had wayyyyyy too much overlap but it was needed to do the given task. Uses t,=*STDIN to get the line of input, assuming newlines won't be present. Let me know if that's an incorrect assumption.
t,=*STDIN;t=t.tr'A-Z','a-z';t=t.tr'^a-z','';STDOUT<<t.chars.uniq*''

Attempt This Online!
Task 5, 53 bytes + 20 ($*<>) = 73
Buys back virtually every character in the program, since it's still cheaper than any alternative I could think of. Uses heredoc syntax for the string since we no longer have ' or " and we're buying back < anyways since it's cheaper than buying back puts.
$><<<<Q
   *
  ***
 *****
*******
 *****
  ***
   *
Q

Attempt This Online!

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

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


text:
Sort this, quick!
Well... there are 59 (now 60) questions tagged sorting, but no simple quicksorts.
That must be fixed.
For those unfamiliar with quicksort, here is a breakdown, courtesy of Wikipedia-

Pick an element, called a pivot, from the array.
Reorder the array so that all elements with values less than the pivot come before the pivot, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partition operation.
Recursively apply the above steps to the sub-array of elements with smaller values and separately to the sub-array of elements with greater values.

Rules
The rules are simple:

Implement a numerical quicksort in the programming language of your choice.
The pivot should be chosen at random or with median of three (1st, last, and middle element).
Your program can be a complete program or function.
You can get the input using STDIN, command line args, or function parameters. If using a string input, the input is space separated.
The input may contain decimal and negative values. However, there will be no duplicates.
You may output to STDOUT or by returning from the function.
No built-in sorting (or sorting related) functions or standard loopholes.
The list may be an arbitrary length.

Bonus #1: On lists or sub-lists of length <= 5, use insertion sort to speed things up a bit. Reward: -15%.
Bonus #2: If your language supports concurrency, sort the list in parallel. If you are using an insertion sort on sub-lists, the final insertion sort doesn't need to be in parallel. Built in thread pools/ thread scheduling are allowed. Reward: -15%.
Note: Median of three was confusing some people, so here is an explanation, courtesy of (again) Wikipedia:

choosing the median of the first, middle and last element of the partition for the pivot

Scoring
This is code-golf. Base score is in bytes. If you got one bonus, take 15% off that number. If you got both, take 30% off. That really sounds like a sales pitch.
This isn't about finding the shortest answer overall, but rather the shortest in each language.
And now, a shameless copy of the leaderboard snippet.
The Leaderboard
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 62476; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 41505; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+(?:.\d+)?)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];

  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });

    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });

  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery(''+lang+'').text();

    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

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

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

"No built-ins" - define "built-in" for this purpose, please. As-is, I don't know how one would select a random pivot.

Also, how do you choose a pivot at random in a language with no RNG? (E.g. BF)

@TLW clarified built-ins; a rng is fine. If there isn't a rng the median of three is fine. Though if someone can golf this to under 700 bytes (with median of three), I'll give them a bounty.

Thanks. I was (mainly) joking about BF, though. Among other things, quicksort in BF should really be named "slowsort" (although that's a different sort already), due to the whole NUMA thing (namely, that you can only move one space per step, and can only "carry" a finite amount of information). It's the same problem as with single-tape Turing Machines... I do not believe there is a way to reverse an array in BF (or a single-tape TM) in under O(n^2) time.

I'm noticing that quite a few of the codes are working just a little too literally, and it hasn't been clarified, yet - can the lists include repeated entries? That is, can you input [1,5,3,5,9,2,6], and should it output [1,2,3,5,6,9] or [1,2,3,5,5,6,9]? A literal reading of the rules makes it the former.

@GlenO Made it a bit clearer. The input won't contain duplicates, so this situation shouldn't arise.

"The pivot should be chosen at random or with median of three (1st, last, and middle element)." What does this mean? You previously said only one element is chosen.

In step 3, "concatenate", what order are we supposed to concatenate them in? Wouldn't choosing such an order itself require a sorting function?

@msh210 All it means is to join the sub-lists together. For median of three, take a look at the wikipedia article for quicksort (Algorithm>Implementation issues > Choice of pivot). All it is is a way to choose a pivot so that the algorithm doesn't take quadratic time on sorted lists. I mainly added it so that languages without rng support could participate.

@msh210 I updated the post with better definitions

The leaderboard snippet doesn't work with decimals. I led me to believe that there was a 3 bytes solution :/

@daniero Snippet is fixed now

@msh210 ...there is a WP link (look near top)

Is the median choice algorithm a hard requirement? It is impractical (as in, it tanks the performance) in languages that use a linked list as their primary array type (Haskell, LISP) and there is already at least one answer that ignores the rule.

@JanDvorak "The pivot should be chosen at random or by median of three". The med of three is mostly for langs that don't have a built in rng. I'll clarify that a bit more when I have cpu access

Both random pivot and median of three are problematic in list-based languages. Both require random access into the array and accessing the end of a linked list is O(n). Taking Taking the median of the first three elements doesn't quite do the same kind of job (also because you'll grab the same pivot within three splits anyways) and only complicates the code for no good reason.

Random pivot is problematic in Haskell for another reason, too - once you start rolling dice, you're no longer writing a function. You're defining an I/O action that produces an array. You could define a function that takes a RNG state as an argument, but it isn't too great either.

C++, 440.3 405 388 bytes
518 bytes - 15% bonus for insertion sort = 440.3 bytes
477 bytes - 15% bonus for insertion sort = 405.45 bytes
474 bytes - 15% bonus for insertion sort = 402.9 bytes
456 bytes - 15% bonus for insertion sort = 387.6 bytes

Thanks to @Luke for saving 3 bytes (2 really).
Thanks to @Dúthomhas for saving 18 (15 really) bytes.
Note that I am new here and this is my first post.
This is a .h (header) file.
Compressed Code:
#include<iostream>
#include<ctime>
#include<cstdlib>
void s(int a[],int i,int j){int t=a[i];a[i]=a[j];a[j]=t;}int z(int a[],int b,int e){int p=a[(rand()%(e-b+1))+b];b--;while(b<e){do{b++;}while(a[b]
p);if(b<e){s(a, b, e)}}return b;}void q(int a[],int b,int e){if(e-b<=5){for(int i=b;i<e;i++){for(int j=i;j>0;j--){if(a[j]<a[j-1]){s(a,j,j-1);}else{break;}}}return;}int x=z(a,b,e);q(a,b,x);q(a,x,e);}void q(int a[],int l){q(a,0,l);}

Full Code:
#include <iostream>
#include <ctime>
#include <cstdlib>

void swapElements(int toSort[], int i, int j) {
    int temp = toSort[i];
    toSort[i] = toSort[j];
    toSort[j] = temp;
}

int partitionElements(int toSort[], int beginPtr, int endPtr)
{
    int pivot = toSort[(rand() % endPtr - beginPtr + 1) + beginPtr];
    beginPtr--;
    while (beginPtr < endPtr) {
        do {
            beginPtr++;
        } while (toSort[beginPtr] < pivot);
        do {
            endPtr--;
        } while (toSort[endPtr] > pivot);
        if (beginPtr < endPtr) {
            // Make sure they haven't crossed yet
            swapElements(toSort, beginPtr, endPtr);
        }
    }
    return beginPtr;
}

void quickSort(int toSort[], int beginPtr, int endPtr)
{
    if (endPtr - beginPtr <= 5) { // Less than 5: insertion sort
        for (int i = beginPtr; i < endPtr; i++) {
            for (int j = i; j > 0; j--) {
                if (toSort[j] < toSort[j - 1]) {
                    swapElements(toSort, j, j - 1);
                } else {
                    break;
                }
            }
        }
        return;
    }
    int splitIndex = partitionElements(toSort, beginPtr, endPtr);
    quickSort(toSort, beginPtr, splitIndex );
    quickSort(toSort, splitIndex, endPtr);
}

void quickSort(int toSort[], int length)
{
    quickSort(toSort, 0, length);
}

You can save 10 bytes using a single letter name instead of quickSort and removing spaces in the last function call. And I bet that you can get a better score avoiding the bonus (15% is not enough)

You can save another 5 bytes by replacing the square brackets of the arguments by single asterisks. Some macro magic could shave off some more bytes, I guess.

You don't need a space after #include.

Get rid of 34 bytes by removing the call to srand(time(NULL)); You'll still get pseudo-random numbers from rand().

APL, 49 42 bytes
{1≥⍴⍵:⍵⋄(∇⍵/⍨⍵
p←⍵[?⍴⍵]}

This creates an unnamed recursive monadic function that accepts an array on the right. It does not qualify for the bonus.
Explanation:
{1≥⍴⍵:⍵⋄                                     ⍝ If length(⍵) ≤ 1, return ⍵
                                  p←⍵[?⍴⍵]}  ⍝ Choose a random pivot
                           ∇⍵/⍨⍵>            ⍝ Recurse on >p
                  (⍵/⍨⍵=p),                  ⍝ Concatenate with =p
        (∇⍵/⍨⍵<p),                           ⍝ Recurse on <p

Try it online
Fixed an issue (at the cost of 8 bytes) thanks to marinus and saved 7 bytes thanks to Thomas Kwa!

The question specifies there will be no duplicates. (Don't know how it took me so long to see that...)

C++17, 254 199 195 bytes
#include<vector>
#include<cstdlib>
#define P push_back(y)
using V=std::vector<int>;V q(V a){int p=a.size();if(p<2)return a;p=rand()%p;V l,r;for(y:a)(y<a[p]?l:r).P;l=q(l);for(y:q(r))l.P;return l;}

With whitespace:
V q(V a) {
    int p = a.size();

    if (p < 2)
        return a;

    p = rand() % p;
    V l,r;

    for (y : a)
        (y < a[p] ? l : r).P;

    l=q(l);

    for (y : q(r))
        l.P;

    return l;
}

No need for srand(time(NULL)).
No need for the erase, just let the value get partitioned, then change the 'if (a.empty())' to 'if(a.size()<2)' and remove 'l.P(x)'.

Eliminating the erase allowed me to save a lot of bytes. Thank you!

One other tiny one:
No need to assign 'r=q(r)', just use 'for(y:q(r))', but that's all I can see!

Just out of curiosity: where is C++17 in particular used here?

for (y : a) would otherwise need to be for (auto y : a) or for (int y : a). (Actually, clang++ calls this a C++1z extension, but it doesn't really seem to be C++17? I don't know and it's too late at night to go look it up.)

Pyth, 25 bytes
L?tbsyMa_,]JObf<TJbf>TJbb

This defines a function y, that takes a list of numbers as input.
Try it online: Demonstration
Explanation
L?tbsyMa_,]JObf<TJbf>TJbb
L                          define function y(b), that returns:
 ?tb                         if t[1:] (if the list has more than one element):
            Ob                 choose a random element of b
           J                   save it in J
          ]                    put J in a list
         ,    f<TJb            create a pair, that contains ^ and a list of
                               all numbers smaller than J: [[J], [smaller than J]]
        _                      reverse this list: [[smaller than J], [J]]
       a           f>TJb       append a list with all elements bigger than J:
                               [[smaller than J], [J], [bigger than J]]
     yM                        call y recursively for each sublist
    s                          combine the results and return it
                        b    else: simply return b

Pyth, 21 bytes (probably invalid)
I use the "group-by" method, which internally uses a sort. I use it to split the original list into three sublists (all element smaller than the pivot, the pivot, and all elements bigger than the pivot). Without the sort in "group-by", it could return these 3 lists in a different order.
As said, this is probably invalid. Nevertheless I'll keep it here, because it's an interesting solution.
L?tb&]JObsyM.g._-kJbb

Try it online: Demonstration
Explanation
L?tb&]JObsyM.g._-kJbb
L                      def y(b): return
 ?tb                     if t[1:] (if the list has more than one element):
       Ob                  choose a random element of b
      J                    save it in J
    &]                     put it in an array and call "and"
                           (hack which allows to call 2 functions in one statement)

            .g     b       group the elements in b by:
              ._-kJ           the sign of (k - J)
                           this generates three lists
                             - all the elements smaller than J
                             - J
                             - all the elements bigger than J
          yM               call y recursively for all three lists
         s                 and combine them
                    b    else: return b

><> (Fish), 313 309 bytes
!;00l[l2-[b1.
>:0)?v~$:@&vl2,$:&${:}$
^-1@{< ]]. >055[3[5b.
?v~~@~ v:}@:}@:}:}@:}@}}}(}(}({{:@=
.>=$~?$>~]]
.001-}}d6.{$}1+}d6
?v:{:}@{(?v08.}:01-=
 >{$~~{09.>95.v-1@{<   v-1}$<
.:@}:@{=${::&@>:0)?^~}&>:0)?^~+}d6
 1-:0a.{{$&l&1+-: >:0)?v~:1)?!v62fb.
>:0)?v~:}:1)?v~69.^@{-1<>.!]]~<
^@{-1<:}@@73.>69@@:3+[{[b1.

This took me very long to write. You can try it here, just put the list that has to be sorted into the initial stack, seperated with commas, before running the program.
How it works
The program grabs the first, middle and last element in the initial stack and calculates the median of these three.
It then changes the stack to:
[list 1] element [list 2]
where everything in list 1 is smaller or equal to the element and everything in list 2 is bigger.
It recursively repeats this process on list 1 and list 2 untill the whole list is sorted.

Python 3, 123, 122.
Saved 1 byte thanks to Aaron.
This is the first time I've actually bothered to write a sorting algorithm. It's actually a little easier than I thought it would be.
from random import*
def q(s):
 if len(s)<2:return s
 p=choice(s);return q([d for d in s if d<=p])+q([d for d in s if d>p])

Ungolfed:
from random import choice
def quick_sort(seq):
    if len(seq) < 2:
        return seq
    low = []
    high = []
    pivot = choice(seq)
    for digit in seq:
        if digit > pivot:
            high += [digit]
        else:
            low += [digit]
    return quick_sort(low) + quick_sort(high)

This looks like it might not work, due to the <= comparison - it doesn't guarantee that p is in the right place, you probably need to change that to an exclusive inequality, and add p in the middle independently (I havn't tested/can't test the code).

@VisualMelon I tested it with a bunch of different cases and never got an incorrect result, but if you can find a test case that breaks it, let me know. Also, it might not work with duplicates, but the challenge specifies that there won't be duplicates.

I'd have thought that [2, 1, 3] would break it 1/3 of the time, as when it selects the pivot to be 2, it will have the low list be [2, 1] - I'm sorry I can't test this myself right now.

@VisualMelon Well, sure, but it then recursively sorts again.

Ah, sorry, missed that completely, not quite how I would expect a Quicksort to be implemented - have an upvote for confusing me

save a byte with from random import*

CJam, 40 bytes
{_1>{_mR:P-PaL@{_P<{+}{@\+\}?}/J\J+}&}:J

This is a named function that expects an array on the stack and pushes one in return.
Try it online in the CJam interpreter.
The above code follows the spec as closely as possible. If that's not required, 12 bytes can be saved:
{_1>{_mR:P;_{P<},J_@^J+}&}:J

Javascript (ES2015), 112
q=l=>{let p=l[(Math.random()*l.length)|0];return l.length<2?l:q(l.filter(x=>x<=p)).concat(q(l.filter(x=>x>p)));}

Explanation
//Define lambda function q for quicksort
q=l=>{

    //Evaluate the pivot
    let p=l[(Math.random()*l.length)|0];

    //return the list if the length is less than 2
    return l.length < 2 ? l:

    //else return the sorted list of the elements less or equal than
      the pivot concatenated with the sorted list of the elements
      greater than the pivot
    q(l.filter(x=>x<=p)).concat(q(l.filter(x=>x>p)));
}

ES6 could probably shorten this.

Octave, 76 75 bytes
function u=q(u)n=numel(u);if n>1 k=u(randi(n));u=[q(u(u<k)),q(u(u>=k))];end

Multi-line version:
function u=q(u)
   n=numel(u);
   if n>1
      k=u(randi(n));
      u=[q(u(u<k)),q(u(u>=k))];
   end

Ceylon (JVM only), 183 170
No bonuses apply.
import ceylon.math.float{r=random}{Float*}q({Float*}l)=>if(exists p=l.getFromFirst((r()*l.size).integer))then q(l.filter((e)=>e
p<e))}else[];

It seems there is no cross-platform way to produce a random number in Ceylon, so this is JVM-only. (At the end I have a non-random version which works in JS too, and is smaller.)
This defines a function which takes an iterable of floats, and returns a sorted version thereof.
import ceylon.math.float {
    r=random
}

{Float*} q({Float*} l) {
    if (exists p = l.getFromFirst((r() * l.size).integer)) {
        return q(l.filter((e) => e
 p < e)) };
    } else {
        return [];
    }
}

If (against the specification) duplicate entries are passed, those will be filtered out.
This are 183 bytes: import ceylon.math.float{r=random}{Float*}q({Float*}l){if(exists p=l.getFromFirst((r()*l.size).integer)){return q(l.filter((e)=>e
p<e))};}else{return[];}}
We can improve a bit by using the new (Ceylon 1.2) if expression:
import ceylon.math.float {
    r=random
}

{Float*} q({Float*} l) =>
        if (exists p = l.getFromFirst((r() * l.size).integer))
        then q(l.filter((e) => e
 p < e)) }
        else [];

This is 170 bytes: import ceylon.math.float{r=random}{Float*}q({Float*}l)=>if(exists p=l.getFromFirst((r()*l.size).integer))then q(l.filter((e)=>e
p<e))}else[];

Here is a non-random version:
{Float*} r({Float*} l) =>
        if (exists p = l.first)
        then r(l.filter((e) => e
 p < e)) }
        else [];

Without spaces this would be 107 bytes: {Float*}r({Float*}l)=>if(exists p=l.first)then r(l.filter((e)=>e
p<e))}else[];

Ruby, 87 60 bytes
q=->a,p=a.sample{a[1]?(l,r=a.partition{|e|e
 1
    l,r = a.partition { |e| e < pivot}
    quicksort(l) + quicksort(r)
  else
    a
  end
end

Test:
q[[9, 18, 8, 5, 13, 20, 7, 14, 16, 15, 10, 11, 2, 4, 3, 1, 12, 17, 6, 19]]
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

R, 78 bytes
Q=function(x)if(length(x)>1)c(Q(x[x<(p=sample(x,1))]),x[x==p],Q(x[x>p]))else x

This creates a recursive function Q that accepts a vector and returns a vector. It does not conditionally apply insertion sort, so no bonus.
Ungolfed:
Q <- function(x) {
    # Check length
    if (length(x) > 1) {
        # Select a random pivot
        p <- sample(x, 1)

        # Recurse on the subarrays consisting of
        # elements greater than and less than p,
        # concatenate with those equal to p
        c(Q(x[x
 p]))
    } else {
        x
    }
}

Try it online
Saved 4 bytes thanks to flodel!

You can nibble a couple of bytes off by dropping the ">1" from the length comparison. This implicitly compares it to 0, but an extra layer of recursion isn't a problem,

@Miff Thanks for your input but I tried that and it doesn't produce the expected result for me.

Julia, 83 bytes
Q(x)=endof(x)<2?x:(p=rand(x);[Q((f=filter)(i->i
i==p,x);Q(f(i->i>p,x))])

This creates a recursive function Q that accepts an array and returns an array. It does not conditionally use insertion sort, so no bonus applies.
Ungolfed:
function Q(x::AbstractArray)
    if endof(x) ≤ 1
        # Return on empty or 1-element arrays
        x
    else
        # Select a random pivot
        p = rand(x)

        # Return the function applied to the elements less than
        # the pivot concatenated with those equal to the pivot
        # and the function applied to those greater than the pivot
        [Q(filter(i -> i
 i == p, x);
         Q(filter(i -> i > p, x))]
    end
end

Fixed an issue and saved some bytes thanks to Glen O!

Possible issues with loss of repeat elements (which already exist in your code) aside, you can save a few bytes here by assigning f when you first use filter, and using endof instead of length. Q(x)=endof(x)<2?x:(p=rand(x);[Q((f=filter)(i->i
i>p,x))])

@GlenO Thanks for the suggestion. I've implemented that and fixed the issue with repeated elements.

I said it could be an issue, but I asked the question poster for clarification, and "The input may contain decimal and negative values. However, there will be no duplicates"

JavaScript (ES6), 191
Q=(a,l=0,h=a.length-1)=>l<h&&(p=((a,i,j,p=a[i+(0|Math.random()*(j-i))])=>{for(--i,++j;;[a[i],a[j]]=[a[j],a[i]]){while(a[--j]>p);while(a[++i]
=j)return j}})(a,l,h),Q(a,l,p),Q(a,p+1,h))

// More readable
U=(a,l=0,h=a.length-1)=>l<h &&
  (p=( // start of partition function
    (a,i,j,p=a[i+(0|Math.random()*(j-i))])=>
    {
      for(--i,++j;;[a[i],a[j]]=[a[j],a[i]])
      {
        while(a[--j]>p);
        while(a[++i]
=j)return j
      }
    } // end of partition function
  )(a,l,h),U(a,l,p),U(a,p+1,h))

// This is the shortest insertion sort that I could code, it's 72 bytes
// The bonus is worth  ~30 bytes - so no bonus
I=a=>{for(i=0;++ix;)a[j]=a[--j]}

// TEST
z=Array(10000).fill().map(_=>Math.random()*10000|0)

Q(z)

O.innerHTML=z.join(' ')

K, 41 bytes
s:{$[#x;(s@x@&x
p:x@*1?#x;x]}

TAKE THAT, APL!!! Doesn't do any of the bonuses.

Haskell, 137136 bytes
f=filter
m a b c=max(min a b)(min(max a b)c)
q[]=[]
q l=let{n=m(head l)(head$drop(length l`div`2)l)(last l)}in(q$f(<n)l)++(n:(q$f(>n)l))

The ungolfed version is hereunder, with expanded variable and function names and some intermediate results added:
median a b c = max (min a b) (min (max a b) c)
quicksort [] = []
quicksort l = let mid = median (head l) (middle l) (last l)
                  lesser = filter (< mid) l
                  greater = filter (> mid) l
                  middle l = head $ drop (length l `div` 2) l
              in (quicksort lesser) ++ (mid : (quicksort greater))

I'm taking advantage of the fact that there's no duplicates to use two strict comparisons. I'll have to check if Data.List.partition doesn't makes things shorter though, even considering I would have to add an import statement. I'm not taking the insertion sort bonus because I consider Data.List.insert as a sorting-related function — thus forbidden — and if not using it, adding the insertion sort pushes the code to 246 bytes, 209.1 with the bonus, so it's not worth it.
Edit : Thanks to RobAu for their suggestion to create an alias to use f=filter. It may save only one byte but everything helps.

f=filter might shave off some bytes.

Maybe you can shave a few bytes by making a function to handle the two redundant q$f(>n)l and q$f(<n)l calls?

Tcl, 138 bytes
proc q v {if {$v eq {}} return
lassign {} a b
foreach x [lassign $v p] {if {$x<$p} {lappend a $x} {lappend b $x}}
concat [q $a] $p [q $b]}

This is an exceedingly standard quicksort.
The pivot is simply the first element of each subarray (I contend that this is a random number. https://xkcd.com/221/)
It isn't particularly efficient in terms of memory usage, though it could be improved some with tailcall on the second recursion and a base case of n<1 elements.
Here's the readable version:
proc quicksort xs {
  if {![llength $xs]} return
  set lhs [list]
  set rhs [list]
  foreach x [lassign $xs pivot] {
    if {$x < $pivot} \
      then {lappend lhs $x} \
      else {lappend rhs $x}
  }
  concat [quicksort $lhs] $pivot [quicksort $rhs]
}

Works on all input and permits duplicates. Oh, it's also stable.
You can test it with something simple, like:
while 1 {
  puts -nonewline {xs? }
  flush stdout
  gets stdin xs
  if {$xs eq {}} exit
  puts [q $xs]    ;# or [quicksort $xs]
  puts {}
}

Enjoy! :O)

You can save bytes replacing foreach by  lmap

Java, 346 bytes
407 bytes - 15% bonus for insertion sort = 345.95 bytes

Compressed Code:
class z{Random r=new Random();void q(int[] a){q(a,0,a.length);}void q(int[] a,int b,int e){if(e-b<6){for(int i=b;i<e;i++){for(int j=i;j>0&a[j]<a[j-1];j--){s(a,j,j-1);}}return;}int s=p(a,b,e);q(a,b,s);q(a,s,e);}int p(int[] a,int b,int e){int p=a[r.nextInt(e-b)+b--];while(b<e){do{b++;}while(a[b]
p);if(b<e){s(a,b,e);}}return b;}void s(int[] a,int b,int e){int t=a[b];a[b]=a[e];a[e]=t;}}

Full Code:
public class QuickSort {

    private static final Random RANDOM = new Random();

    public static void quickSort(int[] array) {
        quickSort(array, 0, array.length);
    }

    private static void quickSort(int[] array, int begin, int end) {
        if (end - begin <= 5) {
            for (int i = begin; i < end; i++) {
                for (int j = i; j > 0 && array[j] < array[j - 1]; j--) {
                    swap(array, j, j - 1);
                }
            }
            return;
        }
        int splitIndex = partition(array, begin, end);
        quickSort(array, begin, splitIndex);
        quickSort(array, splitIndex, end);
    }

    private static int partition(int[] array, int begin, int end) {
        int pivot = array[RANDOM.nextInt(end - begin) + begin];
        begin--;
        while (begin < end) {
            do {
                begin++;
            } while (array[begin] < pivot);
            do {
                end--;
            } while (array[end] > pivot);
            if (begin < end) {
                // Make sure they haven't crossed yet
                swap(array, begin, end);
            }
        }
        return begin;
    }

    private static void swap(int[] array, int begin, int end) {
        int temp = array[begin];
        array[begin] = array[end];
        array[end] = temp;
    }

}

Couple improvements: 1. get rid of the spaces between int[] and a in the method header. 2. Make the increment or decrement in a for loop the last place a variable is accessed. 3. Make a class int (or a couple) to save bytes by using it instead of a new int. 4. Using Math.random() and casting might be shorter than making a Random object.

AutoIt, 320.45 304.3 bytes
This is plenty fast (for AutoIt anyway). Qualifies for insertion sort bonus. Will add explanation after final golfing occurred.
Input is q(Array, StartingElement, EndingElement).
Func q(ByRef $1,$2,$3)
$5=$3
$L=$2
$6=$1[($2+$3)/2]
If $3-$2<6 Then
For $i=$2+1 To $3
$4=$1[$i]
For $j=$i-1 To $2 Step -1
$5=$1[$j]
ExitLoop $4>=$5
$1[$j+1]=$5
Next
$1[$j+1]=$4
Next
Else
Do
While $1[$L]<$6
$L+=1
WEnd
While $1[$5]>$6
$5-=1
WEnd
ContinueLoop $L>$5
$4=$1[$L]
$1[$L]=$1[$5]
$1[$5]=$4
$L+=1
$5-=1
Until $L>$5
q($1,$2,$5)
q($1,$L,$3)
EndIf
EndFunc

Random test input + output:
862, 543, 765, 577, 325, 664, 503, 524, 192, 904, 143, 483, 146, 794, 201, 511, 199, 876, 918, 416
143, 146, 192, 199, 201, 325, 416, 483, 503, 511, 524, 543, 577, 664, 765, 794, 862, 876, 904, 918

Interesting, never heard of AutoIt before

Mathematica, 93 90 bytes
If[Length@#>1,pv=RandomChoice@#;Join[qs2[#~Select~(#<pv&)],{pv},qs2[#~Select~(#>pv&)]],#]&

No bonus, haven't got a minimal way to do insertion sort yet.  When I was learning C++ recently, I did a comparison of various sorting algorithms here.

Python2, 120 bytes
def p(a):
 if[]==a[1:]:return a
 b,c,m=[],[],__import__("random").choice(a)
 for x in a:[b,c][x>m]+=[x];return p(b)+p(c)

if[]==a[1:] is exactly as long as if len(a)>2 but looks more golfed.

Lua, 242 Bytes
function f(t,p)if(#t>0)then local P,l,r,i=math.random(#t),{},{},table.insert p=t[P]for k,v in ipairs(t)do if(k~=P)then i(v
0)then                                            # Just return 0 length lists...
        local P,l,r,i=math.random(#t),{},{},table.insert    # Using local here actually makes the a,b=1,2 method more efficient here. Which is unnormal for Lua
        p = t[P]                                            # P is the index of the pivot, p is the value of the pivot, l and r are the sub-lists around the pivot, and i is table.insert to save bytes.
        for k,v in ipairs(t) do                             # We use a completely random pivot, because it's cheaper on the bytes.
            if(k~=P)then                                    # Avoid 'sorting' the pivot.
                i(v<p and l or r,v)                         # If the value is less than the pivot value, push it to the left list, otherwise, push it to the right list.
            end                                             #
        end                                                 #
        t = {}                                              # We can re-use t here, because we don't need it anymore, and it's already a local value. Saving bytes!
        for k,v in pairs(f(l)) do                           # Quick sort the left list, then append it to the new output list.
            i(t,v)                                          #
        end                                                 #
        i(t,p)                                              # Append the pivot value.
        for k,v in pairs(f(r)) do                           # Ditto the right list.
            i(t,v)                                          #
        end                                                 #
    end                                                     #
    return t                                                # Return...
end                                                         #

Racket 121 bytes
(λ(l)(if(null? l)l(let((h(car l))(t(cdr l)))(append(qs (filter(λ(x)(< x h))t))(list h)(qs (filter(λ(x)(>= x h))t))))))

Ungolfed (l=list, h=head (first element), t=tail (rest or remaining elements)):
(define qs
  (λ(l)
    (if (null? l) l
        (let ((h (first l))
              (t (rest  l)))
          (append (qs (filter (λ(x) (< x h) ) t))
                  (list h)
                  (qs (filter (λ(x) (>= x h)) t))  )))))

Testing:
(qs (list 5 8 6 8 9 1 2 4 9 3 5 7 2 5))

Output:
'(1 2 2 3 4 5 5 5 6 7 8 8 9 9)

Japt, 23 bytes
Each bonus would need to be three bytes or less to pay off in the total score, so I didn't take any bonuses.
Z=Uö;Ê<2?U:ßUf<Z)cßUf¨Z
Z=Uö;                   // Take a random element from the input for partitioning.
     Ê<2                // If the input is shorter than two elements,
        ?U              // return it.
          :             // Otherwise
           ß      ß     // recursively run again
            Uf<Z        // with both items that are smaller than the partition
                   Uf¨Z // and those that are larger or equal,
                )c      // returning the combined result.

Try it online!

20 bytes

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


text:
Roller coaster of numbers
Write a program that generates a sequence of numbers starting with zero and then 100 random integers between -9 and 9.
That sequence will be displayed like a roller coaster.
Any increasing number in the sequence will go up and any decreasing number will go down
Sample sequence:
0 1 8 5 -1 -5 7 1 3 3 4 6 9 -2 ...

Sample output
                                                9
        8                                   6       -2...
    1       5                           4
0               -1      7       3   3
                    -5      1

This is code golf. Shortest code in bytes by November 5th wins.

Very similar.

Can we use ANSI escape codes?

This is essentially a special case of the challenge that Calvin's Hobbies linked to.

Ruby, 167 bytes
l={}
y=p=n=0
101.times{|i|
d/=d.abs if(d=n-p)!=0
l[y-=d]||=Array.new 101," "*4
l[y][i]=n.to_s.ljust 4
p,n=n,rand(18)-9}
puts l.sort_by(&:first).map(&:last).map(&:join)

First time golfing Ruby, so I'm sure I'm missing something.


text:
Area of Polygon
Given the number of vertices N of a convex polygon and each of their (x, y) calculate the polygon's area. vertexes are in clockwise order
You must handle all N <= 45 ,-600 <= x,y <= 600, and your answer must be accurate to at least 2 decimal places.
Example:
3
 1 6
 1 2
-4 2

The area is 10.00.
This is code-golf, fewest bytes wins.
Input to be taken in code.

What order are the vertices given in? Can we assume the polygon is always convex?

Does the input have to be taken in the format of the example? There's no reason for the scripting languages only restriction, and I don't even know what that means.

"Code in scripting languages only" is subjective (what qualifies as a scripting language?) and likely excludes many of the languages commonly used on the site. It's an arbitrary and unnecessary condition.

Sounds like a good challenge, but bad written.

As edited, this question is a duplicate of http://codegolf.stackexchange.com/q/47638/194

About clockwise direction, I think, it is worse. It should be random order like before, instead.

The polygon will be convex hull, so it is unique. Prove me that it is wrong.

After then number of vertex is redudant

@PeterTaylor Why is that? Isn't determining the area of a complex polygon much simpler than determining that of a self-intersecting polygon with even-odd area counting rule?

@MartinBüttner, the standard approach uses the exact same techniques that are used in the answers to the other question. The answers will be shorter because they only need to track two extrema rather than a sorted list of lines, but I that doesn't mean they will be fundamentally different. Although I suppose, on reflection, that there would be other techniques available (use the centroid to split the polygon into triangles). If you want to reopen it, go ahead, but first please edit to clarify whether the vertices are integers or doubles.

@PeterTaylor "They are fudamentally using the same approach. It's only some minor details in the other question which have contributed 87% of the code size!"

Mathematica, 29 bytes
RegionMeasure@*ConvexHullMesh

Example usage:
(RegionMeasure@*ConvexHullMesh)[{{1, 6}, {1, 2}, {-4, 2}}]
(* 10. *)

perfect tool for the job

@phase Even so, I know I'm still going to be beat by the golfing languages. =)

Someone needs to make Pyth for Mathematica

@phase Hmmm what a good idea ;)

Area@*Polygon

JavaScript (ES6) 131

f=l=>(p=l.pop(t=Math.atan2),l.sort((a,b)=>t(a.y-p.y,a.x-p.x)-t(b.y-p.y,b.x-p.x)),[...l,p].map(t=>(v+=p.x*t.y-p.y*t.x,p=t),v=0),v/2)

// More readable
u=l=>(
  t=Math.atan2,
  p=l.pop(),
  l.sort((a,b)=>t(a.y-p.y,a.x-p.x)-t(b.y-p.y,b.x-p.x)),
  v=0,
  [...l,p].map(t=>(v+=p.x*t.y-p.y*t.x,p=t)),
  v/2
)

//TEST
console.log=x=>O.innerHTML+=x+'\n'

T=[{x:1,y:6},{x:1,y:2},{x:-4,y:2}] // area 10
console.log(JSON.stringify(T)+' '+f(T))
T=[{x:12,y:12},{x:2,y:2},{x:4,y:10},{x:11,y:2}] // area 75
console.log(JSON.stringify(T)+' '+f(T))

C# - 268
with all the output handling included, yup this ain't gonna win
using System;class P{static void Main(string[]a){int i,v=int.Parse(a[0]),j=v-1;var x=new float[v];var y=new float[v];for(i=0;i++<v;){x[i-1]=float.Parse(a[i]);y[i-1]=float.Parse(a[i+v]);}float s=0;for(i=0;i<v;j=i++)s+=(x[j]+x[i])*(y[j]-y[i]);Console.Write(s/2);}}

Program reads input from the string array args. Example input: 3 1 1 -4 6 2 2. Output: 10
First number is the number of vertices, all the rest are X & Y coordinates. After vertice number input all x coordinates, then all y coordinates, each one separated by whitespace.
I'm not fully certain if I need to include using, namespace, main void etc... but I included them anyway.
EDIT: Saved some bytes, thanks to @edc65 !

You need to take the input in code.

@hotrod Alright, one second.

@hotrod Done. See the explanation.

namespace is not needed and Program could be P

and surely yod don't need console.read() at the end

The same program, golfed: 262 using System;class P{static void Main(string[]a){int i,v=int.Parse(a[0]),j=v-1;var x=new float[v];var y=new float[v];for(i=0;i++<v;){x[i-1]=float.Parse(a[i]);y[i-1]=float.Parse(a[i+v]);}float s=0;for(i=0;i<v;j=i++)s+=(x[j]+x[i])*(y[j]-y[i]);Console.Write(s/2);}}

@edc65 Alright, next time I know what to include in the byte count :D I know I don't need to stop the console at the end, I just didn't see any way of me winning with C# so didn't golf it to the end :P Thanks for the golfed one still, looks nice!

To have the console app stopping: run without debug (Ctrl f5)

@edc65 Didn't know that o.O Thanks for telling!