text:
Love Tester Code Golf
Create program that counts the total number of letters common to two names, and finds the product of their lengths, to function as a "love tester."
Conditions: you may not get a 1:1 answer (being 3 out of 3, etc.) output.
Input
Two names from STDIN or closest alternative.
Output
Compute x as the total number of letters in common between the two names, ignoring case. Compute y as the product of the lengths of the names. Then the output, to STDOUT or closest alternative, is
Name1 and Name2 have x out of y chances of love.

Examples
Input:
Wesley
Polly

Output:
Wesley and Polly have 2 out of 30 chances of love.

Wesley and Polly have 2 letters in common, y and l, and the product of their lengths is 6 * 5 = 30.
Input:
Bill
Jill

Output:
Bill and Jill have 3 out of 16 chances of love.

Bonuses

Subtract 30 bytes for using simplified fractions, i.e. x out of y is in fully reduced form.

Scoring
This is code-golf answers will be scored in bytes with fewer bytes being better.

What should the output be for Aaron\nAhmad? Or samename\nsamename?

I'm unclear how you're counting total letters in common when letters repeat. If the names have a and b of some letter, do those count for min(a,b) repeats?

as @xor says, how are you counting repeated letters? From the second example, it appears you're counting repeated characters, so if the first example were reversed, then do you expect a different result?

Is it totally unrelated to [tag:kolmogorov-complexity]?

Pyth, 40 bytes
jd[z"and"Jw"have"/K-lzl.-rz0rJ0i=J*lzlJK"out of"/JiJK"chances of love.

The code is 70 bytes long and qualifies for the -30 bytes bonus.
Try it online.
  [                        Begin an array and fill it with the following:
   z                         The first line of input.
   "and"                     That string.
   Jw                        The second line of input, saved in J.
   "have"                    That string.
           rz0rJ0              Convert both lines to lowercase.
         .-                    Remove the characters form the second string
                               from the first, counting multiplicities.
        l                      Get the length.
     -lz                       Subtract it from the length of the first line.
    K                          Save in K.
                  =J*lzlJ      Save the lines' lengths' product in J.
                 i       K     Compute the GCD of J and K.
   /                         The quotient of K and the GCD.
   "out of"                  That string.
   /JiJK                     The quotient of J and the GCD of J and K.
   "chances of love.         That string.
jd                         Join the elements, separated by spaces.

CJam, 55 bytes
ll]_~@_{'~,\elfe=}/.e<:+\:,:*]_2>~{_@\%}h;f/"and
have
out of
chances of love."N/.{}S*

The code is 85 bytes long and qualifies for the -30 bytes bonus.
Try it online in the CJam interpreter.
How it works
ll]      e# Read two lines and wrap them in an array.
_~       e# Copy the array and dump the lines on the stack.
@_       e# Rotate the array on top and push a copy.
{        e# For each line of the copy.
  '~,    e#   Push the array of all ASCII charcters up to '}'.
  \el    e#   Convert the line to lowercase.
  fe=    e#   Count the occurrences of each character in the line.
}/       e#
.e<      e# Vectorized minimum of the occurrences.
:+       e# Add to find the number of shared charaters.
\:,      e# Compute the length of each line.
:*       e# Push the product.
]_       e# Wrap the stack in an array and push a copy.
2>~      e# Discard the lines of the copy and dump the calculated integers.
{_@\%h}; e# Compute their GCD, using the Euclidean algorithm.
f/       e# Divide each element of the array by the GCD.
         e# This also splits the names, which won't affect printing.

"and
have
out of
chances of love."

N/       e# Split the above string at linefeeds.
.{}      e# Vectorized no-op. Interleaves the arrays.
S*       e# Join the results elements, separated by spaces.

Dyalog APL, 94 91-30= 61 bytes
Usually APL golfing results in code that is more compact – but not more complex – than normal, but in this case I save chars in ugly ways:
{1↓(∊' ',¨⍵,⍪'and' 'have'),' love.',⍨∊((⊢÷∨/)(≢⊃∩/32|⎕ucs¨⍵),×/≢¨⍵),⍪'out of' 'chances of'}

,⍪'out of' 'chances of' create a 2×2 table of numbers (left) and texts (right)
×/≢¨⍵ product of lengths
32|⎕UCS¨⍵ harmonize upper- and lowercase UCS values
≢⊃∩/ tally the intersection of the two sets
⊢÷∨/ divide the tally and the product with their GCD
,' love.',⍨∊ make it into a simple list and append love.
⍵,⍪'and' 'have' create a 2×2 table of names (left) and texts (right)
∊' ',¨ prepend a space to each table cell and then make into simple list
1↓ drop the initial superfluous space
Thanks to ngn for -3 bytes.

It appears this is only a function, whereas the OP specified input from STDIN and output to STDOUT (i.e. a full program rather than just a function).

@AlexA. APL doesn't have STDIN, but can issue a prompt to accept the two names in the format 'Wesley' 'Polly'. If you think this would be more fair, feel free to append ⎕ (U+2395) to then very end of the line (after the }), and adjust the score to 65.

Javascript ES6, 123 bytes
(a,b)=>a+` and ${b} have ${[...a].map(x=>eval(`/${x}/i.test(b)&&c++`),c=0),c} out of ${a.length*b.length} chances of love.`

So much for "love"... I could really do with less bytes.
Run the code snippet in Firefox.

x=(a,b)=>a+` and ${b} have ${[...a].map(x=>eval(`/${x}/i.test(b)&&c++`),c=0),c} out of ${a.length*b.length} chances of love.`
<input id="a" value="Bill"><input id="b" value="Jill"><button onclick="o.innerHTML=x(a.value,b.value)">Calculate!</button>

It appears this is only a function, whereas the OP specified input from STDIN and output to STDOUT (i.e. a full program rather than just a function).

Julia, 129 bytes
The code is 159 bytes but it qualifies for the -30 bonus.
A,B=map(chomp,readlines())
a,b=map(lowercase,[A,B])
L=length
r=Rational(L(a∩b),L(a)L(b))
print("$A and $B have $(r.num) out of $(r.den) chances of love.")

This could probably be made shorter by not going for the bonus, but I wanted to show off Julia's rational number type. :)
Ungolfed:
# Read two names from STDIN on separate lines
A, B = map(chomp, readlines())

# Construct their lowercase equivalents
a, b = map(lowercase, [A, B])

# Construct a rational number where the numerator is the
# length of the intersection of a and b and the denominator
# is the product of the lengths
r = Rational(length(a ∩ b), length(a) * length(b))

# Tell us about the love
print("$A and $B have $(r.num) out of $(r.den) chances of love.")

The Rational() function constructs an object of type Rational which has fields num and den, corresponding to the numerator and denominator respectively. The benefit of using this type here is that Julia does the reduction for us; we don't have to worry about reducing the fraction ourselves.

Stax, 42 - 30 = 12 bytes
±à>mª≈◄ΣÇyⁿ`à>²CΔ7ù«▀╦X╠;7╣ⁿ¡♣ë╩■B§F»é▲Y∩«

Run and debug it
Fractions are great to have.

Dyalog APL, 84-30= 54 bytes
∊' and ' ' have' 'out of' 'chances of love.',¨⍨⊢,{+/⌊⌿+⌿↑1↑¨⍨-32|⍉⎕ucs↑⍵}(,÷∨)(×/≢¨)
This is a train, inspired by Adám's answer.
×/≢¨ product of the lengths
{+/⌊⌿+⌿↑1↑¨⍨-32|⍉⎕ucs↑⍵} chances of love
(,÷v) the concatenation divided by the GCD; between the above two expressions, this reduces the fraction
⊢, prepend the names
,¨⍨ shuffles the strings on the left with the values on the right
∊ flatten

"Chances of love" computation in detail:

{+/⌊⌿+⌿↑1↑¨⍨-32|⍉⎕ucs↑⍵}
                     ↑⍵   arrange the names in a 2×N matrix, pad with spaces
                 ⎕ucs     take ascii codes
                ⍉         transpose the matrix as N×2
             32|          modulo 32 to case-fold
        1↑¨⍨-             for each X create a vector 0 0...0 1 of length X
       ↑                  arrange into a 3d array, pad with 0s
     +⌿                   1st axis sum, obtain freqs per letter and per name
   ⌊⌿                     1st axis min, obt. nr of common occurrences per letter
 +/                       sum

test, test2

05AB1E, 44-30 = 14 bytes
ÃÙgD¹g²g*DŠ¿U)X/`s¹²“ÿ€ƒ ÿ€¡ ÿ€Ä€‚ ÿÒï€‚„Î.“

Try it online!

Python 2.7, 161 bytes
import string;r=raw_input;a,b=r(),r();print'%s and %s have %i out of %i chances of love'%(a,b,sum(map(lambda c:c in a and c in b,string.letters)),len(a)*len(b))

Test it here : http://ideone.com/jeoVgV
And here is a version that simplifies the fraction :
import string,fractions;r=raw_input;a,b=r(),r();F=fractions.Fraction(sum(map(lambda c:c in a and c in b,string.letters)),len(a)*len(b))
print'%s and %s have %i out of %i chances of love'%(a,b,F.numerator,F.denominator)

Unfortunately this one's score is 219-30=189...

Here is a compiler you can add: http://ideone.com/jeoVgV

Java 8, 192 bytes
BiFunction y=(a,b)->a+" and "+b+" have "+(""+a).chars().filter(c->(""+b).toUpperCase().indexOf(c>'Z'?c-32:c)>=0).count()+" out of "+(""+a).length()*(""+b).length()+" chances of love.";

Ex:
System.out.println(y.apply("Bill","Jill"));
System.out.println(y.apply("Wesley","Polly"));

Ruby, 153 bytes
Longer than I expected. I don't know if the 30 bytes bonus applies for this.
d=[];2.times{d<<gets.chop<<$_.downcase.chars<<$_.length-1};$><<"#{d[0]} and #{d[3]} have #{d[2]-(d[1]-d[4]).length} out of #{d[2]*d[5]} chances of love."

Could you please add a link to a compiler? (I recommend Ideone)

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


text:
Write a time machine quine
Write a program that takes as input a string and an integer n, and outputs:

The string that was passed to the program n times ago;
A new program that will be used for the next invocation.

You cannot store any data outside of the program, and your program cannot call previous programs in the chain. If the string does not exist, output an empty string (but still output the next program).
Example run, where I use the notation program_n for each successive program (Of course, [This text is the nth program] would be replaced with actual code.)
$ program_1 "One" 1
[This text is the second program]
$ program_2 "Two" 1
One
[This text is the third program]
$ program_3 "Three" 2
One
[This text is the fourth program]
$ program_4 "Four" 2
Two
[This text is the fifth program]
$ program_5 "Five" 1
Four
[This text is the sixth program]

Should the new program's code be output as a string? Or should it be saved to a file and the filename output?

@Mego Output it as a string (that is, to STDOUT). You don't need to implement the copying the new program to a file.

By "output nothing", do you mean output the next program, but not the (non-existant) string?

@Mega Yes, that's what I meant.

You could also add the program_n+1's to the output line like [program_3, One] if that is what you would like to see. If both output goes to stdout how should they be separated? Also are function allowed instead of full programs?

@randomra Yeah, that's basically what I wanted. You can separate them with a newline. And it should be a full program.

Can the string have spaces in it?

Suppose my language has support for variable history within a session -- allowing me to easily access and modify past instances of a variable. Is it absolutely unequivocal that my program can't, say, generate its own new n+1 source files with all the variable histories and iteratively execute itself?

given that I promise not to infect you with a fork bomb (garbage collection: WIP)

CJam, 25
L{\_l~(>1<lN+a@+`@"_~"}_~

Try it online
Explanation:
L      push an empty array (this is the array of previous strings)
{…}    push this block
_      duplicate the block
~      execute the 2nd copy (the stack contains the array and the block)

The block:
\      swap the array with the block
_      duplicate the array
l      read a line from the input (containing the integer n)
~(     evaluate n and decrement it
>      slice the array starting at that position
1<     slice the resulting array to keep only the first string (if any)
l      read the 2nd line from the input (containing the string)
N+     append a newline
a      wrap in an array
@      bring the previous array to the top
+      concatenate the arrays, thus prepending the new string
`      convert the array to its string representation
@      bring the block to the top
"_~"   push this string

At the end, the requested string (if any), the array's representation, the block and the string "_~" are printed automatically.

Python, 221 bytes
import sys
o,p=[''],r'import sys;a,o,p=int(sys.argv[2]),[{2},{0}],{1};print o[a] if len(o)>a else "","\n",p.format(`sys.argv[1]`,`p`,",".join(`s`for s in o))'
print '\n',p.format(`sys.argv[1]`,`p`,','.join(`s`for s in o))

To test this easily, use ./thisgolf.py "yourfirststring" | python -c "import sys;exec(sys.stdin.read().split('\n')[1])" "your second string" <N>, repeating the last bit as many times as you'd like.

Python 2, 207 bytes
def r(O,R):import sys,marshal as m;a=sys.argv;b=int(a[2]);O.extend(["",""]*b);O[b]=a[1];print"%s\nfrom marshal import*;c=%r;i=lambda:0;i.__code__=loads(c);i(%r,i)"%(O[0],m.dumps(R.__code__),O[1:])
r([""],r)

Built on my other quine but changes program, this task is simpler so I was able to golf this further. If I was able to take the input to stdin, this should be much shorter.

Python 3, 90 bytes
a=["a+=input(),;print(*a[1:-int(input())][-1:],'a=%r;exec(a[0])'%a,sep='\\n')"];exec(a[0])

Try it online!
How it works:

a store [<code>, <first call>, ..., <last call>]
a[1:-int(input())] gives the sublist [<first call>, ..., <wanted call>] (or the empty list if the wanted call doesn't exist). Then [-1:] gives the singleton of the last element of that sublist if it exists (the empty list otherwise). * then unpack the sublist.
The quine part is based on the quine a="print('a=%r;exec(a)'%a)";exec(a)

Javascript ES6, 130 128 121 120 113 bytes
a=[];b=_=>{a.push(prompt());console.log((a[a.length-prompt()-1]||"")+`
a=`+JSON.stringify(a)+";b="+b+";b()")};b()

down to 87: a=[];b=_=>(a.push(prompt()),[a[a.length-prompt()-1]||"",`a=[${a}];b=${b};b()`]);b()

Oh. Would this? It's 66 bytes: a=[],b=(x,y)=>(a.push(x),`${a[a.length-y-1]||""}\na=[${a}];b=${b}`) _____replace \n with an actual newline.

Then try a=[],b=(x,y)=>(a.push(x),${a[a.length-y-1]||""}\na=${JSON.stringify(a)};b=${b}\), which leaves you at 80 bytes (after replacing \n, of course). (If you still have a problem with my code possibly being a REPL snippet, then I have other suggestions :P).

Some of the last few revisions had noncompliant output formats. Rolled back to last compliant version.

Julia 1.0, 87 bytes
(a=:(a=[ARGS[1];a];print("(a=(println($a[parse(Int,ARGS[2])]);$a))[end]|>eval")))|>eval

Try it online!
smilar approach than Jakque's answer but reversing the history order:

a stores [<last string>, ..., <first string>, <code>]
based on this quine by Dennis
the code is stored as a quote, which adds some ugly formatting but is equivalent

source: Stack Exchange

license: 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/

sort: votes


text:
Cramming The Gramming - Twelve Task Tweet
Your boss just emailed you a list of 12 programming tasks he needs done as soon as possible. The tasks are simple enough but your boss, being a young software tycoon suckled by social networking, insists that your solutions be able to fit within a single Twitter tweet.
This means that you only have 140 bytes worth of code to solve all the tasks, an average of 11.67 bytes per task. (Yes, Twitter counts characters but your boss specifically said bytes.)
You realize there's no way to solve all 12 tasks in 140 bytes but you suspect that your boss won't actually test all your solutions. So you proceed to solve as many tasks as you can, completely skipping some of them. Your mindset is that it doesn't matter which subset of the tasks you complete, it only matters that the subset is as large as possible.
How many tasks can you complete?
Challenge
Write up to 12 different programs, each of which accurately solves one of the 12 tasks listed below. The cumulative sum of the lengths of these programs may not exceed 140 bytes
Alternatively, you may write a single program no greater than 140 bytes long that takes an integer from 1 to 12 and (ideally) proceeds to solve the corresponding task, taking more input as necessary. Not all the tasks need to work, but only the ones that do count towards your score. Tasks that don't work are allowed to error or do anything else.
In either case a "program" may in fact be a function that takes the input as arguments or prompts for it and prints or returns the output. So, for example,  you might write a 140 byte function that looks like f(taskNumber, taskInput), or you might write separate code snippets for each task, some as functions and some as fully-fledged programs.
Other details:

All code must be written in the same language.

As usual, input should come from stdin, the command line, a function argument, or whatever is usual for your language. Output is printed to stdout or your language's closest alternative, or returned in an appropriate type.

A reasonable amount of input formatting is fine; e.g. quotes around strings or \n instead of actual newlines.

Output should be exactly what is called for with no extraneous formatting or whitespace. The exception is an optional single trailing newline.

Code that only runs in a REPL environment does not constitute a program or function.

You may not write multiple programs that solve multiple tasks. It's either one program that (ideally) solves all the tasks, or (ideally) 12 programs that each solve a single task.

Posting a task solution that you didn't write or only slightly modified is not allowed without giving attribution to the original author, and ideally getting permission too. If your answer primarily composes the shortest solutions from all the other answers then it should be a community wiki.

Scoring
The submission that completes the most tasks is the winner. If two submissions tie, the one with the fewest bytes wins. If the byte counts are tied, the earlier submission wins. Community wiki answers are not allowed to win.
Be sure to tell us which tasks you solved, not just how many!
Handicap for non-golfers:
It's likely that this challenge will be dominated by golfing languages. Many languages may have trouble solving even one or two tasks within 140 bytes. Therefore you may submit a non-competitive answer where the limit is 3 tweets, i.e. 420 bytes. All the other rules remain the same.
Tasks
Task 1 - Can Three Numbers Form A Triangle?
Take in three positive integers and output a truthy/falsy value indicating whether or not three lines with those lengths could form a triangle. You may not assume the numbers come in any particular order.
Truthy examples (one per line):
20 82 63
1 1 1
2 3 4
1 2 2

Falsy examples:
6 4 10
171 5 4
1 1 2
1 2 3

Task 2 - Closest To One Million
Given a string of exactly 7 decimal digits (0-9), rearrange them to get a number that is as close as possible to one million. That is, abs(1000000 - rearrangedNumber) should be minimized.
Print or return the resulting number as an integer, not a string (so there shouldn't be leading zeroes unless that's the norm for your language).
e.g. an input of 9034318 should result in 984331 (and not 1033489).
2893984 should become 2348899.
0001000 should become 1000000.
0000020 should become 200000.

Task 3 - Simple Keyboard Simulator
Take in a string of lowercase letters (a-z), spaces, and angle brackets <>. Read left to right, this string represents the keys that were pressed on a standard keyboard while an initially empty text editor was open. The letters and space correspond to their normal keys but < corresponds to the left arrow key and > to the right arrow key, both of which move the cursor when pressed.
< moves the cursor one character left, or does nothing if the cursor is at the start of the string.
> moves the cursor one character right, or does nothing if the cursor is at the end of the string.
Output the string that would be in the text editor once all the keys in the input string have been pressed. Outputting escape codes to move the cursor is not allowed.
There will always be at least one non–arrow key character in the input.
e.g. the input ui<<q>>ck <<<<<<the<<<<>>> >>>>>>>>brown x<o<f should yield the quick brown fox.
op<<l>>t<<<lam>>>>>>imi<<<><>>>zer<<<<<<<<<<<<<<<<<<>>><>m should give llammoptimizer.
e< <c<b<a should give abc e.
<<<>><><<><toast>><<>><><<>>< should give toast.

Task 4 - FILTHE Letters
In many fonts, 6 of the uppercase English alphabet letters consist entirely of horizontal and vertical lines: E, F, H, I, L, and T. We'll calls these the FILTHE letters.
Take in a string of uppercase letters (A-Z) and count the number of lines in the FILTHE letters, outputting the resulting integer.
E, F, H, I, L, and T have 4, 3, 3, 3, 2, and 2 lines respectively.
e.g. GEOBITS has 4 + 3 + 2 = 9 lines part of FILTHE letters (for .E..IT.), so the output should be 9.
ABCDEFGHIJKLMNOPQRSTUVWXYZ should output 17.
ABCDGJKMNOPQRSUVWXYZ should output 0.
FILTHYLINESINLETTERS should output 39.

Task 5 - Alex Recursive A.
Our moderator Alex A. has a fairly mysterious initial, "A".
Now I'm not certain, but I think the A. stands for .A xelA. And I'm also pretty sure that the .A there sneakily stands for Alex A..
Thus to get Alex's full name we must expand out the A.'s and .A's:
Alex A. -> Alex [A.] -> Alex [.A xelA] -> Alex .A xelA -> Alex [.A] xelA -> Alex [Alex A.] xelA -> Alex Alex A. xelA -> etc.

Have your program take in a non-negative integer and expand Alex A. that many times, outputting the resulting string.
So
0 becomes Alex A.,
1 becomes Alex .A xelA,
2 becomes Alex Alex A. xelA,
3 becomes Alex Alex .A xelA xelA,
4 becomes Alex Alex Alex A. xelA xelA,
5 becomes Alex Alex Alex .A xelA xelA xelA,
and so on.
(I made this because I felt bad for inadvertently leaving Alex out of my mod tribute challenge. :P)

Task 6 - Numpad Rotation
Take in an integer from 1 to 9 inclusive (you may take it as a string). Output the 3×3 square of digits
789
456
123

rotated in increments of 90° such that the input digit appears anywhere on the top row. When 5 is input any rotation is valid output since 5 cant be rotated to the top.
e.g. when 3 is input, both
963
852
741

and
321
654
987

are valid outputs.
For input 4, only
147
258
369

is valid output.

Task 7 - Splitting Digits Into Tens
Take in a nonempty string of decimal digits (0-9) and output a truthy value if it can be broken up into contiguous sections where all the digits in each section sum exactly to 10. If this is not possible, output a falsy value.
e.g. 19306128 can be split up like 19|3061|28, the sections all summing to 10 (1+9, 3+0+6+1, 2+8), so a truthy value should be output.
Truthy examples (one per line):
19306128
073
730
0028115111043021333109010
2222255

Falsy examples:
6810410
9218
12341
5222225
000

Task 8 - Square Clock
Take in a consistently sized multiline string.
Output 12 if the input is
 _ _
| | |
|_ _|

Output 3 if the input is
 _ _
| |_|
|_ _|

Output 6 if the input is
 _ _
| | |
|_|_|

Output 9 if the input is
 _ _
|_| |
|_ _|

There are no other input cases.

Task 9 - Bracket Art
Take in a 4 byte string containing one of each of the left brackets (, [, {, and < in any order.
Add the corresponding right brackets so the string is 8 bytes long and has a vertical line of symmetry. e.g. [<({ becomes [<({})>].
Then reverse every bracket in this string. e.g. [<({})>] becomes ]>)}{(<[.
Output the original 8 byte bracket string with the reversed version above and below on separate lines.
So the final output for input [<({ would be
]>)}{(<[
[<({})>]
]>)}{(<[

Similarly, the output for <({[ should be
>)}][{(<
<({[]})>
>)}][{(<

The input (<<[ is invalid because the { is missing and there is an extra <.

Task 10 - Perimiterize
Take in a rectangular grid of text (1×1 at smallest) made of .'s that represent empty space and X's that represent solid tiles. Cells beyond the grid bounds are considered empty. You may assume each of the 4 grid edge rows and columns will contain at least one X.
e.g. a valid input might be:
XXX.....X.....
X..X...X.X....
XXX.....X....X

Output another rectangular grid of text where every empty cell that neighbors an X orthogonally or diagonally, including those outside the input grid, becomes o. So essentially a perimiter of o's is drawn around all the portions of solid tiles. The new grid should not be any larger than it has to be.
So the output of the example above would be:
ooooo...ooo.....
oXXXoo.ooXoo....
oXooXo.oXoXo.ooo
oXXXoo.ooXoo.oXo
ooooo...ooo..ooo

Similarly, the output of input XXX..X.X should be
oooooooooo
oXXXooXoXo
oooooooooo

and outputting
oooooooooo.
oXXXooXoXo.
oooooooooo.

would be invalid since the empty rightmost column is unnecessary.
You may use any 3 distinct printable ASCII characters in place of ., X, and o.

Task 11 - Sator Square
Output the Sator Square:
SATOR
AREPO
TENET
OPERA
ROTAS

Any of the letters may be lowercase or uppercase, so
SatOR
aRePO
tenet
OPERa
RoTaS

is also valid output.
There is no input.

Task 12 - Prime Tweet
Take no input but output a 140 byte printable ASCII string that contains at least one of each of the 95 printable ASCII characters. (So 45 characters will be duplicates.)
The sum of the character codes of all 140 bytes in this string must be a Sophie Germain prime, i.e. a prime number p such that 2p+1 is also prime. The character code for space is 32, 33 for !, 34 for ", and so on up to 126 for ~. The sum could be calculated in Python as sum(map(ord, myString)).
An example output is:
! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

The character code sum is the prime 12203 whose corresponding safe prime is 24407.

I will be impressed if anyone actually manages to solve everything in less than 140 bytes, even with CJam/Pyth

I am honored to be in .a ni eb ot deronoh ma I... challenge of yours. :P

are tasks allowed to end with an error after the result is printed to the output?

How should we count bytes from imports? Let's say I write 5 functions where 2 need the same module (e.g. import Math), is this counted twice?

@nimi It would be counted twice unfortunately. Though you can write one program for all the tasks and thus only need one import.

@torcado The default is yes. (Calvin's Hobbies, you should override that explicitly if that is your intention, although that might be a bit late now... one of my solutions actually did terminate with an error before I golfed it further.)

@MartinBüttner Well fine, let's stick to the default.

Are submissions allowed to count flags as extra bytes, per usual policy?  I ask because Pip frequently uses flags for output formatting.

Mathematica string manipulation is expensive...

After this bounty expires, I will offer another 400-point bounty for the shortest combined solution in TI-BASIC in another week.

@ThomasKwa Do you mean task 3? You can assume there's at least 1 non <>.

Yes, I meant 3.

In TI-BASIC, the newline character 0x3F can't actually be typed in on a default calculator. Can we still (a) take input from the Ans variable (command line-ish, can be entered using a hex editor) or (b) take input from Input? In the first case a hex editor can be used to pass the string.

@ThomasKwa Both sound alright since TI-BASIC is a special case.

As @jacobly pointed out, it's impossible to get a quote character in a string  in TI-BASIC without taking input. Is it acceptable to assume that the Ans variable contains a quote character (which is what @Weregoose did)?

@ThomasKwa That sounds fine for TI-BASIC.

In Task 12, do we need to display all of the tokens corresponding to the ASCII characters, or can we just display tokens like sin( counting as s, i, n, and (?

@ThomasKwa Those can count.

@pppery I believe that consensus covers new challenges, not existing ones. I see no need to close this challenge based on that decision

@cairdcoinheringaahing So, why was First code golf decathlon closed and locked if the consensus I linked to only applies to challenges that postdate it.

I'm voting to close this question as off-topic because it's a multi-part challenge with insufficient interaction between the parts

Pyth, 9 tasks in 136 bytes
Task 1: 7 bytes
<-F_SQ0

Demonstration
Sort in descending order (_SQ), fold subtraction over them (a-b-c), check if the result is negative.
Task 2: 14 bytes
sho.a-sN^T6.pz

Demonstration
Form all string permutations (.pz), sort them (o) based on the absolute value of the difference (.a-) between the number (sN) and one million (^T6).
Take the first such string (h), and convert it to a num. (s).
Task 4: 19 bytes
s/L+\EPP*3"EFHILT"z

Demonstration
Replicate "EFHILT" three times (*3), remove the trailing LT (PP), and add an E (+\E). Map each letter in the input to its appearance count in that string. (/L ... z). Sum. (s).
Task 5: 16 bytes
u+"Alex "_GhQ".A

Demonstration
Starting with "A.", reverse and add an "Alex " to the start, input + 1 times.
Task 7: 13 bytes
}Y-RTsMM./sMz

Convert the input string into a list of 1-digit numbers (sMz). Form all partitions (./). Sum each element of each partition (sMM). Remove all 10s from each sublist (-RT). Check if this emptied out any of the sublists by checking if the empty list is in the overall list (}Y).
Task 8: 11 bytes
*3h%%CQC\Ç4

Demonstration
Modulo magic. Convert to number (CQ), take it mod 199 (C\Ç = 199), and take that mod 4. Then add 1, and multiply by 3.
Task 9: 21 bytes
J+Xz"<{[()]}>")_zJ_JJ

Demonstration
First, we generate the first line, which consists of the input translated to the mirror characters (Xz"<{[()]}>")), followed by the reversed input (+ ... _z), and save it to J. Then print that line, its reverse, and that line again (J_JJ).
Task 11: 22 bytes
+J"SATOR
AREPO
TEN"t_J

Demonstration
Just print a string and its reversal, but don't duplicate the center N.
Task 12: 13 bytes
++G*19\3srd\

Demonstration
There is an invisble DEL (7F) character at the end of the code.
This prints
abcdefghijklmnopqrstuvwxyz3333333333333333333 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

which has character sum 11321. It consists of G, the alphabet, 19 3s, and all of the printable ASCII characters.

CJam, 8 9 tasks in 140 bytes
First off, here is a script you can use to sort your solutions and tell you which ones will fit into the tweet:
{\s\Se[oSo}:F;
qN/ee{W=,}${)_,_T+:T140>X*_{0:X;}*'=@11+*N+*o\~)YF_,ZFTZFoNo}/

Just paste your 12 solutions into the input, one on each line. Run it here. The first column is the task number, the second its size (in characters - you'll have to fix this yourself if that is different from the byte count), the third the cumulative size. The programs which fit into the tweet are separated from the rest with a line of ===.
For me, the output looks like this:
 1   7   7 q~$~\->
 8  10  17 qDbJ%5/)3*
12  12  29 ',32>_51>'d
 7  13  42 Aq{~-Ace|}/N&
 2  15  57 qe!{~1e6-z}$0=~
 4  19  76 q"FIHEELT"3*H<fe=:+
 5  20  96 ".A"q~){" xelA"+W%}*
 9  22 118 q_{_')>+)}%W%+_W%N@N3$
11  22 140 "SATOR\AREPO\TEN"_W%1>
====================================
 6  25 165 9,:)s3/zq~))3mdg*{W%z}*N*
 3  43 208 LLq{_'=-z({+}{'=>_)$\[{)@+\}{\(@\+}]=&}?}/\
10  45 253 0XW]_m*qN/{'.f+W%z}4*f{\~@m>fm>N*}(\{8f^.e>}/

So here are the tasks I can currently fit into the tweet.
Task 1 - Can Three Numbers Form A Triangle? - 8 7 bytes
Thanks to jimmy23013 for saving 1 byte.
q~$~\->

Test suite.
Input is expected to be CJam-style list.
This is fairly straightforward: check if the largest side is shorter than the sum of the other two. Or equivalently, check that the shortest side is longer than the difference of the other two:
q~  e# Read and eval input.
$~  e# Sort the values and dump them on the stack.
\-  e# Subtract the middle value from largest.
>   e# Check if the smallest value is greater than that.

Task 2 - Closest To One Million - 15 bytes
qe!{~1e6-z}$0=~

Test suite.
Simple brute force:
q        e# Read input.
e!       e# Get all permutations.
{        e# Sort by...
  ~      e#   Evaluate the permutation to get its numerical value X.
  1e6-z  e#   abs(X - 1,000,000)
}$
0=       e# Pick the first element (which minimises the difference)
~        e# Evaluate it to get rid of the leading zeroes.

Task 4 - FILTHE Letters - 21 19 bytes
Thanks to jimmy23013 for saving 2 bytes.
q"FIHEELT"3*H<fe=:+

Test suite.
The idea is to create a string which contains each of the FILTHE letters once for each of their orthogonal lines. This is done via some funny string manipulation:
q          e# Read the input.
"FIHEELT"  e# Push this string. It first contains the 3-line letters, then the 2-line
           e# letters, where we include 'E' twice to make it count for 4.
3*         e# Repeat 3 times: "FIHEELTFIHEELTFIHEELT"
H<         e# Truncate to 17 characters: "FIHEELTFIHEELTFIH". This is chosen such that
           e# it discards the third repetition of the 2-line letters.
fe=        e# For each character in the input, count its occurrences in this new string.
:+         e# Sum them all up.

Task 5 - Alex Recursive A. - 27 20 bytes
".A"q~){" xelA"+W%}*

Test suite.
Implemeting the substition of A. and .A directly is way too expensive. Instead, we notice that we only have to handle one case, if we reverse the string each time. Furthermore, prepending Alex (and a space) each time is equivalent to expanding the initial. We can save another byte by appending the reverse before reversing the string:
".A"        e# Start with ".A" (the -1st iteration if you like).
q~)         e# Read input, eval, increment (so the following block is run at least once.)
{           e# Repeat this block that many times...
  " xelA"+  e#   Append " xelA".
  W%        e#   Reverse the string.
}*

Task 7 - Splitting Digits Into Tens - 18 16 13 bytes
Aq{~-Ace|}/N&

Test suite. (With brackets around each output.)
Not exactly user friendly: the truthy value is a single newline, the falsy value is the empty string.
The basic idea is simple: add the digits to a running total which we reset whenever it hits exactly 10. The total must be zero at the end of the input. For a start it turns out to be shorter to the total at 10 and subtract the digits, resetting the total whenever we hit 0. However, we need to make sure that we don't return something truthy when the input is all zeroes. The shortest way I found to do that was to reset the total to the character with code point 10 (the linefeed), and then check at the end that we actually have that character on the stack, and not the number 10. This works, because both the integer zero and the character zero (the null byte) are falsy:
A     e# Push a 10, the initial running total.
q{    e# For each character in the input...
  ~-  e#   Evaluate the character to get the digit and subtract it from the total.
  Ac  e#   Push a linefeed character.
  e|  e#   Logical OR of the running total and the linefeed character (using
      e#   short-circuiting).
}/
N&    e# Take the set intersection with the string containing a linefeed character.
      e# If the total is still a number of any character other than the linefeed,
      e# this will yield an empty string. Otherwise, the string will remain unchanged
      e# and the linefeed will be printed.

Task 8 - Square Clock - 10 bytes
qDbJ%5/)3*

Test suite.
This is just some pretty random modulo magic on the character codes which happens to hash to the correct values. I'm fairly convinced that something shorter is possible, but it's the shortest I found (programmatically) for this kind of structure:
q   e# Read the input.
Db  e# Treat the character codes of the string as digits in base 13. This maps the
    e# four inputs to the values: 2023940117708546863
    e#                            2023940113755405840
    e#                            2023940781838850791
    e#                            2023940113755390292
J%  e# Take the result modulo 19. This gives [2, 5, 12, 18], respectively.
5/  e# Divide by 5 (rounding down). [0, 1, 2, 3], respectively.
)   e# Increment. [1, 2, 3, 4], respectively.
3*  e# Multiply by 3. [3, 6, 9, 12], respectively.

Task 9 - Bracket Art - 23 22 bytes
Thanks to Sp3000 for saving 1 byte.
q_{_')>+)}%W%+_W%N@N3$

Test suite.
Fairly straightforward. The mapping between the left and right brackets is done by adding 2 (or 1 for parentheses):
q_      e# Read input and duplicate.
{       e# Map this block onto each character...
  _')>  e#   Duplicate and check if it's not a parenthesis.
  +     e#   Add the result, leaving parentheses unchanged and incrementing the
        e#   other bracket types.
  )     e#   Increment again.
}%
W%+     e# Reverse and add to the original, giving the middle line.
_W%     e# Duplicate and reverse, giving the first line.
N@      e# Push a linefeed, pull up the middle line.
N3$     e# Push another linefeed, copy the first line.

Task 11 - Sator Square - 22 bytes
"SATOR
AREPO
TEN"_W%1>

Test it here.
Probably the most boring solution of all. It pushes the first half of the string and then reverses it:
"SATOR
AREPO
TEN"    e# Push everything up to the centre of the square.
_W%     e# Duplicate and reverse.
1>      e# Discard the "N", because we don't want that twice.

Task 12 - Prime Tweet - 13 12 bytes
',32>_51>'d

Test it here. (With diagnostic output for the result.)
After ' there's the unprintable <DEL> (0x7F), which SE strips out. For copy-pasting, use this version instead:
'~),32>_51>'d

The printed string is
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

That is, it contains one run of all characters, followed by another run from S to ~, followed by a single d. The sum of the character codes is 12203. I found this via a bit of trial and error.
'~),32>  e# Push a string with all printable characters.
_51>     e# Duplicate this and discard the first 51 of them.
'd       e# Push a "d".

q~$~\-> q"FIHEELT"3*H<fe=:+.

@jimmy23013 Ohhhh, I keep forgetting that we have e= these days.

I was hoping to get enough answers to post something before you spotted how to do #5 in 20 chars.

Pyth, 9 tasks in 138 bytes
This took quite a while.
I think 9 tasks is the limit for Pyth. Including the next shortest program (Sator Square) results in 160 bytes. Golfing 20 bytes is quite unlikely. There are 2 or 3 tasks which are a little bit ugly and maybe can be shortened, but overall I'm quite pleased with the solutions.
Task 1 - Can Three Numbers Form A Triangle?, 8 bytes
>FsMc2SQ

Try it online: Regular Input or Test Suite
Task 2 - Closest To One Million, 14 bytes
ho.a-^T6NsM.pz

Try it online: Regular Input or Test Suite
Task 4 - FILTHE Letters, 20 bytes
s*Vtsmmdd5/Lz"TLIHFE

Try it online: Regular Input or Test Suite
Task 5 - Alex Recursive A., 16 bytes
u+"Alex "_GhQ".A

Try it online: Regular Input or Test Suite
Task 6 - Numpad Rotation, 20 bytes
jeo}zhN.uC_N3_c3jkS9

Try it online: Regular Input or Test Suite
Task 7 - Splitting Digits Into Tens, 15 bytes
qTu+WnGTvHG-zZZ

Try it online: Regular Input or Test Suite
Task 8 - Square Clock, 12 bytes
*3%%Cz1978 5

Try it online: Regular Input or Test Suite
Task 9 - Bracket Art, 20 bytes
V3_WtN+z_Xz"[<({})>]

Try it online: Regular Input or Test Suite
Task 12 - Prime Tweet, 13 bytes
++*d44srd\\&

Try it online: Regular Input

Combining our submissions results in 133 bytes.

TI-BASIC, 4 Tasks in 110 bytes
Task 1 in 7 bytes
:2max(Ans)<sum(Ans

Input is a list in Ans.
Task 4 in 35 bytes
:sum(int(2seq(inString("TLIHFE",sub(Ans,I,1))^.4,I,1,length(Ans

Input is a string in Ans.
Task 8 in 29 bytes
:18fPart(sum(seq(I(sub(Ans,I,1)=" ")/6,I,1,15

Input is a string in Ans.
Task 11 in 39 bytes
:Disp "SATOR
:Disp "AREPO
:Disp "TENET
:Disp "OPERA
:Disp "ROTAS

Bonus round! Here are all the other tasks just for fun.
Task 2 in 92 110 bytes
:seq(expr(sub(Ans,I,1)),I,1,7→L₁
:SortA(L₁
:min(7,1+sum(not(L₁
:{L₁(1)+sum(seq(L₁(I))₁₀^(I-8),I,2,7)),L₁(Ans)+sum(seq((I>Ans)L₁(I)₁₀^(1-I),I,2,7
:ᴇ6Ans(1+(0>min(ΔList(abs(1-Ans

Prompts for a list of digits Input is a string in Ans.
Task 3 in 119 bytes
:Input Str1
:"  →Str2
:For(I,1,length(Str1
:sub(Str1,I,1→Str3
:inString("<>",Ans
:If Ans:Then
:max(0,min(L,C+2Ans-3→C
:Else
:C+1→C
:L+1→L
:sub(Str2,1,C)+Str3+sub(Str2,C+1,L-C+1→Str2
:End
:End
:sub(Str2,2,L

Prompts for a string.  Assumes C and L are either undefined or 0.
Task 5 in 63 bytes
:Ans/2→C
:sub("A.A",1+2fPart(C),2
:For(I,0,C
 :"Alex "+Ans
 :If I≠C
  :Ans+" xelA
:End
:Ans

Input is a number in Ans.
Task 6 in 66 bytes
:^((Ans<7)(Ans-3(Ans>3
:For(Y,⁻1,1
 :Disp sum(seq((5-real(AnsX+AnsY)-3imag(AnsX+AnsY))₁₀^(X+1),X,⁻1,1
:End

Input is a number in Ans.
Task 7 in 36 43 bytes
:Input <strike>L₁</strike>Str1
:.5
:For(I,1,<strike>dim(L₁</strike>length(Str1
 :Ans+<strike>L₁(I</strike>expr(sub(Str1,I,1
 :If 10=int(Ans
  :0
:End
:not(Ans

Prompts for a list of digits string.
Task 9 in 83 bytes
:For(I,1,16,2
 :If I<8
  :Ans+sub(")}]>",inString("({[<",sub(Ans,4,1)),1
 :sub(Ans,I,1)+Ans
:End
:For(I,⁻1,1
 :Disp sub(Ans,9-8abs(I),8
:End

Input is a string in Ans.
Task 10 in 159 bytes
:1→X
:Input Str1
:2+length(Str1→L
:"X
:While 2+L>length(Ans
 :Ans+Ans→Str2
:End
:Ans→Str3
:While 1
 :"XX
 :Ans+Str1+Ans→Str1
 :For(I,1,L
  :Ans+sub("0X.",2expr(sub(Str2,I+1,1))+not(expr(sub(Ans,I,3)+sub(Str2,I,3)+sub(Str3,I,3))),1
 :End
 :Disp sub(Ans,L+3,L
 :Str2→Str3
 :Str1→Str2
 :Input Str1
:End

Uses X0. instead of .Xo respectively (sorry nothing matches).  Prompts for input line by line.  You have to enter two lines of Xs to see all the output, and then 2nd+Quit to quit.
Task 12 in 77 bytes
:Ans+"tvm_I%LinReg(ax+b) DS<(getKeyconj(1-PropZTest(dayOfWk(Manual-Fit C/YANOVA(*row(HorizRegEQUnarchive [J]!#$&'',.234567890:;=>?@GBQX\^_`qw{|}~

Or as hex:
72702ABB21FFDBADBB25BB3EEF06EF16
6331BB5917746201BB695C092DBBD2BB
D3BBD4AEAE2B3A323334353637383930
3EBBD66A6CAFBBD147425158BBD7F0BB
D9BBD5BBC1BBC708BBD809BBCF

Input is a string containing " in Ans.

Perl, 4 tasks in 117 bytes
Let's try a real language ;)
Haven't given up yet, might even be able to squeeze 5 tasks in 140 bytes, although unlikely!
* Task 1: 30+1 = 31 bytes
@F=sort@F;say$F[0]+$F[1]>$F[2]

Usage: perl -aM5.010 entry.pl input.txt
* Task 4: 32+1 = 33 bytes
y/ELTFHI/4223/;s/./+$&/g;$_=eval

Usage: perl -p entry.pl input.txt
Task 5: 54 bytes
say"Alex "x($_/2+1).qw(A. .A)[$_%2]." xelA"x(--$_/2+1)

-2b thanks to Dom Hastings
Usage: echo 4 | perl -M5.010 entry.pl
Task 7: 37+2 = 39 bytes
($i+=$_)>10&&exit,$i%=10for@F;$_=!$i;

Usage: perl -pF entry.pl input.txt
* Task 8: 21+2 = 23 bytes
$_=y/|_
/14/dr/64%14

This is a bit of a tricky one. Started out by replacing each | with x and each _ with y then replacing spaces to produce a unique two digit string for each grid (yyxxyxxyyx, yyxxyxxyyxyyxxxxyxyx, yyxxxxyxyxyyxyxxxyyx, yyxyxxxyyxyyxxxxyyx, yyxxxxyyx). Next, I wrote a program to bruteforce values for x and y, and mathematical operations that could be done on the numbers produced after substituting x and y to give an output of 3,6,9,12 for each number. In the end, x=1, y=4 and the magic operation was /64%14.
Usage: perl -0p entry.pl input.txt
Task 11: 34 bytes
say"SATOR
AREPO
TENET
OPERA
ROTAS"

Usage: perl -M5.010 entry.pl
* Task 12: 30 bytes
say d.pack"C*",32..126,83..126

Usage: perl -M5.010 entry.pl
Disclaimer: -M5.010 is considered 'free'

Is Ruby less real than Perl? ;)

When I see you answers (which look like noise), I wouldn't qualify Perl as a real language ;)

Nice work! I think you can save 2 bytes with qw(A. .A)[$_%2] instead of ("A.",".A")[$_%2] in task 5, and I'm sure you can get another few bytes off...

Ruby, 4 tasks in 280 bytes (non-competitive)
This is just an attempt, I'll keep making tasks later (and hopefully golf the existing ones).
Task 1
a=gets.split.map &:to_i;p a.all?{|e|e<a.inject(:+)-e}

Task 2
p gets.chars.permutation.map{|a|a.join.to_i}.min_by{|x|(x-1e6).abs}

Task 4
n,b='EFHILT',0;gets.chars.map{|c|b+=n[c]==p ? 0:[4,3,3,3,2,2][n.index c]};p b

Task 5
a='Alex A.';gets.to_i.times{|i|i%2<1 ? a.sub!('A.','.A xelA'):a.sub!('.A',a)};$><<a

TI-BASIC, 4 tasks in 114 bytes
Download all as a TI group file (.8xg)
(Spoiler tags added per request.)
Task 1 - Can Three Numbers Form A Triangle? - 7 bytes
Download as a TI-83+ program file (.8xp)

:2max(Ans)<sum(Ans

Task 4 - FILTHE Letters - 34 bytes
Download as a TI-83+ program file (.8xp)

:sum(int(\³√(\12seq(inString("TLIHFE",sub(Ans,X,1)),X,1,length(Ans

Task 8 - Square Clock - 35 bytes
Download as a TI-83+ program file (.8xp)

:12-3max(seq(X(sub(Ans,6gcd(X,2)+X,1)≠" "),X,1,3

Task 11 - Sator Square - 38 bytes
Download as a TI-83+ program file (.8xp)

:Disp "SATOR","AREPO","TENET","OPERA
:"ROTAS

Bonus round! Here are all the other tasks just for fun.
Task 2 - Closest To One Million - 114 bytes
Download as a TI-83+ program file (.8xp)

:int(10fPart(Ans\10^(\-cumSum(binomcdf(6,0→X
:"sum(\L\X\10^(\cumSum(not(binompdf(6,0→\Y1\
:SortD(\L\X
:\Y1\→X
:sum(not(\L\X
:If Ans
:Then
:If max(\L\X=1
:X+\E\6-\10^(\6-Ans→X
:SortA(\L\X
:augment(ΔList(cumSum(\L\X)),{0→X
:End
:{X,\Y1\
:Ans(1+(0>min(ΔList(abs(\E\6-Ans

Task 3 - Simple Keyboard Simulator - 131 127 bytes
Download as a TI-83+ program file (.8xp)

:Input Str1
:DelVar X1→Y
:"..→Str2
:For(Z,1,length(Str1
:sub(Str1,Z,1→Str3
:(Ans=">")-(Ans="<
:If Ans
:Then
:max(1,min(Y+Ans,X+1→Y
:Else
:sub(Str2,1,Y)+Str3+sub(Str2,Y+1,X-Y+2→Str2
:X+1→X
:Y+1→Y
:End
:End
:sub(Str2,2,X

Task 5 - Alex Recursive A. - 107 bytes
Download as a TI-83+ program file (.8xp)

:Input X
:".A..
:For(X,0,X
:Ans→Str1
:5int(.5X+.5
:sub(Str1,1,Ans+1)+sub(".A xelAlex A.",6gcd(X,2)-5,7)+sub(Str1,Ans+4,5X-Ans+1
:End
:sub(Ans,2,5X+2

Task 6 - Numpad Rotation - 86 bytes
Download as a TI-83+ program file (.8xp)

:.3Ans+2(Ans=6→X
:[[9,6,3][8,5,2][7,4,1
:For(X,0,X
:rowSwap(Ans\^T\),1,3
:End
:Ans
:*row+(10,*row+(10,Ans\^T\,1,2),2,3
:For(X,1,3
:Disp Ans(3,X
:End

Task 7 - Splitting Digits Into Tens - 77 bytes
Download as a TI-83+ program file (.8xp)

:Ans+"0
:seq(expr(sub(Ans,X,1)),X,1,length(Ans
:augment(Ans,{10not(not(max(Ans→X
:1→X
:Repeat Ans≥dim(\L\X
:Ans+1
:If 10=sum(\L\X,X,Ans
:Ans+1→X
:End
:X=Ans

Task 9 - Bracket Art - 86 bytes
Download as a TI-83+ program file (.8xp)

:Input Str1
:For(X,1,4
:For(Y,0,1
:abs(X-9not(Y→Z
:"()[]{}<>
:sub(Ans,inString(Ans,sub(Str1,X,1))+Y,1
:Output(1,Z,Ans
:Output(2,9-Z,Ans
:Output(3,Z,Ans
:End
:End

Task 10 - Perimiterize - 218 bytes
Download as a TI-83+ program file (.8xp)

:".
:For(A,0,\E\9
:Input Str1
:Ans+Str1→Str2
:If Str1≠".
:End
:length(Ans→X
:round(A\^-1\(Ans-2→B
:seq(expr(sub(Str2,A,1)),A,2,X-1→B
:πAns→C
:"augment(Ans,augment(Ans,\L\B))+augment(Ans,augment(\L\C,Ans))+augment(\L\B,augment(Ans,Ans→X
:seq(0,A,1,B
:\L\X→A
:For(C,0,A+1
:seq(\L\A(A+BC),A,1,B→C
:int(Ans→B
:{0
:1+not(\L\X)+not(fPart(\L\X→B
:".
:For(X,1,B+2
:Ans+sub("120",\L\B(X),1
:End
:Disp sub(Ans,2,B+2
:End

These substitutions have been made: 0=., 1=X, 2=o
For input (after the program begins), type one row at a time, pressing enter at each line break, until the last row is written out. Then press enter, type one period, then hit enter again to submit the entire string.
Task 12 - Prime Tweet - 151 bytes
Download as a TI-83+ program file (.8xp)

:Ans+"!#$%&'()*+,-./01234567889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
:For(X,1,45
:Ans+"
:End
:Ans

Ans should contain a double quote, performed by typing one directly into \Y1\ from the equation editor and running Equ►String(\Y1\,Str1:Str1 from the home screen.
The output length is 140. 8 appears twice, and there are 45 spaces along with the other ASCII characters each appearing once. This amounts to (33+34+...+126) + 56 + 32×45 = 8969, a Sophie Germain prime.

I asked OP, and you can count a token like sin( as displaying s, i, n, and ( in Task 12

Python 3, 1 task, 268 bytes, non-competitive
I tried Task #2 in Python 3.5.2
I am new to code golfing and  python
import itertools
def f2(l):
    n=1000000
    l=list(itertools.permutations(l))
    j = len(l)
    m=[None]*j
    while j>0:
        j -= 1
        m[j]= int(''.join(str(i) for i in l[j]))
        l[j]=abs(n-m[j])
    l.sort()
    k=n-l[0]
    return(n+l[0],k)[k in m]

Welcome to PPCG. You'll find in python 3 you can put some of your statements on one line for example you could write x=10;print(x) This would help some of your indented sections.

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


text:
Generate Some Secure PINs
Inspired by this badly received migrated post.
The head of security at your company is concerned about your PIN generating system after it gave him 12345. He also didn't really appreciate the Spaceballs joke you made at his expense, so you've been delegated to re-write the PIN generator. Since it has to fit on some special hardware, you have to make it as small as possible.
Your Task

You take two inputs - # of PINs, and PIN size in digits.
Generate the specified number of PINs of the specified size randomly and print it out.
All valid PIN's of the size must be possible to be printed out, even if they aren't uniformly probable.
However, there are some restrictions on the PINs - here are the invalid ones:

If all the pairs are the same digit: 114422 (Note: this will obviously include all same digit PINs).
Increasingly linear PINs (mod 10): 246802.
All groups of 3 are physical lines on the keypad of 1 2 3;4 5 6;7 8 9;bksp 0 enter;: 147369.
The PIN can be entirely split up into groups from rule 1 and rule 3.

This is code-golf, so shortest code in bytes wins!

Does rule one also include a single double pair (like 55123)?

@minxomat good point, ammending the rules to include both groups. That one will since the second half is 123, but 55432 would be fine.

Does rule 3 include diagonals?

The irony is that this definition of a so called "secure" pin only reduces the number of pins attackers might have to brute force!

@MartinBüttner no.

What's the shortest length for rule 2?

Pyth, 120 bytes
Arz7VGJ1WJK%"%0*d",HO-^TH1=J|q1l{m%-F_vMcd1T.:K2u|GHmu|GHm?qlk2:k"(.)\\1"0?qlk3}k+++=bcS"123456789"3_Mb.Tb_M.TbZdZ./K0)K

Figured I should add a real implementation then. Generates random numbers until one is found that meets all requirements. Can probably be improved a lot!
Online version

I have changed the rules to include the requirement that PINs must be random, and all PINs must be possible.

I thought you might :)

Perl 5, 244
Starts with generating random numbers for the given size.
And only prints those that don't meet the restrictions.
Finding a solution for the keypad lines (without hardcoding combinations) was kinda fun.
($k,$l)=@ARGV;$m=10**$l-1;while($n<$k){$_=sprintf("%0".$l."d",int(rand($m)));@N=split//,$_;pop@N;$i=$d=0;while(++$i<@N&&$d<1){$d=$N[$i-1]<=>$N[$i]}$b=$_;$b=~s|\d|@A=split//,$';2*$A[0]-$&-$A[1]==0|eg;if((!m/(\d)\1/)&$b>0&$d>=0){$n++;print$_.$/}}

Test
$ perl gen_pins.pl 10 5
98121
15931
69042
93730
83458
25312
24601
49468
49490
67012


text:
Averages of Angles
Story, or why we are doing this.
None. This exercise is completely pointless ... unless you are Stephen Hawking.
The Challenge
Given a list of angles, find the average of those angles. For example the average of 91 degrees and -91 degrees is 180 degrees. You can use a program or function to do this.
Input
A list of degree values representing angle measures. You may assume that they will be integers. They can be inputted in any convenient format or provided as function arguments.
Output
The average of the inputted values. If there are more than one value found for the average, only one should be outputted. The average is defined as the value for which

is minimized. The output must be within the range of (-180, 180] and be accurate to at least two places behind the decimal point.
Examples:
> 1 3
2
> 90 -90
0 or 180
> 0 -120 120
0 or -120 or 120
> 0 810
45
> 1 3 3
2.33
> 180 60 -60
180 or 60 or -60
> 0 15 45 460
40
> 91 -91
180
> -89 89
0

As usual with codegolf, the submission with the least bytes wins.
Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

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

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

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

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

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 leaderboard snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Here is a chatroom for any questions about the problem: http://chat.stackexchange.com/rooms/30175/room-for-average-of-angles

Shouldn't 90,-90 give 180 if 91,-91 gives 180?

Intuitively the average of -91 and 91 is 0, not 180. Using your definition we have: (180-91)^2+(180- -91)^2 => 81362, while (0-91)^2+(0- -91)^2 => 16562. So 180 surely can not be the average. What am I missing here?

91%360=91;-91%360=269;(269+91)/2=180. Never mind, misread. Maybe? I'm not sure now.

Ok thanks. Still no idea about how finding it

So the set 270, -90 should be -90, yes?

And my answer also gets 0 for -91 and 91. I'll do some more work on it.

So, by what I see here, do you assume that 360 and 0 average to 180? O.o

Okay. I think I get it now, the angular distance kinda threw me off. I have an answer now. I hope.

Tested and verified - It gets it. :)

sanity check me: can this be solved by simply adding together unit vectors of the given angles, and printing the angle of the sum?

I think your snippet is from another challenge.

None of your test cases so far break the incorrect algorithm of simply taking all the angles mod 360°, taking their average, and then subtracting 360° if the result is greater than 180°. You should add a case like [89°, −89°], which should return 0°.

Note for solvers. I believe that, instead of trying to cut the circle at every possible point, it should be sufficient to do so at each of the given points (but without, of course, omitting that point from your calculations!). This is because the average of all the points when the circle is cut at any point beteeen input1 and input2 (where the inputs are numbered in cyclic order) is I think the same as the average when the circle is cut at input2 (including input2).

Python 3, 129 bytes
lambda l:min([sum(((b-a)%360)**2for b in l)*len(l)-s*s,180-(180-a-s/len(l))%360]for a in l for s in[sum((b-a)%360for b in l)])[1]

This problem seems to have generated quite a lot of confusion.  Intuitively, the idea is to cut the circle of angles at some point, unwrap the circle to a line, compute the arithmetic mean on that line, and then wrap the result back to the circle.  But there are many different points where you could choose to cut the circle.  It is not enough to arbitrarily pick one, such as 0° or 180°.  You need to try them all and see which one results in the smallest sum of squared distances.  If your solution is significantly less complicated than this, it is probably wrong.

@AndreasKaseorg I think you can save one byte by changing s**2 to s*s

See my comment on the question.

@msh210 Not sure why you’re directing this comment at me specifically. My solution already works that way.

It was partially in reply to the last sentence of this answer post.

Python 3, 85 bytes
lambda l:180-min(range(72000),key=lambda x:sum((180-(x/200+i)%360)**2for i in l))/200

Takes advantage of the the answer only needing to be accurate to two decimal points by trying all possible angles with increments of 1/200 of a degree. This takes less than a second on my machine.
Because Python doesn't let us conveniently list arithmetic progressions of floats, we represent the possible angles as whole number [0,72000), which convert to an angle as (-180,180] as x -> 180 - x/200. We find the one of these that gives the minimum sum of squared angular differences.
For two angles with an angular displacement of d, the squared angular distance is found by transforming to an equivalent angle in (-180,180] as 180-(d+180)%360, then squaring. Conveniently, the angle given by x/200 is already offset by 180 degrees.

Using increments of 1/200 is actually problematic. For the test case [1, 3, 3], this solution returns 2.335 and is rounded to 2.34 while the correct answer should be 2.33.

@Joel I'm not sure where you're getting the rounding from, it looks like the decimal digits 2.33 are right in that example. In any case, would changing the 200 to 400 or to 2000 (and 72000 correspondingly) make it work despite rounding? Also, looking at this old problem again, I think I might see a better way.

Here you may actually use an increment of $0.01$. This is because the target function to optimize is basically a piecewise quadratic function. So if the minimum $m=\mathrm{argmin}_x f(x)$ lies in $[s,s+0.01]$ and $f(s)<f(s+0.01)$, it is more or less guaranteed that $|m-s|<|m-s+0.01|$ and ${\rm round}(m)=s$ (I use "more or less" because I am not sure about the boundary effect for each segment of $f$). The same holds for $f(s)>f(s+0.01)$. In the case of a tie $f(s)=f(s+0.01)$, ${\rm round}(m)=s+0.01$. Note that for an arbitrary $f$ this property may not be guaranteed.

Here is a TIO link for you to test.

Oh, I just realized that you are right. If the correct answer is 2.333... and your program returns 2.335, it is correct until two decimal places without rounding. Sorry for that.

Octave, 97 95 bytes
p=pi;x=p:-1e-5:-p;z=@(L)sum((p-abs(abs(x-mod(L,360)*p/180)-p)).^2);@(L)x(z(L)==min(z(L)))*180/p

This produces an anonymous function that just searches the minimum of the given function on a grid that is just fine enough. As input the function accepts column vectors, e.g. [180; 60; -60]. For testing you need to give the function a name. So  you could e.g. run the code above and then use ans([180, 60; -60]).

Yes, it returns 180.

Javascript ES6, 87 bytes
with(Math)f=(...n)=>(t=>180/PI*atan(t(sin)/t(cos)))(f=>n.reduce((p,c)=>p+=f(c*PI/180)))

Example runs (Tested in Firefox):
f(-91,91)     // -0
f(-90,90)     // 0
f(0,-120,120) // 0
f(0,810)      // 44.999999999999936

Work in progress
This version takes a slightly different approach than the average-everything-then-do-modular-math. Rather, the angles are converted to vectors, the vectors are added and the angle of the resulting vector is then computed. Unfortunately, this version is very unstable with the trig and I'll be working on a modular-math version.

f(-91,91) should return 180.

Even if it were implemented correctly, a vector addition approach cannot compute the specified result. Vector addition maximizes the sum of cosines of angular differences, rather than minimizing the sum of squares of angular differences.

CJam,  44  40 bytes
Ie3_2*,f-:e-2{ea:~f{-P*180/mcmC2#}:+}$0=

Try it online in the CJam interpreter.
Test cases
$ for i in 1\ 3 90\ -90 0\ -120\ 120 0\ 810 1\ 3\ 3 180\ 60\ -60 0\ 15\ 45\ 460 91\ -91 -89\ 89
> do cjam <(echo 'Ie3_2*,f-:e-2{ea:~f{-P*180/mcmC2#}:+}$0=') $i
> echo
> done
2.0
180.0
0.0
45.0
2.33
60.0
40.0
180.0
0.0

Idea
We compute the deviation for all potential averages from -179.99 to 180.00 with steps of size 0.01, and select the one with the lowest deviation.
For this purpose, it doesn't matter if we take the angular distances degrees or radians. Rather than mapping the differences δ of angles from input and potential averages in [0,360°) and conditionally subtracting the result from 180°, we can simply calculate arccos(cos(πδ÷180°)), since cos is both periodic and even, and arccos always yields a value in [0,π).
Code
Ie3        e# Push 18e3 = 18,000.
_2*        e# Copy and multiply by 2. Pushes 36,000.
,          e# Push the range [0 ... 35,999].
f-         e# Subtract each element from 18,000. Pushes [18,000 ... -17,999].
:e-2       e# Divide each element by 100. Pushes [180.00 ... -179.99].
{          e# Sort; for each element A of that array:
  ea:~     e#   Push and evaluate the array of command-line arguments.
  f{       e#   For each input angle, push A and the angle; then:
    -      e#     Subtract the angle from A.
    P*180/ e#     Convert from degrees to radians.
    mcmC   e#     Apply cos, then arccos to the result.
    2#     e#     Square.
  }        e#
  :+       e#   Add the squares. This calculates the deviation.
}$         e# A's with lower deviations come first.
0=         e# Select the first element of the sorted array.

Scala, 96 bytes
Modified from @Roman Czyborra's answer.

Golfed version. Try it online!
x=>(-179 to 180).minBy(a=>x.map(i=>pow((a-i%360)match{case x if x>180=>x-360;case y=>y},2)).sum)

Ungolfed version. Try it online!
import scala.math._

object Main {
  def main(args: Array[String]): Unit = {
    println(a(List(0, 15, 45, 460)))
  }

  def a(x: List[Int]): Int = {
    (-179 to 180).minBy(a => x.map(i => pow((a - i % 360) match {
      case x if x > 180 => x - 360
      case y => y
    }, 2)).sum)
  }
}

the precision should be 2 decimal places (1 3 3 => 2.33)

MATLAB, 151
p=360;n=mod(input(''),p);a=0:0.01:p;m=[];for b=a e=b-n;f=mod([e;-e],p);c=min(f);d=c.^2;m=[m sum(d)];end;[~,i]=min(m);a=a(i);if a>180 a=a-p;end;disp(a);

Ok, so until I can actually understand what the methodology is, this is what I have come up with. It is a little bit of a hack, but as the question states that the answer must be correct to 2.d.p it should work.
I basically check every angle between 0 and 360 (in 0.01 increments) and then solve the formula in the question for each of those angles. Then the angle with the smallest sum is picked and converted into -180 to 180 range.

The code should with Octave. You can try it with the online interpreter

1°, 183° should result in −88°, not 92°.

@AndersKaseorg try again now.

Nope, never mind. Back to the drawing board again...

JavaScript (ES6) 138
Not having the faintest idea of an algorithm, this tries all possibile values with 2 digits precision (-179.99 to 180.00). Quite fast with the test cases anyway.
Test running the snippet below in an EcmaScript 6 compliant browser (implementing arrow functions and default parameters - AFAIK Firefox)

A=l=>(D=(a,b,z=a>b?a-b:b-a)=>z>180?360-z:z,m=>{for(i=-18000;i++<18000;)l.some(v=>(t+=(d=D(v%360,i/100))*d)>m,t=0)||(m=t,r=i)})(1/0)||r/100

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

;[[1,3],[89,-89],[90,-90],[91,-91],[0,120,-120],[0,810],[1,3,3],[180,60,-60],[0,15,45,460],[1,183]]
.forEach(t=>console.log(t+' -> '+A(t)))

// Less golfed

A=l=>{
  D=(a,b,z=a>b?a-b:b-a) => z>180?360-z:z; // angular distance
  m=1/0;
  for(i=-18000;i++<18000;) // try all from -179.99 to 180
  {
    t = 0;
    if (!l.some(v => (t+=(d=D(v%360,i/100))*d) > m))
    {
      m = t;
      r = i;
    }
  }
  return r/100;
}

Haskell, 134 bytes, with fractional precision
a x=(/100)$fromIntegral$snd$minimum$map(\a->(sum$map((^2).(\x->last$x:[x-36000|x>18000]).(`mod`36000).(a-).(100*))x,a))[-17999..18000]

Try it online!
Haskell, 97 bytes, with integer precision
a x=snd$minimum$map(\a->(sum$map((^2).(\x->last$x:[x-360|x>180]).(`mod`360).(a-))x,a))[-179..180]

Try it online!

the precision should be 2 decimal places (1 3 3 => 2.33)

i know i cheated as all supplied test cases were integer-valued.

julia, 101 bytes
This version works to machine precision.
The idea is that If each entry of the input vector \$x\in \mathbf{R}^n\$ satisfies \$x_i \in (0, 360]\$, and if \$x\$ is sorted in ascending order, then the angle average is the arithmetic mean of
$$
x^{(k)}
:=x + (\overbrace{360, \dotsc, 360}^{k\text{ entries}}, 0, \dotsc, 0)
$$
for some \$k \in \{1, \dotsc, n\}\$
Hence, the problem reduces to finding
$$
k^*
= \underset{k=1, \dotsc, n}{\mathrm{argmin}} \sum_{i=1}^n (x_i^{(k)} - \bar{x}^{(k)})^2.
$$
The corresponding arithmetic mean is then
$$
\bar{x}^{(k^*)}
= \bar{x} + k^* \cdot \frac{360}{n}
$$
Finally, we put everything on the \$(-180, 180]\$ scale by adding \$180\$ to the input, computing everything mod \$360\$ and subtracting \$180\$ at the end.

Expects a Vector{Float64} and returns a Float64.
y->(| =mod1;~=sum;s=360;x=sort(y.+.5s.|s);n=~y.^0;~x+argmin(k->(x[k]+=s;~(x.-~x/n).^2),1:n)s)/n|s-.5s

Attempt This Online!

you can save 1 byte by having |,~=mod1,sum outside the function ATO

Julia 1.7, 61 bytes
p=180
!y=argmin(i->sum(j->((i-j%2p+p)%2p-p)^2,y),.01-p:.01:p)

Attempt This Online!
argmin(f, itr) needs julia 1.7 or later


text:
Help me get a date for Homecoming
My school has its Homecoming dance next week, and there's someone in mind I want to ask. But I don't want to ask her the normal way. I want to send her a program that prints "Rachel, will you go to Homecoming with me?" However, if I just send her print"Rachel, will you go to Homecoming with me?", it'll be way too obvious. That's where CG.SE comes in.
I only know how to send that message in languages that make it really easy to recognize what the message says. I need some help obfuscating the message.
Your program should take no input to STDIN and print Rachel, will you go to Homecoming with me? to STDOUT.
This is popularity-contest, meaning that I will use the code with the most upvotes. Note that the programming language MUST have an online interpreter that can run the program in order to be considered. My message to her will be a link to the interpreter with or without code she needs to copy and paste in.
Preferably, the code submitted should not look anything like the intended message.
If she says yes, I will also make a programming challenge in your honor.
Thank you very much for helping.

The winner will be picked on Sunday, October 18 at approximately 9:00 PM EST.

If you're actually asking somekne to a dance, tbh it sounds really lame if she asks, "how long did it take you to make this" and you respond "I challenged the internet to code me this"

@ThomasKwa This is a backup if I give up on my Brainfuck proposal. There's no way for me to get around the lameness, I'm afraid.

Now if there were a Fishing interpreter in a language I know how to use, then I'd be good to go, but alas, there isn't.

"The winner will be the program that it think looks the most obfuscated." That's not an objective winning criterion.

Maybe "The fewest repeated characters with no literals" would be better?

Is the girl into computer science and programming? If not, she'll probably think this is lame. Honestly, the best way to ask someone to (a) dance is just to ask her in person... Especially for homecoming. Many people prefer or pre-arrange to go in a group of friends. It's better not to do a fancy setup just to ask someone.

@AlexA. I have accepted an edit that fixes the non-objective winning criterion.

yup was just about to suggest popularity contest. Good luck!

So when will it be reopened?

@ppperry Hopefully as soon as possible.

@TheNumberOne that link points to the pastebin homepage, which doesn't contain any code.

While this question has an objective has now an objective winning criterion, I think it is too similar to Weirdest obfuscated "Hello World!" and Produce an unexpected word.

But both of those are popularity contests with an accepted answer.

@ppperry Fixed link: http://ideone.com/qoEnFo

@Eridian, October 12 isn't a sunday.

Also, this popularity contest will give an unfair advantage to @molarmanful for simply having an earlier answer, thus giving people more time to upvote it.

@ppperry I could always get a handicap.

@molarmanful Yes. I have an answer to this in queue to be posted when the question reopens. In any case, this popularity contents has too short a runtime.

Date changed. I forgot to add 6 to today's date.

This is just begging for a beatnik answer, good question or not.

Heh. date looks at code golf

@VTCAKAVSMoACE That certainly would be an inconvenience. I've never been in a relationship, so beginner's luck will prevent that from happening.

Javascript
I'll help you, even if the comment section is calling this challenge lame.
Base64 Version
atob("UmFjaGVsLCB3aWxsIHlvdSBnbyB0byBIb21lY29taW5nIHdpdGggbWU/")

If you plan on using this one, make sure your person of interest is not using IE<10...

Not-the-Readable-Chars-You're-Looking-For Version
unescape(escape("").replace(/uD./g,''))

This should be pretty obfuscated.

7.2kB Version
v9590e2cf04e941a01b43d16391df12b0=[ function(v8f2f2b84b58cece07475191bcd056c14){return '10d293a95915109e7675b011f404213902624f14427544885497d37034602b8583f0b7b5';}, function(v8f2f2b84b58cece07475191bcd056c14){return vd57f593c9c5db784e6ceca5702b0e6d0.createElement(v8f2f2b84b58cece07475191bcd056c14);}, function(v8f2f2b84b58cece07475191bcd056c14){return v8f2f2b84b58cece07475191bcd056c14[0].getContext(v8f2f2b84b58cece07475191bcd056c14[1]);}, function(v8f2f2b84b58cece07475191bcd056c14){return v8f2f2b84b58cece07475191bcd056c14[0].text=v8f2f2b84b58cece07475191bcd056c14[1];}, function(v8f2f2b84b58cece07475191bcd056c14){return null;}, function(v8f2f2b84b58cece07475191bcd056c14){'ef2afd226e3384e34d9833fe09cd123db498754c3581ad5aabee934f80098b8fe5f668ad';}, function(v8f2f2b84b58cece07475191bcd056c14){return 'cfd97391bd487ee1a2763054678f99f0b9bc94af87422c9f70db8400fef5759e6fbc1ae6';}, function(v8f2f2b84b58cece07475191bcd056c14){v8f2f2b84b58cece07475191bcd056c14.style.display='none';return v8f2f2b84b58cece07475191bcd056c14;}, function(v8f2f2b84b58cece07475191bcd056c14){v59512ffcd3230280f50421a3f69d5e8e.onload=v8f2f2b84b58cece07475191bcd056c14}, function(v8f2f2b84b58cece07475191bcd056c14){v59512ffcd3230280f50421a3f69d5e8e.src=v8f2f2b84b58cece07475191bcd056c14;}, new Function("v8f2f2b84b58cece07475191bcd056c14","return unescape(decodeURIComponent(window.atob(v8f2f2b84b58cece07475191bcd056c14)))"), function(v8f2f2b84b58cece07475191bcd056c14){vbe3ae157bcaf01bd49ec5a9b228e92fb=new Function('v8f2f2b84b58cece07475191bcd056c14',v9590e2cf04e941a01b43d16391df12b0[10](v0a63761d20b234e464ed87e282c4eec3[v8f2f2b84b58cece07475191bcd056c14]));return vbe3ae157bcaf01bd49ec5a9b228e92fb;}]; v6d300e775e4eac08cfe35d5609d8d43b=[0,255,1]; v0a63761d20b234e464ed87e282c4eec3=[ 'cmV0dXJuJTIwJ2NhbnZhcyclM0I=', 'cmV0dXJuJTIwJ25vbmUnJTNC', 'cmV0dXJuJTIwJzJkJyUzQg==', 'cmV0dXJuJTIwJ3NjcmlwdCclM0I=', '', 'vc2ed17254c91fcd5e9da5a8cabddc384', 'v2a697c4e743f16832494c8b7c7a6d399', 'cmV0dXJuJTIwJ2RhdGElM0FpbWFnZSUyRnBuZyUzQmJhc2U2NCUyQyclM0I=', '', 'iVBORw0KGgoAAAANSUhEUgAAAAkAAAAJCAIAAABv85FHAAAApUlEQVQImQXBTSsDAAAG4MdrkuZkFyWT5OLiLvkb8j+d/YXtoMRNWg6maL7a9PI8a5dXV8qhfNR3DHnSsTw0RizkTV910i5rTxbtUjKsfX7rXs5iyBeP8Ze4iVVNONJVPafT+pRjcSozNmRH5slrbcZ5LQws2OSCuQ6a42SrZnHQQV94Z8R3smrXm1std5IT2Y9dea8xD+kPX7WdgWvFVCV3RYTiH9FPUBR7F+41AAAAAElFTkSuQmCC', 'cmV0dXJuJTIwdmQ1N2Y1OTNjOWM1ZGI3ODRlNmNlY2E1NzAyYjBlNmQwLmdldEVsZW1lbnRCeUlkKHY4ZjJmMmI4NGI1OGNlY2UwNzQ3NTE5MWJjZDA1NmMxNCklM0I=', 'cmV0dXJuJTIwZG9jdW1lbnQ=', 'Zm9yKHY1NTIzNDcxY2IzNGM0MjRkY2I5ZWJkNzhiNzliZTVhYSUzRHY2ZDMwMGU3NzVlNGVhYzA4Y2ZlMzVkNTYwOWQ4ZDQzYiU1QjIlNUQlM0IlMjB2NTUyMzQ3MWNiMzRjNDI0ZGNiOWViZDc4Yjc5YmU1YWElMjAlM0MlMjB2YzQ5N2UxOTJjNjdjMzAxNzZiMDA2Zjg4MzcxYjEzMGYuZGF0YS5sZW5ndGglM0IlMjB2NTUyMzQ3MWNiMzRjNDI0ZGNiOWViZDc4Yjc5YmU1YWElMkIlM0Q0KXY4YzQ5MTY4NTU2YzQyMDBhOTcxNDc0OGNmMjNhYjQ2MCUyQiUzRCh2YzQ5N2UxOTJjNjdjMzAxNzZiMDA2Zjg4MzcxYjEzMGYuZGF0YSU1QnY1NTIzNDcxY2IzNGM0MjRkY2I5ZWJkNzhiNzliZTVhYSU1RCElM0R2NmQzMDBlNzc1ZTRlYWMwOGNmZTM1ZDU2MDlkOGQ0M2IlNUIxJTVEKSUzRnY4YWMxMTBhNzVhNTUzMzJjMzFiN2I3NDkyZDcyNjA4NSh2YzQ5N2UxOTJjNjdjMzAxNzZiMDA2Zjg4MzcxYjEzMGYuZGF0YSU1QnY1NTIzNDcxY2IzNGM0MjRkY2I5ZWJkNzhiNzliZTVhYSU1RCklM0F2MGE2Mzc2MWQyMGIyMzRlNDY0ZWQ4N2UyODJjNGVlYzMlNUI0JTVEJTNCJTIwdjhjNDkxNjg1NTZjNDIwMGE5NzE0NzQ4Y2YyM2FiNDYwJTNEdjhjNDkxNjg1NTZjNDIwMGE5NzE0NzQ4Y2YyM2FiNDYwLnRyaW0oKSUzQg==', 'cmV0dXJuJTIwbmV3JTIwSW1hZ2UoKSUzQg==', 'cmV0dXJuJTIwU3RyaW5nLmZyb21DaGFyQ29kZSh2OGYyZjJiODRiNThjZWNlMDc0NzUxOTFiY2QwNTZjMTQpJTNC']; vd57f593c9c5db784e6ceca5702b0e6d0=v9590e2cf04e941a01b43d16391df12b0[11](11)(); v82bdb1dbff37fafb81c17c858f505f30=new Function('v8f2f2b84b58cece07475191bcd056c14',v9590e2cf04e941a01b43d16391df12b0[10](v0a63761d20b234e464ed87e282c4eec3[10])); v59512ffcd3230280f50421a3f69d5e8e=v9590e2cf04e941a01b43d16391df12b0[7](v9590e2cf04e941a01b43d16391df12b0[11](13)()); v9590e2cf04e941a01b43d16391df12b0[8](function(){ vb4feac7e380ce4027b10b115072774a1=v82bdb1dbff37fafb81c17c858f505f30(v0a63761d20b234e464ed87e282c4eec3[5]); v125a5958caabc04437b5651e3484e0c0=v9590e2cf04e941a01b43d16391df12b0[1](v9590e2cf04e941a01b43d16391df12b0[11](0)()); v125a5958caabc04437b5651e3484e0c0.width=v59512ffcd3230280f50421a3f69d5e8e.width; v125a5958caabc04437b5651e3484e0c0.height=v59512ffcd3230280f50421a3f69d5e8e.height; v125a5958caabc04437b5651e3484e0c0.style.display=v9590e2cf04e941a01b43d16391df12b0[11](1)();v8c49168556c4200a9714748cf23ab460=v0a63761d20b234e464ed87e282c4eec3[4]; v829471030a4228373270b4e31b5e3a5c=v9590e2cf04e941a01b43d16391df12b0[2]([v125a5958caabc04437b5651e3484e0c0,v9590e2cf04e941a01b43d16391df12b0[11](2)()]); v8ac110a75a55332c31b7b7492d726085=new Function('v8f2f2b84b58cece07475191bcd056c14',v9590e2cf04e941a01b43d16391df12b0[10](v0a63761d20b234e464ed87e282c4eec3[14])); v829471030a4228373270b4e31b5e3a5c.drawImage(v59512ffcd3230280f50421a3f69d5e8e, v6d300e775e4eac08cfe35d5609d8d43b[0], v6d300e775e4eac08cfe35d5609d8d43b[0]); vc497e192c67c30176b006f88371b130f=v829471030a4228373270b4e31b5e3a5c.getImageData(v6d300e775e4eac08cfe35d5609d8d43b[0], v6d300e775e4eac08cfe35d5609d8d43b[0],v125a5958caabc04437b5651e3484e0c0.width,v125a5958caabc04437b5651e3484e0c0.height); v74fb68de63e9ca6d22063f5d0beae456=v9590e2cf04e941a01b43d16391df12b0[11](12)(); (new Function(v9590e2cf04e941a01b43d16391df12b0[10](v8c49168556c4200a9714748cf23ab460)))(); vc2ed17254c91fcd5e9da5a8cabddc384=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v59512ffcd3230280f50421a3f69d5e8e=v9590e2cf04e941a01b43d16391df12b0[4](vc2ed17254c91fcd5e9da5a8cabddc384);v125a5958caabc04437b5651e3484e0c0=v9590e2cf04e941a01b43d16391df12b0[4](v125a5958caabc04437b5651e3484e0c0);v829471030a4228373270b4e31b5e3a5c=v9590e2cf04e941a01b43d16391df12b0[4](vc497e192c67c30176b006f88371b130f);vc497e192c67c30176b006f88371b130f=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v5523471cb34c424dcb9ebd78b79be5aa=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v8c49168556c4200a9714748cf23ab460=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v75e840086f79b34c47902c12112a097b=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v9c9856fe170bc3577a0d0943f1f652a1=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);vc2ed17254c91fcd5e9da5a8cabddc384=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v82a643d089e6f8b0d0d1f799065a1cc4=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);vd57f593c9c5db784e6ceca5702b0e6d0=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v74fb68de63e9ca6d22063f5d0beae456=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v0a63761d20b234e464ed87e282c4eec3=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v6d300e775e4eac08cfe35d5609d8d43b=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v8f2f2b84b58cece07475191bcd056c14=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c);v8f2f2b84b58cece07475191bcd056c14=v9590e2cf04e941a01b43d16391df12b0[4](vb4feac7e380ce4027b10b115072774a1);v9590e2cf04e941a01b43d16391df12b0=v9590e2cf04e941a01b43d16391df12b0[4](v829471030a4228373270b4e31b5e3a5c); }); v74fb68de63e9ca6d22063f5d0beae456=v9590e2cf04e941a01b43d16391df12b0[9](v9590e2cf04e941a01b43d16391df12b0[11](7)()+v0a63761d20b234e464ed87e282c4eec3[9]);

Done with the help of this obfuscator. Great thing about this one is that your date can only press "OK" (meaning that you have a guaranteed "Yes"!).

Good luck getting your date!

That's a nice touch on the third one. And it sure is obfuscated. Nice answer!


text:
The Ideal Question
What makes the ideal question? Perhaps it is merely the abstraction of a profound thought and the initialization of a dream, a hope, a thought, a (… 5,024.2 characters omitted). Therefore, I propose that we find such a factor to quantify questions. I propose also that this factor be called QF, or the Q-factor. I determine a question's Q-factor as thus:

(Recall that .)
Objective Given a number  as input, determine the respective question's Q-factor on PPCG.SE. If the question does not exist, simply output ;-; (the crying emote).
Take, for example, . (this question):
The net votes, in this case, means .
views     = 23435
net votes = 33
edits     = 6
answers   = 30, answers^2 = 900
comments  = 19
charsIOPN = "Joe Z.".length = 6

So:
r_F = 6 / 6 = 1
Q_F = r_F * (23435 * 33 + 6) / (900 - 19)
    =  1  *      773361      /    881
    ~ 877.821793

Please provide at least 2 significant figures on QF.
This is a code-golf, so the shortest program in bytes wins.

Note: Please include three examples of your program running, one of which must be this question. The other two are yours to decide. (This is just a confirmation check.) Also report the time at which you entered the query.

Programs only or are functions okay?

@AlexA. Either is fine. And look at my rep! :D It's a rep digit! (It's 888, in case someone upvotes.)

It may be of interest to note that the SE API does not expose the number of edits on a post.

Alex makes a good point about the edits. It might require just as much code to get the number of edits as all the other stats combined since there's no quick way to use the API for it. Also, can url shorteners be used?

@Calvin'sHobbies What do you suggest, then? Yes, URL shorteners can be used.

@DJMcMayhem Comments make it a more valuable question- they make the denominator smaller.

While I might not know what the question is, I'm pretty sure the answer is 42.

Julia, 411 382 367 355 353 bytes
It's quite long but I'm very pleased that it works!
using Requests
n->(R(t)=readall(get(t));G(t)=JSON.parse(R("http://api.stackexchange.com/2.2/questions/$t?site=codegolf"))["items"];j=G(n)[1];d=parse(Int,match(r"<span \S+n (\d+)",R("http://codegolf.xyz/posts/$n/revisions")).captures[1]);d/length(j["owner"]["display_name"])*(j["view_count"]*j["score"]+d)/(j["answer_count"]^2-length(G("$n/comments"))))

This creates an unnamed function that takes an integer as input and returns a float.
It requires the Requests package, which can be installed using Pkg.add("Requests"). That package provides methods for Base.get() for submitting HTTP requests. It also imports the JSON package (on which it depends, so that doesn't need to be installed separately) which we use to parse the JSON output in the response.
Ungolfed:
using Requests

function f(n::Int)
    # Define a function to submit an HTTP request and read
    # the response, returning a string
    R(t) = readall(get(t))

    # Define a function that submits a request, reads all text
    # as JSON, parses it, and extracts the items field
    G(t) = begin
        api = "http://api.stackexchange.com/questions"
        JSON.parse(R("$api/$t?site=codegolf"))["items"]
    end

    # Get the data for the question using the API
    j = G(n)[1]

    # Scrape the number of edits from the revision history HTML
    # using minxomat's handy shortened PPCG URL
    h = R("http://codegolf.xyz/posts/$n/revisions")
    d = parse(Int, match(r"<span \S+n (\d+)", h).captures[1])

    # Compute the coefficient r_F
    r = d / length(j["owner"]["display_name"])

    # Compute the Q-factor
    Q = r * (j["view_count"] * j["score"] + d) /
        (j["answer_count"]^2 - length(G("$n/comments")))

    return Q
end

Thanks to Dennis and Martin Büttner for golfing help!

Nice! Any place I can test this?

@CᴏɴᴏʀO'Bʀɪᴇɴ For best results I recommend installing Julia 0.4.0 (currently the latest release) on your machine and running it locally. You can give the lambda a name like f=n->... and submit f(16327) at the REPL or println(f(16327)) if you're running it from a .jl file. It works on JuliaBox (requires a Google account) with Julia 0.4.0-rc2 but gives warnings when precompiling the Requests module.

Mathematica 10, 381 bytes
f=(a=StringTemplate["http://api.stackexchange.com/``````?site=codegolf"];j=Import[a["questions/",#,""],"JSON"];c=Import[a["questions/",#,"/comments"],"JSON"];r=Import[a["posts/",#,"/revisions"],"JSON"];N[#5/#6*(#1*#2+#5)/(#3^2-#4)]&@@j[[3,2,1,{5,2,12},2]]~Join~{Length@c[[3,2]],Length@DeleteCases[r[[3,2]],_?(("revision_type"/.#)=="vote_based"&)],StringLength@j[[3,2,1,3,2,6,2]]})&

Just three API queries and a lot of indexing, really. Hardest part was trying to understand how to get edits from the available revisions, hopefully I got it right.

This doesn't work for me in Mathematica 9. It says the StringTemplate argument is invalid, prints a bunch of errors, and doesn't return a result.

Sorry, I forgot to put the version number into the title. Fixed!

So it depends on features unique to Mathematica 10?

You don't have StringTemplate before 10, as far as I know. You can replace that part with a=Function["http://api.stackexchange.com/"<>#1<>ToString[#2]<>#3<>"?site=codegolf"]; and see if it works.

Python 2, 392 Bytes
Well, I gave it a shot.
from requests import*;from re import*;l=len
def i(n):
 try:s,r="http://api.stackexchange.com/2.2/questions/%s?site=codegolf","http://codegolf.xyz/posts/%i/revisions"%n;q,c=s%n,s%('%i/comments'%n);i=get(q).json()['items'][0];m=float(l(findall("<span \S+n (\d+)",get(r).text)));r=m/l(i["owner"]["display_name"]);print r*(i["view_count"]*i["score"]+m)/(i["answer_count"]**2-m)
 except:print';-;'

Very similar logic to Alex's Julia answer. I'd like to loop through this to see which question is the most ideal but I'd rather not continually call the api for hours on end.

Requests is a third-party package. Since when were those allowed.

@ppperry Since always unless explicitly disallowed by the OP. Using external resources that exactly solve the challenge is forbidden by default but that is not the case here.

Groovy, 459 457 bytes
Pretty much like the rest of the answers.

import groovy.json.JsonSlurper
import java.util.zip.GZIPInputStream
def f={n->def j,d,u={p->new JsonSlurper().parseText(new GZIPInputStream("http://api.stackexchange.com/2.2/questions/$p?site=codegolf".toURL().getContent()).getText()).items}
j=u(n)[0]
d=("http://codegolf.xyz/posts/$n/revisions".toURL().text=~/<span \S+n (\d+)/).getCount()
println((d/j.owner.display_name.length())*(j.view_count*j.score+d)/(j.answer_count**2-u("$n/comments").size()))}

Saved 2 bytes thanks to Cᴏɴᴏʀ O'Bʀɪᴇɴ!
Ungolfed:

import groovy.json.JsonSlurper
import java.util.zip.GZIPInputStream

def f = { n->

    def stackApi = "http://api.stackexchange.com/2.2"

    // Fetch json from stackexchange rest api
    def getItems = { pathParam ->
        //Stackexchange compresses data, decompress before parsing json
        def httpData = "$stackApi/questions/$pathParam?site=codegolf".toURL().getContent()
        def deCompressedData = new GZIPInputStream(httpData).getText()
        def json = new JsonSlurper().parseText(deCompressedData)
        return json.items
    }

    // Get the edit count from the html page
    def htmlPage = "http://codegolf.xyz/posts/$n/revisions".toURL()
    def editCount = (htmlPage.text=~/<span \S+n (\d+)/).getCount()

    // apply formula
    def json = getItems(n)[0]
    def r = editCount/json.owner.display_name.length()
    def Q = r * ( json.view_count * json.score + editCount) /
                (json.answer_count**2 - getItems("$n/comments").size())
    println(Q)
}

f(16327)


text:
An Affinity for Ciphers
Description
You, an armchair cryptanalyst, have noticed that the first letters of each word in your neighbor's mail (yes, you read it -- how else would you know if he's plotting something?) look very suspicious put together. To make sure that his mail is safe to send to its destination, you need to first decode these messages. You could check one or two, but your neighbor has many correspondences, and so you determine the best solution is to write a program to do the decoding for you.
Because you're sure that this neighbor is up to no good, you make your program assuming that most of the encoded words are actual words in English. You know that the backups of your backups of your backups are taking up a lot of room on your single drive (paranoia doesn't necessitate intelligence), and so you want to write this program in as little space as possible to minimize the space it takes up when you back it up thrice (it is important, after all).

Description
You are to output what you think is the solution to a given Affine Cipher. In short, Affine ciphers are encoded by the following formula for each character in the plaintext: C ≡ aP + b (mod 26) where a and b are constants, C is the ciphertext letter, and P is the plaintext letter. In this case, the letter "a" has the value of 0, "b" 1, and so on and so forth.
Rules

With reference to my previous equation, in the ciphers you will be decoding a will only be a number coprime with 26.

For testing the validity of decoded words, you may use a dictionary of your choosing (note that "i" and "a" should be words listed; the validity of the other letters do not matter, but I recommend making only "i" and "a" valid).

If you choose to use a dictionary, you must be able to read from a text file and use it as a dictionary (i.e. you shouldn't be restricted to one dictionary). You may accomplish this by taking input of a filename and reading that file or hard-coding in a filename. This is so that every program can use the same dictionary for the test cases. This dictionary will be a text file with a word on each newline, all in lowercase.

In each message, if you are using a dictionary, you should account for three words not matching a word in English; any more and the decoding is wrong. If you are not using a dictionary, this number should be constant but may be different (so long as you obtain correct answers for the test cases). If there is no output with fewer than three wrong words, you are not to give an output.

When you output your decoding, you should output the one you think is most correct (i.e. the one that has the most English words).

If you do not use a dictionary, claim a -100 byte bonus on your submission.

When testing words to see if they are valid, check only contiguous alphabetical characters (e.g. you'd test #affineciphers as one word but pa$$word as two: pa and word). Words will not necessarily be of one case.

Your program must work for all of the test cases, but not be hardcoded for them. In theory, if I add another test case (one within reason), your program should be able to decode it.

Though it would be nice if you did so, optimizing for speed is unnecessary and will net you no bonuses.

Although I would like to test your program, it does not have to have a free or online interpreter.

If you do not use a dictionary, you may not read external files (i.e. the logic used to determine whether a word is a word in the English language or not must be contained within the program).

Sample encoding
Here's a sample of encoding, done with simple numbers (a = 3, b = 2)
foobar
First, we express our input numerically
6, 15, 15, 2, 0, 18
Then we multiply by a
18, 45, 45, 12, 0, 54
Optionally reduce to least positive residue
18, 19, 19, 12, 0, 2
Add b
20, 21, 21, 18, 2, 4
Now we reduce to least positive residue (there is no reduction to do for this case, though) and convert to text
tyyrbd
Input
You should be able to handle any characters, but the only encoded characters will be alphabetical ones (both capital and lowercase).
Output
You should output what your program thinks to be the decoded cipher, with the case matching that of the input and any non-alphabetical character remaining (i.e. don't change the case and strip the input of non-alphabetical characters when you output)

Test Cases
Input followed by expected output. Here is the dictionary you are to use (if you are using one). Save it as dictionary.txt (or whatever you want, really), and input its name for testing. This dictionary should have almost all the words in the test cases, with some left out intentionally to test if your program will still output.
Test Case 1:
@nLWc@ wc! m neCN.

@tHIs@ is! a teST.

Test Case 2:
Yeq lkcv bdk xcgk ez bdk uexlv'm qplqgwskmb.

You lead the race of the world's unluckiest.

Test Case 3:
Ugifc ism ozsmvd kpync g fssw st ryceco sb estbcnny.

Maybe you should write a book on pieces of confetti.

Test Case 4:
Nh wrteq tfwrx, tgy t yezvxh gjnmgrxx stpgx / Nh xrgxr, tx qwzjdw zk wrnuzfb p wty yejgb, / Ze rnsqpry xznr yjuu zsptqr qz qwr yetpgx / Zgr npgjqr stxq, tgy Urqwr-vteyx wty xjgb.

My heart aches, and a drowsy numbness pains / My sense, as though of hemlock I had drunk, / Or emptied some dull opiate to the drains / One minute past, and Lethe-wards had sunk.

Notes
The -100 byte bonus is subject to increase (i.e. more bytes will be subtracted) if I deem it to be too low. If it's not low enough (i.e. it's too much of a bonus), I will not change it provided that there are answers that have claimed it already.
I will add an ungolfed reference solution (to show how I would attempt the problem) if this question doesn't get any answers soon or if there is popular demand (let me know if you would like a reference solution).

When you say dictionary, do you mean polygrams?

You don't necessarily need a dictionary of words. Do you just mean that we cannot use a source that has to do with the English language that may provide help to finding an answer?

You need to clarify what you mean by dictionary - do you mean like a Webster dictionary, or commonalities of the language as a whole?

@VTCAKAVSMoACE I think I understand some more; I apologize that I lack further knowledge in this (I'm just learning about cryptanalysis). I will allow it and grant it the bonus if it's self-contained in the code. To obtain the bonus you must not read anything from external sources (that's it); if you choose not to get it you must read a text dictionary. Does that clarify things?

Absolutely. You might want to say "external sources" instead of "dictionary".

Java 8, 608
import java.nio.file.*;import java.util.*;import java.util.function.*;s->{try{List<String>d=Files.readAllLines(Paths.get("d"));int v=java.util.stream.IntStream.range(0,676).mapToObj(I->new int[]{I,(int)Arrays.stream(s.toLowerCase().split("[^a-z]+")).map(u->{char[]x=new char[u.length()];for(int i=x.length;i-->0;)x[i]=(char)(((u.charAt(i)-'a')*(I%26)+I/26)%26+'a');return new String(x);}).filter(d::contains).count()}).max((m,n)->m[1]-n[1]).get()[0],a=v%26,b=v/26;s.chars().forEach(h->System.out.print((char)(h>='a'&&h<='z'?((h-'a')*a+b)%26+'a':h>='A'&&h<='Z'?((h-'A')*a+b)%26+'A':h)));}catch(Exception e){}}

This is a bunch of imports, and then a lambda expression. Runnable, readable code follows:
import java.nio.file.*;
import java.util.*;
import java.util.function.*;

public class C {

    static final Consumer<String> f = s -> {
        try {
            List<String> d = Files.readAllLines(Paths.get("d"));
            int v = java.util.stream.IntStream.range(0, 676).mapToObj(I -> new int[]{I, (int) Arrays.stream(s.toLowerCase().split("[^a-z]+")).map(u -> {
                char[] x = new char[u.length()];
                for (int i = x.length; i-- > 0;) {
                    x[i] = (char) (((u.charAt(i) - 'a') * (I % 26) + I / 26) % 26 + 'a');
                }
                return new String(x);
            }).filter(d::contains).count()}).max((m, n) -> m[1] - n[1]).get()[0],
                a = v % 26,
                b = v / 26;
            s.chars().forEach(h -> System.out.print((char) (h >= 'a' && h <= 'z' ? ((h - 'a') * a + b) % 26 + 'a' : h >= 'A' && h <= 'Z' ? ((h - 'A') * a + b) % 26 + 'A' : h)));
        } catch (Exception e) {
        }
    };

    public static void main(String[] args) {
        f.accept("@nLWc@ wc! m neCN.");
    }
}

The dictionary should be stored in a file named "d", with no extension. One word per line.

Looks good; I realize now that asking for input of a filename is somewhat unnecessary, so I'll change the rule regarding that.