text:
Help! My calculator broke! (Turn integer expression into calculator keystrokes)
Introduction
Help! I accidentally dropped my TI-84 calculator out my window (don't ask how) and it broke. I have a math test tomorrow and the only calculator I can find is one with these buttons:
7 8 9 +
4 5 6 -
1 2 3 *
0   = /

My math test is a review test on evaluating expressions. I need a program to take an expression such as 1+(5*4)/7 and convert it to the keystrokes needed to solve it on my spare calculator. (And in case you were wondering, this actually happened to me).
Challenge
Given a non-empty input string containing only the characters 0-9, (, ), +, -, *, and /, output the keystrokes in a space-separated string (eg. 1 + 3 / 3 =). There must always be an equal sign at the end of the output. Standard loopholes are not allowed.
Examples:

Input: 1+(5*4)/7, Output: 5 * 4 / 7 + 1 =
Input: 6*(2/3), Output: 2 / 3 * 6 =
Input: (7-3)/2, Output: 7 - 3 / 2 =

To make this challenge easier:

You may assume that the input has a series of keystrokes linked to it that does not require clearing the calculator (1-(7*3) is not valid since it would require you to find 7 * 3, then clear the calculator to do 1 - 21. All the above examples are valid since there is one, continuous output that does not require the user to clear the calculator and remember a number).
You may assume that there will only be a single integer after a /, as having an input such as 21/(7*3) would not pass the first assumption either.
You may assume that there will always be a * between an integer and a left parentheses (Valid: 6*(7), Invalid: 6(7)).
You may assume the input always produces integer output.
You may assume the input only has three levels of parentheses.

Non-examples

2-(14/2) as you would have to do 14 / 2, then clear, then 2 - 7.
36/(2*3) as you would have to do 2 * 3, then clear, then 36 / 6.
1024*4/(1*2+2) as you would have to do 1*2+2, then clear, then 1024 * 4 / 4.

Bonuses

-5% if your program can recognize parentheses multiplication (it knows that 6(7)=6*(7)).
-5% if your program can handle input with decimal numbers (3.4, 2.75, 7.8) and the output includes . (as there must be a . key on my spare calculator in this case).
-5% if your program can handle unlimited levels of parentheses.

This is code-golf, shortest code in bytes (including the bonuses) wins!
Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
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

var QUESTION_ID=61751,OVERRIDE_USER=141697;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

You're allowed to run programs but can't use them to run the actual equation? 0.o

@Vɪʜᴀɴ You're going to have to ask my math teacher on that, I didn't understand it either.

Do we need to handle order of operations?

@ThomasKwa yes order of operations should be handled

Do we need to handle expressions like 3*2+(5)? The expression can be translated to 3 * 2 + 5 =, but the parentheses were not executed first.

Yes. According to order of operations 3*2+(5) does equals 3 * 2 + 5, therefore it is able to be solved without clearing the calculator.

Do we need to handle 1-(2-3) (distributing the -)?

@ThomasKwa no. You would have to memorize 2-3 then clear then do 1-(-1)

If we handle decimals, can we assume that numbers will never start or end with a decimal point (e.g. .142857, 100.)?

@ThomasKwa yes. It wil always be 0.~ or ~.0

Can we have some longer, more complicated test cases with ten or so operations?

@ThomasKwa sure, Ill add some as soon as I havr time.

There is a typo. In the text saying that 6(7) won't happen, it also says that the sign ? in 6?(7) will always be a *.

There's no need to memorize and clear on expressions like 1-(7*3), the translation would be - 7 * 3 + 1. For 1-(2-3) it would be - 2 + 3 + 1. There could be a bonus for handling that.

Python 3. 337 327 - 10% = 295 bytes
Supports floating-point and unlimited levels of parentheses, so qualifies for bonus -10%.
import re
def v(s):
 if s[:1]=='(':l,s=e(s[1:]);return l,s[1:]
 m=re.match(r"\d+\.?\d*|\.\d+",s)
 if m:return[m.group()],s[m.end():]
def b(s,f,*O):
 l,s=f(s)
 while s[:1]in O:
  o=s[0]
  r,s=f(s[1:])
  if len(r)>1:l,r=r,l
  l+=[o]+r
 return l,s
m=lambda s:b(s,v,'*','/')
e=lambda s:b(s,m,'+','-')
print(' '.join(e(input())[0]))

???

@sysreq This does work, you just have to use command line arguments. Replacing sys.argv[1] with input() works in ideone (and is shoter - hint hint)

Are there guidelines somewhere that make things clear such as input is supposed be read, not passed as an argument? (Btw @GamrCorps you mean raw_input(), which would only save me 4 characters: "sys,".) As for not shaving off the last few characters, I really just wanted to get the ball rolling and see other peoples' solutions, especially if they do something more interesting than recursive-descent.

@mjmt input can be taken in any method: command-line args, input(), etc.

10% of 337 is 33.7 so wouldn't you round up?

@mjmt GamrCorps means input() because this is Python 3! Python 2's raw_input() === Python 3's input()!

Isn't this 294 because 327 - 32.7 = 294.3 which rounds to 294?

Or do you round the bonus before subtracting?

TI-BASIC, 605.2 bytes
Eligible for lirtosiast's TI-BASIC bounty under Fitting but Unsuitable Languages.
Qualifies for all 3 bonuses, 712 - 15% = 605.2. There are some golfing opportunities here and there, but I wanted to get this out first, as some of the potential golfs are non-trivial. Please note that TI-BASIC is a tokenized language, and the below is a textual representation of that program. Thus, the program is not 1182 bytes, since this program is not encoded under UTF-8. Note that ~ is equivalent to unary negation and -> to the STO> operator. Output is a string, retrievable from Ans or Str1.
The below program is the result of a few programmer hours thinking and programming, spread over the course of a few weeks.
Input "",Str1
0->dim(L1
0->dim(L2
1->I
DelVar S
While I<length(Str1
DelVar T
".->Str3
1->C
While C and I<length(Str1
sub(Str1,I,1->Str2
inString("0123456789.",Str2->C
If C:Then
I+1->I
1->T
Str3+Str2->Str3
End
End
If T=0:Str3+Str2->Str3
sub(Str3,2,length(Str3)-1->Str3
If T=1:Then
expr(Str3->L2(1+dim(L2
End
inString("*+/-",Str3->M
If M:Then
I+1->I
2->T
1->C
While C
dim(L1->C
If C:Then
2fPart(L1(dim(L1))/2)>2fPart(M/2->C
If C:Then
~L1(dim(L1->L2(1+dim(L2
dim(L1)-1->dim(L1
End
End
End
M->L1(1+dim(L1
End
If Str3="(":Then
If S=1:Then
sub(Str1,1,I-1)+"*"+sub(Str1,I,length(Str1)-I+1)->Str1
Else
I+1->I
0->L1(dim(L1)+1
End
End
If Str3=")":Then
I+1->I
While L1(dim(L1
~L1(dim(L1->L2(1+dim(L2
dim(L1)-1->dim(L1
End
dim(L1)-1->dim(L1
End
T->S
End
augment(L2,-seq(L1(X),X,dim(L1),1,-1)->L2
0->dim(L1
1->C
{0,1->L3
For(I,1,dim(L2
L2(I->M
If M>=0:Then
M->L1(dim(L1)+1
Else
If C:Then
L1(dim(L1)-1
Goto S
Lbl A
Ans->Str1
L1(dim(L1->L1(dim(L1)-1
dim(L1)-1->dim(L1
0->C
End
Str1+" "+sub("*+/-",-M,1)+" ->Str1
L1(dim(L1
Goto S
Lbl B
Str1+Ans->Str1
dim(L1)-1->dim(L1
End
End
Goto F
Lbl S
L3Ans->L4
LinReg(ax+b) L3,L4,Y1
Equ►String(Y1,Str2
sub(Str2,1,length(Str2)-3
If C:Goto A
Goto B
Lbl F
Str1

General explanation
Here's the key I worked with while developing the program:
Str1        The input string.
Str2        Counter variable (e.g. current character)
Str3        The current token being built.
L1          The operator stack
L2          The output queue
L3          Temporary list
L4          Temporary list
I           Iterator index
T           Type of token (enum)
S           Type of previous token (enum)
M           Temporary variable
C           Conditional variable

Token Types (T)
0           Undefined
1           Number
2           Operator
3           Open Parenthesis

Operator Elements
0           left parenthesis ("(")
1           multiplication ("*")
2           addition ("+")
3           division ("/")
4           subtraction ("-")
5           right parenthesis (")")

Precedence Rule: Remainder(prec, levelno)
0 - add, sub
1 - mul, div
(levelno = 2)

And here is the equivalent, hand-written JavaScript code I used to test and develop this program.
let Str1, Str2, Str3, L1, L2, I, S, T, M, C;

let error = (type, ...args) => {
    let message = "ERR:" + type + " (" + args.join("; ") + ")";
    throw new Error(message);
};

let isInteger = (n) => n == Math.floor(n);

let inString = (haystack, needle, start=1) => {
    if(start < 1 || !isInteger(start)) {
        error("DOMAIN", haystacak, needle, start);
    }
    let index = haystack.indexOf(needle, start - 1);
    return index + 1;
};

let sub = (string, start, length) => {
    if(start < 1 || length < 1 || !isInteger(start) || !isInteger(length)) {
        error("DOMAIN", string, start, length);
    }
    if(start + length > string.length + 1) {
        error("INVALID DIM", string, start, length);
    }
    return string.substr(start - 1, length);
}

let fPart = (value) => value - Math.floor(value);

// Input "", Str1
Str1 = process.argv[2];
// 0->dim(L1
L1 = [];
// 0->dim(L2
L2 = [];
// 1->I
I = 1;
// DelVar S
S = 0;
// While I<=length(Str1
while(I <= Str1.length) {
    // DelVar T
    T = 0;
    // Disp "Starting",I
    console.log("Starting, I =", I);

    // " read token
    // ".->Str3
    Str3 = ".";
    // 1->C
    C = 1;
    // While C and I<=length(Str1
    while(C && I <= Str1.length) {
        // sub(Str1,I,1->Str2
        Str2 = sub(Str1, I, 1);
        // inString("0123456789",Str2->C
        C = inString("0123456789", Str2);
        // If C:Then
        if(C) {
            // I+1->I
            I++;
            // 1->T
            T = 1;
            // Str3+Str2->Str3
            Str3 += Str2;
        }
    }
    // If T=0:
    if(T == 0) {
        // console.log("Huh?T=0?", Str3, Str2);
        // Str3+Str2->Str3
        Str3 += Str2;
    }

    // " remove placeholder character
    // sub(Str3,2,length(Str3)-1->Str3
    Str3 = sub(Str3, 2, Str3.length - 1);

    // " number
    // If T=1:Then
    if(T == 1) {
        // expr(Str3->L2(1+dim(L2
        L2[L2.length] = eval(Str3);
    }

    // Disp "Str3",Str3
    console.log("post processing, Str3 = \"" + Str3 + "\"");

    // inString("*+/-",Str3->M
    M = inString("*+/-", Str3);
    // " operator
    // If M:Then
    if(M) {
        // I+1->I
        I++;
        // 2->T
        T = 2;
        // Disp "op",M,dim(L1
        console.log("op", M, L1.length);
        // " parse previous operators
        // 1->C
        C = 1;
        // While C
        while(C) {
            // dim(L1->C
            C = L1.length;
            // If C:Then
            if(C) {
                // 2fPart(L1(dim(L1))/2)>2fPart(M/2->C
                C = 2 * fPart(L1[L1.length - 1] / 2) > 2 * fPart(M / 2);
                // If C:Then
                if(C) {
                    // ~L1(dim(L1->L2(1+dim(L2
                    L2[L2.length] = -L1[L1.length - 1];
                    // dim(L1)-1->dim(L1
                    L1.length--;
                }
            }
        }
        // " push current operator
        // M->L1(1+dim(L1
        L1[L1.length] = M;
    }
    // If Str3="(":Then
    if(Str3 == "(") {
        // 3->T
        T = 3;
        // If S=1:Then
        if(S == 1) {
            // sub(Str1,1,I-1)+"*"+sub(Str1,I,length(Str1)-I+1)->Str1
            Str1 = sub(Str1, 1, I - 1) + "*" + sub(Str1, I, Str1.length - I + 1);
        }
        // Else
        else {
            // I+1->I
            I++;
            // 0->L1(dim(L1)+1
            L1[L1.length] = 0;
        }
        // End
    }
    // If Str3=")":Then
    if(Str3 == ")") {
        // I+1->I
        I++;
        // While L1(dim(L1
        while(L1[L1.length - 1]) {
            // ~L1(dim(L1->L2(1+dim(L2
            L2[L2.length] = -L1[L1.length - 1];
            // dim(L1)-1->dim(L1
            L1.length--;
        }
        // End
        // dim(L1)-1->dim(L1
        L1.length--;
    }
    // Disp "Ending",I
    console.log("Ending", I);
    // T->S
    S = T;
    // Pause
    console.log("-".repeat(40));
}

// augment(L2,-seq(L1(X),X,dim(L1),1,-1)->L2
L2 = L2.concat(L1.map(e => -e).reverse());

// Disp L1, L2
console.log("L1", L1);
console.log("..", "[ " + L1.map(e=>"*+/-"[e-1]).join`, ` + " ]");
console.log("L2", L2);
console.log("..", "[ " + L2.map(e=>e<0?"*+/-"[~e]:e).join`, ` + " ]");

// post-processing
let res = "";
// 0->dim(L1
L1.length = 0;
// 1->C
C = 1;
// For(I,1,dim(L2
for(I = 1; I <= L2.length; I++) {
    // L2(I->M
    M = L2[I - 1];
    // If M>=0:Then
    if(M >= 0) {
        // M->L1(dim(L1)+1
        L1[L1.length] = M;
    }
    // Else
    else {
        // If C:Then
        if(C) {
            // L1(dim(L1)-1
            // Goto ST
            // Lbl A0
            // Ans->Str1
            res += L1[L1.length - 2];
            // L1(dim(L1->L1(dim(L1)-1
            L1[L1.length - 2] = L1[L1.length - 1];
            // dim(L1)-1->dim(L1
            L1.length--;
            // 0->C
            C = 0;
        }
        // End
        // Str1+" "+sub("*+/-",-M,1)+" ->Str1
        res += " " + "*+/-"[-M - 1] + " ";
        // L1(dim(L1
        // Goto ST
        // Lbl A1
        // Str1+Ans->Str1
        res += L1[L1.length - 1];
        // dim(L1)-1->dim(L1
        L1.length--;
    }
}
// Goto EF
// Lbl ST
// L3Ans->L4
// LinReg(ax+b) L3,L4,Y1
// Equ►String(Y1,Str2
// sub(Str2,1,length(Str2)-3
// If C:Goto A0
// Goto A1
// Lbl EF
// Str1
console.log(res);

I will provide a more in-depth explanation once I'm sure I'm done golfing, but in the meantime, this might help provide a cursory understanding of the code.

You can assume fresh TI-84+CE calculator, so Input "",Str1 0->dim(L1 0->dim(L2 1->I DelVar S can be Prompt Str1:SetUpEditor :1->I, and you can use toString(. Also have some superfluous parens.

@lirtosiast Good point about the fresh calculator, I didn’t want to include toString as I don’t have a CE myself. I’ll look into emulation to ensure the program’s validity.

Javascript (ES6), 535 - 80 (15% bonus) = 455 bytes
f=z=>{a=[],i=0;c=n=>{while(n[M='match'](/\(/)){n=n[R='replace'](/\(([^()]+)\)/g,(q,p)=>{m=++i;a[m]=c(p);return'['+m+']'})}n=n[R](/(\](?=\[|[\d])|[\d](?=\[))/g,'$1*');n=n[R](/\[?[\d\.]+\]?[*/]\[?[\d\.]+\]?/g,q=>{a[++i]=q;return'['+i+']'});n=n[R](/([\d.]+)\+(\[[\d]+\])/g,'$2+$1');while(n[M](/\[/)){n=n[R](/(\[?[\d\.]+\]?)\*(\[?[\d\.]+\]?)/g,(q,p,r)=>{t=a[r[R](/[\[\]]/g,'')];return r[M](/\[/)?(t&&t[M](/\+|\-/)?(r+'*'+p):q):q});n=n[R](/\[(\d+)\]/g,(q,p)=>{return a[p]+(a[p][M](/\+|-/)?'=':'')})}return n};return c(z)[R](/./g,'$& ')+'='}

Not a minimal solution I'm sure, but pretty complete, allowing for all three bonuses. Some instances require multiple pressings of equals key, but do not require clearing of calculator contents. (ex. 3,5,6 & 7 in fiddle)
Link to JSFiddle with some tests: https://jsfiddle.net/2v8rkysp/3/
Here's some unfolded, semi-unobfuscated code with a few comments for good measure.
function f(z) {
var a=[],i=0;
function c(n) {
    //// Tokenize parentheses groups recursively
    while (n.match(/\(/)) {
    n = n.replace(/\(([^()]+)\)/g, function(q,p) {
      m = ++i;
      a[m]=c(p);
      return '['+m+']';
    });
    }

    //// Allow implied multiplication with parentheses
    n = n.replace(/(\](?=\[|[\d])|[\d](?=\[))/g, '$1*');

    //// Tokenize mult/division
    n = n.replace(/\[?[\d\.]+\]?[*\/]\[?[\d\.]+\]?/g, function(q) {
      a[++i]=q;
      return '['+i+']';
    });

    //// Move addition tokens to the front
    n = n.replace(/([\d.]+)\+(\[[\d]+\])/g,'$2+$1');

    //// Detokenize
    while (n.match(/\[/)) {
        //// If a token includes addition or subtraction,
        ////   move it to the front of other tokens
        n = n.replace(/(\[?[\d\.]+\]?)\*(\[?[\d\.]+\]?)/g,function(q,p,r) {
          t=a[r.replace(/[\[\]]/g,'')];
          return r.match(/\[/)?(t&&t.match(/\+|\-/)?(r+'*'+p):q):q;
        });
        //// If a token includes addition or subtraction,
        ////   add the equals keypress
        n = n.replace(/\[(\d+)\]/g, function(q,p) {
           return a[p]+(a[p].match(/\+|-/)?'=':'');
        });
    }
    return n;
}
//// Add spaces and final equals keypress
return c(z).replace(/./g, '$& ')+'=';
}


text:
How's your string theory?
Back to the basics! You're in you comp sci class again, except wiser and golfier. You have the tools, you have the power… but do you have the skill? Probably.
Crash Course for the non-Computer Scientist (skip if you don't need it)
A string is symbolically represented by an arbitrary letter (usually, for our purposes, will be  etc. Of course, we know a string as something like "Hello, World!" or 'Hello, World!', or, if you're the snarky Python user, """Hello, World!""".
An alphabet can be thought of as a set (i.e. no repeating characters) of symbols, of which strings can be made. For example, ; this is the binary alphabet, of which contains strings like  and .  These strings can said to be strings over , or, alternatively, .
The length of any string is denoted . For example, .
There is the empty or null string , which is equivalent to "". It is a valid string in over any alphabet. In other words,  is the unique string satisfying the property .
The set  is the set of all strings  over  for which .
The set  is called the Kleene closure of , and is the set of all strings over . This can be considered the language of .
The concatenation of two strings  and  is denoted , and is the string containing the characters of  followed by the characters of .
 is said to be a prefix of  if there is some string  that satisfies the equality . (If , then  is said to be a proper prefix of .)
The alphabet of a string  is denoted , and is the minimal alphabet  so that  is a string over
The projection of a string  relative to an alphabet  is defined as

and is essentially the removal of all characters in  not in .

TL;DR
Objective Write a program, series of functions, series of programs etc. that can calculate as many of the following tasks as possible:

(1) Calculate, given a string s, its length.
(2) Arrive at, given a string s and an alphabet Σ, whether or not (output a truthy/falsy value) that string is over said alphabet.
(1) Given an alphabet, arrive at whether or not (output a truthy/falsy value) the alphabet is valid (a valid alphabet can have no repeating characters, but is otherwise valid).
(4) Given an alphabet Σ and a positive integer n, display .
(6) Given an alphabet Σ and an integer n, display the first n entries in  (Remember that ε ∈ Σ!)
(1) Given a string s and a string t, output st.
(3) Given a string s, output Al(s).
(5) Given a string s and an alphabet Σ, output πΣ(s).

Input is given by a string or your language's closest equivalent for a string input, an array, tuple, or n-ordinate of characters for an alphabet  (your language's closest equivalent), and a number for a number (or your language's closest equivalent, heaven forbid your language does not support numbers!).
Each task has a score (the number in parenthesis). Your submission's score is calculated as follows:
        sum points scored
score = —————————————————
         length of bytes

Highest score wins.
Bonuses

×4 final score iff you output (with the correct symbols!) the input query. E.g., outputting \pi_{\{0,1\}}(012345678910111213)=01101111 for an input of Σ = [0,1]; s = 012345678910111213. (You may choose to do this in either HTML or (La)TeX. Either counts.)
(I'm open to suggestions.)

Also, for the bonus, how would you notate the third or sixth challenges?

@CᴏɴᴏʀO'Bʀɪᴇɴ There is currently no incentive to solve more than 1 challenge, because any challenge with a worse ratio will give a lower score. The scoring system needs to be changed to make this challenge work. I would recommend making it points/length for each problem, and then sum the scores for each problem completed. Most points wins.

@CᴏɴᴏʀO'Bʀɪᴇɴ That's almost there, but not quite. The point is that answering additional challenges should always improve your score. So you should sum the scores of each challenge, not compute an overall points number.

This is a situation in which the sandbox would have been handy to sort out issues prior to posting.

@isaacg actually, you can share code between the challenges.

For (6) is there a specific order required? I.e. what are the first elements of an infinite set?

For the bonus, is using unicode characters directly (and not HTML entities) also okay?

@PaŭloEbermann Yes.

The scoring has not really changed with the latest edits. It's now the inverse of what it was originally, and the highest wins. This changes the scores, but not the order of them. If somebody had score s1 before, which was lower than score s2, the new scores are now 1 / s1 and 1 / s2, where the first score is higher.

@RetoKoradi What do you suggest?

Task 6, the first n seems meaningless for a set. Do you mean any n?

I assume the order is meant to be lexicographical @edc65

@Mauris A lexicographical order requires an order on the alphabet. And we don’t know the alphabet.

How do we parse "complete anything for the challenge?" Is JavaScript's built-in string type unsuitable for [1] because it has a .length property and therefore completes something for the challenge? Or is it merely forbidden to use that property? If our programming language contains lazy generators can we require that the $\Sigma$ "input" be the generator for $\Sigma^*$ ?

@CRDrost For the former, it is acceptable. For the latter, I said that Input is given by the most convenient method that does not complete anything for the challenge. E.g., you can accept a string for the first challenge, but not the length of the string. Specifically, the use of an input that effectively solves the problem is forbidden.

@CᴏɴᴏʀO'Bʀɪᴇɴ I mean, I view "effectively solves the problem" as vague in these scenarios where interconversion is so trivial, which is why I'm asking you to clarify.

@CRDrost Thanks for clarifying your problem. It is a tad vague. I will disambiguate

@CᴏɴᴏʀO'Bʀɪᴇɴ OK. I posted a new entry while you were revising that but it was invalidated by your rules change, so I have put its heading in strikethrough font; I think it might be worth keeping it for historical reasons.

0 counts as falsy in all languages, right?

@dorukayhan It depends on the language. Typically, if code inside an if statement runs with a value as a condition, the value is considered truthy

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

@pppery Thanks, but you’re retroactively applying a standard that wasn’t in place at the time the question was asked. Not really applicable

Rules about question on-topicness apply to questions that predate them. Othertwise, First code golf decathlon would never have been closed and locked. All that has happened is that this clearly off-topic question has slipped through the cracks for three years -- well, the time has come for that to be remedied.

@pppery Alright. I don't really care, not terribly invested in this site. Seems stupid and pedantic, but do whatever. Good luck getting this closed.

APL, score 3
Task 7: 3 / 1
∪

This is a built-in that – according to this discussion – can be considered an unnamed function.
Try it online on TryAPL.

I don't know APL, so I'm just trying to understand: The meta discussion says that your code must define a function that was not defined before. Isn't this just using a built-in function? Does it actually define a new function?

The accepted answer says that sum would be a valid Python answer (if it did what asked for), and the comments clarify that J/APL built-ins are valid for the same reason. ∪ is like an anonymous function, which you can name via f←∪.

I think, under the current scoring system, my best score is:
Pyth, 5/3
@wz

Task 8

Pyth, 295/42 ~ 7.024
Task 1: 1/2
lz

Task 2: 2/4
!-wz

Task 3: 1/3
.{z

Task 4: 4/3
^zQ

Task 5: 6/7
<s^LzQQ

Warning: Extremely slow.
Task 6: 1/3
+zw

Task 7: 3/2
{z

Task 8: 5/3
@wz

Demonstration
Exactly two of these are not Pyth builtins, namely tasks 2 and 5.

Please revise to fit scoring criteria.

Mathematica, score 64033/52668 = 1.215785676
StringLength
StringMatchQ[#,#2..]&
#==DeleteDuplicates@#&
""<>#&/@Tuples@##&
Table[""<>#&/@#~Tuples~i,{i,#2}]&
#<>#2&
Union@Characters@#&
""<>StringCases@##&

Of course. There's always a Mathematica answer for stuff like this!

Please revise to fit scoring criteria.

Neat, I didn't know about \[Function], but I think here you can save two bytes with Table[""<>#&/@#~Tuples~i,{i,#2}] (same number of characters, but no Unicode).

@MartinBüttner Yeah, using the Unicode can be a good golfing strategy at times. Too bad that most of them are in the Private Use Area and can't be displayed normally...

Pyth, score 1/2 = 0.5

Challenge 1:
lz

Try it out

Please revise to fit scoring criteria.

CJam, score 3/3 = 1.00
Best score for the current definition of the scoring function counts only task 7:
r_&

This is a complete program, and scores 3 points with 3 bytes of code.
As bonus material, here are my solutions for all the tasks but task 5:
Task 1, score 1/2:
r,

Task 2, score 2/4:
rr-!

Task 3, score 1/5:
r__&=

Task 4, score 4/7:
rrim*S*

Task 6, score 1/2:
rr

Task 7, score 3/3:
r_&

Task 8: score 5/6:
rr_@--

Ruby, score = 17 / 153 = 0.111
I've just started with the tasks, I'll try to solve all of them.
Task 1 (13 bytes):
a=->s{s.size}

Task 2 (33 bytes):
b=->s,a{s.chars.all?{|c|a[c]!=p}}

Task 3 (28 bytes):
c=->a{a.chars==a.chars.uniq}

Task 4 (88 bytes, awfully long...):
d=->a,n{a.chars.map{|e|e*=n}.join.chars.permutation.map(&:join).map{|e|e=e[0...n]}.uniq}

Tash 6 (12 bytes):
f=->s,t{s+t}

Task 7 (19 bytes):
g=->s{s.chars.uniq}

Task 8 (48 bytes):
h=->s,a{g='';s.chars.map{|c|a[c]==p ? 0:g+=c};g}

Please revise to fit scoring criteria.

@CᴏɴᴏʀO'Bʀɪᴇɴ Done, thanks!

Ceylon score 16/167 = 1/11 = 0.090909...
This code of length 176 defines for projection, size and the iterators, giving 5 + 1 + 4 + 6 = 16 points:
import ceylon.language{S=String,B=Boolean}import ceylon.collection{H=HashSet}S al(S s)=>S(H{*s});B v(S s)=>s==al(s);S p(S a,S s)=>S(s.filter(a.contains));B i(S s,S a)=>s==p(a,s);S c(S s,S t)=>s+t;Integer(S)l=S.size;
The alphabet is also provided in form of a string (a character iterable {Character*} would work just the same, but take more code space).
I did actually implement all of the functions, but the other ones took more length per point.
All of them formatted and commented:
import ceylon.language {
    S=String,
    I=Integer,
    B=Boolean
}

// minimal alphabet of a string → 3 points
// taken from http://codegolf.stackexchange.com/a/59789/2338
S b(S s) => S { for (x->c in s.indexed) if (!c in s[0:x]) c };

// is the alphabet valid? → 1 point
// we simply check if it is its own minimal alphabet.
B v(S a) => a == b(a);

// project string to alphabet → 5 points
S p(S a, S s) => S(s.filter(a.contains));
//  S p(S a, S s) => S(s.filter((c)=>c in a));

// is string s over alphabet a? → 2 points
// we check if the string is its own projection.
B i(S a, S s) => s == p(a, s);

// concatenate → 1 point
S c(S s, S t) => s + t;

// length of a string → 1 point
// uses a different syntax than the usual I l(S s) => s.size, because it is slightly shorter.
I(S) l = S.size;

// strings of length n over alphabet a → 4 points
{S*} x(S a)(I n) =>
// defined recursively.
        n == 0
        then { "" }
        else { for (s in x(a)(n - 1))
        for (c in a)
            S { c } + s };

// first n strings → 6 points
{S*} y(S a, I n) => expand((0..n).map(x(a))).take(n);

(I guess I could replace the .. by : in the last line, but then the score wouldn't be so nice anymore.)

Haskell, score=1/3
If function is not allowed, this submission is invalid.
The best score is task 8 with score (5/16).
Task 1(1/6):
length

I somehow misread Prelude.
Task 2(2/13):
all.flip elem

First argument is alphabet, the second is string
Task 3(1/32):
c[]=2>1;c(x:xs)=all(/=x)xs&&c xs

Sigh, is is overly long.
Task 4(1/16):
_#0=[[]];x#y=concatMap(flip map$x#(y-1))$map(:)x

Task 5(1/12):
_#0=[[]];x#y=concatMap(flip map$x#(y-1))$map(:)x;n&k=take k.map(n#)[1..]

Task 6(1/4 or 1/2):
(++)

I don't know if the paratheses is allowed to be dropped in this case
Task 7(3/32 or 3/22 or 3/20):
It is same as delete duplicates
a[]=[];a(x:y)=x:(a$filter(\=x)y)

If using library is not cheating
import Data.List
a=nub

Or even drop the a=
Task 8(5/16):
For Haskell it is ridiculously easy.
filter.flip elem

Functions are allowed, you can drop the a= in task 7, dropping the parenteses should be fine, and in task 3 change xs to y or some other single letter.

Haskell, 5, possible cheating
(This was invalidated by a rules update.)
This strongly depends on how you interpret the minutiae of the grading rules.
$

I claim that this solves task 8 (5 points) in 1 byte for a reasonable interpretation of the inputs. I have asked for clarification and not really received much, so I am posting this solution in order to induce more discussion.
The scope of the liberties I am taking
The freedom afforded to us is not "You have to use the most obvious thing that someone would use if they talked about a "string" in your language" but rather,

Input is given by the most convenient method that does not complete anything for the challenge. E.g., you can accept a string for the first challenge, but not the length of the string.

I am choosing some methods as "convenient" which are convenient in two niche areas of programming. They do not "complete anything for the challenge" in the sense that neither one completes the challenge by itself, nor does the challenge have any well-defined subtasks (and if these challenges did have subtasks then builtins would likely be disallowed!).
Stealing a lambda-calculus-style list
In lambda calculus the usual way that you encode a list is the Church encoding with direct reference to its foldr; a variant encoding will run the function on the empty list [], it is constrained only in its output type and not in its function. In other words, list_from_fn f = f (:); fn_from_list ls f = foldr f [] ls. I think that this is relatively noncontroversial because this is in fact a usual way to think of a list in functional programming circles.
Stealing a Clojure-transducer-style alphabet.
The specification of the alphabet is more contorted and may fall foul of the rather-vague rule. For my alphabet I find it quite convenient to use a filtering arrow, more precisely the sort of filtering arrow you'd see in the Kleisli representation of the List monad. So that requires maybe a bit of explaining: there are these functions from a -> [b] which are composed, in the Kleisli category, with the function (.).concatMap. A filtering arrow is the specific a -> [a] which has the form
filterArrow predicate a = if predicate a then [a] else []

So far, so good: an alphabet is equivalent to its filter which is equivalent to its filter arrow, which makes perfect sense in a certain class of applications. However, these applications are used in practice: the programming language Clojure a few years ago started a big hacker-media frenzy when they introduced this Kleisli category a -> [b] into mainline Clojure under the name "Transducers," with the only difference being that they were transformed with a bit of continuation-passing so that the order of the composition was reversed.
So both of those seem to be relatively straightforward and real programmers really use both.
Where cheating may be occurring
However where I might be cheating is that I actually am expecting as "convenient" for the list function to be the concatenating foldr applied to the empty string, (a -> [b]) -> [b]. This is still 100% equivalent to a list, as evidenced by the isomorphism
list_from_fn f = f (:[])
fn_from_list ls f = foldr ((++).f) [] ls

however I do not have any prior art of its widespread usage to represent lists. It's quite possible that someone has done it before, but I can't prove it.

Java, score: 8 / 491 467 465 462 ~= 0.0173
I just wanted to see how many tasks I can figure out.
import static java.lang.System.*;interface a{static void main(String[]A){char[]Z=A[1].toCharArray();switch(A[0]){case"a":out.print(A[1].length());break;case"b":int b=1;for(char B:Z)b=A[2].contains(new String(c))?b:0;out.print(b>0);break;case"c":String B="";int c=1;for(char C:Z){c=B.contains(new String(C))?0:c;B+=C;}out.print(c>0);break;case"d":out.print(A[1]+A[2]);break;case"e":String C="";for(char d:Z)C+=C.contains(new String(d))?"":d;out.print(C);break;}}}

The program (ab)uses command line arguments to get the tasks done. Here's how it works (note that every argument should be enclosed in double quotes like "arg1" "arg2" "arg3"):

If the first argument is a, the second argument's length is printed (calculates the length of a given string). Syntax: a <string>
If the first argument is b, true is printed in case of the second argument being over the third argument, which is taken as an alphabet (given a string and an alphabet, find out if the string is over the alphabet). Syntax: b <string> <alphabet>
If the first argument is c, true is printed if the second argument is a valid alphabet where every character occurs only once (given an alphabet, find out if it's valid). Syntax: c <alphabet>
If the first argument is d, the concatenation of the second and third arguments is printed - the second argument comes first (given two strings, concatenate them). Syntax: d <first string> <second string>
If the first argument is e, the smallest alphabet which the second argument is over is printed (given a string, find out its alphabet). Syntax: e <string>

Oh wait, let me ungolf the program for you:
import static java.lang.System.*;
interface a {
    static void main(String[] A) {
        char[] Z = A[1].toCharArray();
        switch (A[0]) {
        case "a":
            out.print(A[1].length());
            break;
        case "b":
            int b = 1;
            for (char B : Z)
                b = A[2].contains(new String(c)) ? b : 0;
            out.print(b > 0);
            break;
        case "c":
            String B = ""; int c = 1;
            for (char C : Z){
                c = B.contains(new String(C)) ? 0 : c;
                B += C;
            }
            out.print(c > 0);
            break;
        case "d":
            out.print(A[1] + A[2]);
            break;
        case "e":
            String C = "";
            for (char d : Z)
                C += C.contains(new String(d)) ? "" : d;
            out.print(C);
            break;
        }
    }
}

dc: 1k 1 1+2 3+/p: 0.4 points
Strings s and t, as applicable, must be present on the top of the stack at execution time, with s topmost.
Calculate length of string s: 1pt, 2B
Zp

Concatenate s and t: 1pt, 3B
rnn

Python 3, 27 / 158 ≈ 0.1709
I tried for as many tasks as possible instead of the highest score possible.
from itertools import*
L=len
lambda s,a:all(c in a for c in s)
lambda a:L(set(a))==L(a)
permutations
str.__add__
set
lambda s,a:filter(a.__contains__,s)

Task 1:
L=len

Pretty self-explanatory. I assign it because it's used later, and naming it L saved 4 bytes.
Task 2:
lambda s,a:all(c in a for c in s)

This maps s to a list of boolean values telling if the corresponding character is in the string. If they are all True, then s is over a.
Task 3:
lambda a:L(set(a))==L(a)

Here's where I used that len rename. In Python, the set class is a container of unique objects, and if the constructor is given a container with duplicates, it removes them.
Task 4:
permutations

The Python library function itertools.permutations does exactly what is needed.
Task 5:
nope
Task 6:
str.__add__

Shamelessly co-opting class methods. Not much else to say.
Task 7:
set

Once again, the beautiful uniquefying set comes in handy. Here, it automatically finds the minimal alphabet.
Task 8:
lambda s,a:filter(a.__contains__,s)

Filters out the characters in s s which are not also in a. Alternative with the same length: [c for c in s if c in a]

source: Stack Exchange

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

sort: votes


text:
Simple regex parser
Let's parse some regex. Not quite the regex you are used to, but the formal regular expressions taught in courses on automata theory. Wikipedia knows what I'm talking about.
We have four operations. In order of priority, from highest to lowest:

Parenthesis. (a)

The contents of the parenthesis is a regular expression itself. This allows for nested parenthesis.

Kleene star. a*

The star denotes that the previous token may be matched zero or more number of times.

Concatenation. Logical AND. ab

This does what you think it does. It matches a followed by b.

Union, or alteration. Logical OR. a|b

This matches a or b but not ab.

These characters have special meaning: *|()ε All other characters (except white-space) are in the language. There are no escape sequences.
ε denotes the empty string. If your language of choice does not support that character, tell us how we can change what character you used to denote the empty string.
The task:
Your program is supposed to read one line of well-formatted regex from stdin, followed by one line of text to be matched against that regex. If the regex accepts the string, output "yay" to stdout. Otherwise, output "nay" to stdout.
Yay-cases:
abc
abc

_
ab(c|d)*ef*
abcdcdcdddcce

_
ab(c|d)*ef*
abeff

_
[abc]*
[abc]

_
<(?P<tag>[A-Z][A-Z0-9]*)\b[^>]*>
<(?P<tag>[A-Z][A-Z0-9])\b[^>]>

_
a*
ε

_
a*b*c*
aaεbbεεbcε

_
a\(b\)c
a\b\c

_
a|b
b

Nay-cases:
abc
ab

_
ABC
abc

_
abc
abcd

_
[abc]*
abc

_
a+
aaaa

This is code golf, so lowest byte count wins.

Closely related

There are a lot of differences between the two challenges. This one has no restrictions on what language features one may use, and it does not require you to output a program that in turn parses the input.

I don't think the challenges are different enough to warrant separate posts.

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


text:
Find the angle between two points
Given two points A and B, find the angle from line AO to line BO about point O where O is the origin ((0,0)). Additionally, the angle may be positive or negative depending on the positions of the points (see examples). Input will be points A and B, and may be given in any convenient form. Output will be the angle in degrees (but it is positive if AO is rotated counter-clockwise about the origin to get BO and negative if it is rotated clockwise). If the angle is 180 degrees you may return a negative or positive output. Similarly, the angle can be the positive or negative version of the same angle (90 deg is equal to -270 deg). Examples:

Input: A(5,5) B(5,-5) Output: -90 (AO is rotated -90 degrees to get BO).
Input: A(5,-5) B(5,5) Output: 90 (AO is rotated 90 degrees to get BO).

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

Your examples only have multiples of 90 degs in them. Is this true for our programs as well, or do they have to deal with arbitrary angles?

Arbitrary angles as well.

How much precision is required?

Can we take input as two complex numbers?

Can we output as a one-element list containing the angle?

What should the output be if one point is (0,0)?

@ThomasKwa I don't know about the OP, but I treated it as only integer/decimal number input, and the input would never have a (0,0) point.

Hint: The angle between AO and BO would usually be called angle AOB.

Pyth, 11 bytes
.t-FPM.jMQ6

Demonstration
Input is given in the format:
[[Bx, By], [Ax, Ay]]

If it is desired that A comes first, this can be changed for 1 byte.
Explanation:
.t-FPM.jMQ6
               Implicit: Q = eval(input())
      .jMQ     Convert input pairs to complex numbers.
    PM         Take their phases (angles in the complex plane).
  -F           Take the difference.
.t        6    Convert to degrees

TI-BASIC, 13 bytes
For TI-83+/84+ series calculators.
Degree
Input Y
min(ΔList(R►Pθ(Ans,∟Y

To use this program, enter the list {x1,x2} through the Ans variable, and {y1,y2} at the prompt.

Is a TI-BASIC command a single byte?

All commands here, except ΔList(, are one byte each. This includes R►Pθ(.

+1 just for using calculator programming. Takes me back to Trig and Calculus in my high school days.

Nice reference! Super cool.

CJam, 14 bytes
q~::ma:-P/180*

This is a full program that reads the input as [[Ax Ay] [Bx By]] from STDIN.
Try it online in the CJam interpreter.
How it works
q~             e# Read and evaluate all input.
  ::ma         e# Replace each point (x, y) with atan2(x, y).
               e# This returns its angle with the positive y axis, measured clockwise.
      :-       e# Compute the difference of the two resulting angles.
               e# This returns the angle between the points, measured counter-clockwise.
        P/180* e# Divide by Pi and multiply by 180 to convert to degrees.

Amusing that almost half of this program is just converting radians to degrees...

@DarrelHoffman I find it even more amusing that in Pyth the conversion is 3 bytes instead of 6, so if the challenge allowed for reporting in radians the languages would be tied

Minkolang 0.9, 112 bytes
I really want to implement trig functions as built-ins now...but this was fun! (Caveat: this outputs the positive angle difference, not the signed angle difference. Given my limitations, I think that's justified.)
4[n]0c2c*1c3c*+r4[2;1R]r+1R+0g*12$:;$:8[0ci2*3+d1R;0g$:1i1+[i2*1+d1+$:*]*]$+'3.141592654'25*9;$:$:12$:r-66*5**N.

Try it here.
Explanation
I'll post a fuller explanation if anyone wants it, but the gist of it is:
4[n]                                    Take in 4 integers from input
0c2c*1c3c*+                             dot product
r4[2;1R]r+1R+0g*12$:;                   magnitudes of vectors
$:                                      dot product divided by magnitudes (z)
8[0ci2*3+d1R;0g$:1i1+             *]    Taylor series for arccos
                     [i2*1+d1+$:*]      In particular, the coefficient (1/2 * 3/4 * ...)
$+                                      Add them all up!
'3.141592654'25*9;$:$:                  Divide by pi for converting to degrees
12$:r-                                  Subtract from 1/2 - I now have arccos(z)
66*5**                                  Convert to degrees
N.                                      Output as number and stop.

Does minkolang support comments? I couldn't find it on the readme.

@CᴏɴᴏʀO'Bʀɪᴇɴ: It's just like other 2D languages - comments are whatever isn't reached by the program counter.

Oh, okay, then. That makes sense, dunno what I was thinking.

@CᴏɴᴏʀO'Bʀɪᴇɴ: Your explicit use of comments in one of your answers makes me consider implementing similar functionality though. It's a neat idea and wouldn't be terribly hard for me to implement.

Thanks! :D Was it the Hello World challenge that you noticed the comments in (FYI the interpreter I have made for Simplex runs in different "modes": string mode and comment mode. It makes it really easy to parse and allows you to ignore signal characters of one mode whilst in the other.)

@CᴏɴᴏʀO'Bʀɪᴇɴ: Yep. My interpreter does the same for string mode and number mode. It would not be hard to add comment mode.

Mathematica, 22 bytes
{-1,1.}.ArcTan@@@#/°&

Example:
In[1]:= {-1,1.}.ArcTan@@@#/°&[{{5,5},{5,-5}}]

Out[1]= -90.

In[2]:= {-1,1.}.ArcTan@@@#/°&[{{5,-5},{5,5}}]

Out[2]= 90.

Will this work for inputs like {{0,1},{1,0}}

@ThomasKwa Of course it will.

Julia, 18 25 bytes
f(A,B)=angle(B/A)/pi*180

This assumes that "any convenient form" already allows for A and B to be given as complex numbers. Then, the complex number arithmetic does all the heavy lifting.
Edit: converted snippet to function. 18 byte version only works in the Julia REPL.

Python 2.7, 73 Bytes
from math import*
f=lambda A,B:degrees(atan2(B[1],B[0])-atan2(A[1],A[0]))

Test:
f((5,5),(5,-5)) #-90.0
f((5,-5),(5,5)) #90.0

Welcome to PPCG! This is code-golf, so you should try to remove as many spaces as you can and shorten your code.

You can make your code shorter by recklessly adding some *s all over the place

Octave, 43 bytes
f=@(a,b)(cart2pol(b)-cart2pol(a))(1)*180/pi

Input/Output:
octave:40> f([5,5],[5,-5])
ans = -90

octave:41> f([1,0],[0,1])
ans = 90

Javascript, 66 bytes
let f=(a,b)=>(Math.atan2(b.y,b.x)-Math.atan2(a.y,a.x))*180/Math.PI;

demo

23 seconds before me =P Nice golf though! Btw, you can omit the let f=, and it's still considered valid as an anonymous function.

CJam, 15 bytes
l~ma@@ma-P/180*

Thought I'll get in the CJam game as well. Try it online.
Input is in form of bx by ax ay. Unfortunately, this is the shortest method of doing this challenge without copying Dennis' answer.

TeaScript, 28 bytes
I really should of implemented trig functions...
$.atan2(_[3]-y,z-x)*180/$.PI

Try it online input is a.x a.y b.x b.y
Explanation
$.atan2(       // Arc Tangent of...
    _[3] - y,  // 4th input - 2nd input
       z - x,  // 3rd input - 1st input
) * 180 / $.PI // Converts rad -> deg

Ruby, 64, 58 bytes
a=->(b){b.map{|c|Math.atan2(*c)}.reduce(:-)*180/Math::PI}

Usage
a.call [[5, 5], [5, -5]] # => -90.0
a.call [[5, -5], [5, 5]] # => 90.0

JavaScript, 49 bytes
(a,b)=>((c=Math.atan2)(...b)-c(...a))/Math.PI*180

Input is taken in form: [aY, aX], [bY, bX] (notice the reversed x/y)

Simplex v.0.7, 13 bytes
I'm glad I added mathrelations :D Unfortunately, I cannot take pointwise input. So, I input each point as a separate number (Ax, Ay, Bx, By). (I used this as a resource.)
(iRi~^fR)2LSo
(       )2    ~~ repeat inner twice
 iRi          ~~ take two chars of input (x,y)
    ~         ~~ switch top 2 on stack
     ^f       ~~ apply atan2 on (y,x)
       R      ~~ go right
          L   ~~ go left
           S  ~~ subtract result
            o ~~ output as number

I can save a char if I can take input as (Ay, Ax, By, Bx):
(iRi^fR)2LSo

C, 88 bytes
#include<math.h>
typedef double d;d g(d x,d y,d a,d b){return atan2(b-y,a-x)*180/M_PI;}

Requires compiling with GCC to take advantage of M_PI being defined in math.h as a part of GCC's built-in math constants.
Try it online - since ideone doesn't use GCC (apparently), an additional few bytes are needed for enough digits of π to be accurate.

Or 45/atan(1) instead of 180/3.14159.... (in the online demo).

@CompuChip I wasn't trying to make the online demo maximally golfed

You can remove the brackets round atan2(b-y,a-x), although you then need a space after return so it only saves 1 byte.  If you can use K&R style functions then double g(x,y,a,b)double x,y,a,b; also saves six bytes.

R, 33 bytes
f=\(a,b,c,d)atan2(d-b,c-a)/pi*180

result:
> f(5,5,5,-5)
[1] -90
> f(5,-5,5,5)
[1] 90

Pascal, 68 Bytes
Pascal according to ISO standard 10206 “Extended Pascal” includes complex numbers as a built‑in data type.
function f(A,B:complex):real;begin f:=arg(B/A)*90/arg(cmplx(0,1))end

FreePascal, 71 Bytes
As of version 3.2.0 the FreePascal Compiler (FPC) does not (yet) support (all) Extended Pascal features, but the standard RTL (run‑time library) includes a custom ucomplex UCSD Pascal unit providing a record‑based complex number implementation.
uses uComplex;function f(A,B:complex):real;begin f:=180/pi*carg(B/A)end

Swift, 62 bytes
import Foundation
let f={(atan2($3,$2)-atan2($1,$0))*180/M_PI}

If you're on a Mac, you should be able to replace import Foundation with import Darwin to save 4 bytes.

authors: вʀaᴎᴅᴏƞ вєнᴎєƞ

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