text:
Piano Chords on White Keys
Backstory [which is not true]
A piano is set up like this:

However, on my piano, all of the black keys are broken!
I still want to be able to play some chords on my broken piano though.
In music, a chord is a group of notes that are played together. To allow for input of chords, I will first define what a semitone is.
What is a semitone?
A semitone is the smallest distance in Western music. If you look at the top part of the piano, you see that you can usually move from a black key to a white key, or vice versa; however, between B and C and E and F there is no black key.
What is a chord?
For the purposes of this challenge, we define a chord as a bunch of notes with a certain number of semitones between them. For example, let's take a took at a 4-3-3 chord starting on C (for music people, this is a V7 chord in F major). We start at C. We count up 4 semitones: C#, D, D#, E. The next note is E, and we count 3 semitones up after that: F, F#, G. The next note is G, and we count 3 semitones up after that: G#, A, Bb. So, we get C-E-G-Bb. Yay! But wait... Bb is a black key and those are broken... However, if we start from G, we get G-B-D-F! Yay!
Input
Input is given as a list of integers in any reasonable format. This represents the chord as described above.
Output
Output should be a list of notes on which I can start to only need to use white keys. This can also just be a string of all of the up to 7 notes because all of the keynames will be one character. You must be able to handle having an empty output as well.
Test Cases
input -> output // comments
4 3 -> C F G // this is a major triad
3 4 -> D E A // this is a minor triad
4 3 3 -> G // this is the major-minor seventh chord
3 3 3 -> [empty output] // this is the diminished-diminished seventh chord. All of them use black keys
4 4 -> [empty output] // this is an augmented triad
3 3 -> B // this is a diminished triad
1 -> B E // this is just a minor second
11 -> C F // this is just a major seventh

Other specs

Standard Loopholes forbidden
You may assume that the input has at least one integer
You may assume that all of the integers are non-negative and less than 12 (because the piano repeats every 12 notes)
Output may be in any order

Winning Criteria
The shortest valid submission as of April 15th will be accepted.

We may assume "non-negative and less than 12" - should that not be "positive and less than or equal to 12"?

@JonathanAllan Fundamentally there is no difference; my method allows for a Perfect Unison but not a Perfect Octave; yours vice-versa. Theoretically, your restriction might make more sense but I think I probably shouldn't change it because there are already answers and it doesn't change the challenge fundamentally.

Jelly, 25 bytes
236ḃ2ṙÐ€7+\€Ṭ
+\ịþ¢Ạ€TịØA

Try it online! or see a test suite
How?
236ḃ2ṙÐ€7+\€Ṭ - Link 1, white-note-offsets: no arguments
236ḃ2         - 236 in bijective base 2 [2, 2, 1, 2, 2, 1, 2] - semitones G->A, A->B ...
     ṙÐ€7     - rotate left by, mapped over [1,2,3,4,5,6,7] - i.e. as above for each
                    starting white key (1st one A->B,B->C,...; 2nd B->C,C->D,...; etc)
         +\€  - reduce €ach with addition - i.e. absolute number of semitones: [[2,3,5,7,8,10,12],[1,3,5,6,8,10,12],[2,4,5,7,9,11,12],[2,3,5,7,9,10,12],[1,3,5,7,8,10,12],[2,4,6,7,9,11,12],[2,4,5,7,9,10,12]]
            Ṭ - untruth (vectorises) - make lists with 1s at those indexes: [[0,1,1,0,1,0,1,1,0,1,0,1],[1,0,1,0,1,1,0,1,0,1,0,1],[0,1,0,1,1,0,1,0,1,0,1,1],[0,1,1,0,1,0,1,0,1,1,0,1],[1,0,1,0,1,0,1,1,0,1,0,1],[0,1,0,1,0,1,1,0,1,0,1,1],[0,1,0,1,1,0,1,0,1,1,0,1]]

+\ịþ¢Ạ€TịØA - Main link: list of semitone gap integers (even negatives will work)
+\          - reduce by addition - gets the absolute semitone offsets needed
    ¢       - last link (1) as a nilad
   þ        - outer product with:
  ị         -     index into - 7 lists, each with 1s for white and 0s for black keys hit
                      note that indexing is modular and all the lists are length 12
                      so any integer is a valid absolute offset, not just 0-11 inclusive
     Ạ€     - all truthy for €ach - for each get a 1 if all keys are white ones, else 0
       T    - truthy indexes - get the valid starting white keys as numbers from 1 to 7
        ị   - index into:
         ØA -     the uppercase alphabet

MATL, 31 bytes
Thanks to Jonathan Allan for a correction.
'BAGFEDC'"GYs12X\110BQX@YSYsm?@

Try it online! Or verify all test cases.
Explanation
The pattern 2 2 1 2 2 2 1 specifies the intervals between consecutive white keys. The program uses a loop that applies all cyclic shifts to this basic pattern, in order to test each key as a potential lowest note of the input chord. For each shift, the cumulative sum of the pattern is obtained. For example, for B as potential lowest note, the pattern has been shifted to 1 2 2 1 2 2 2 and its cumulative sum is 1 3 5 6 8 10 12.
Now, to see if this can support a 4 3 3 chord we compute the cumulative sum of the chord intervals, which is 4 7 10; reduce it via 1-based modulo 12 (an interval of 14 would give 2); and check if those numbers are all members of the allowed values 1 3 5 6 8 10 12. That's not the case in this example. Had it been the case, we would output the letter B.
The correspondence between cyclic shifts and output letters is defined by the string 'BAGFEDC'. This indicates that 'B' (first character) corresponds to a cyclic shift by 1; 'A' (second character) corresponds to a cyclic shift by 2 etc.
'BAGFEDC'  % Push this string
"          % For each character from the string
  G        %   Push input array
  Ys       %   Cumulative sum
  12X\     %   1-based modulo 12, element-wise (1,12,13,14 respectively give 1,12,1,2)
  110BQ    %   Push 110, convert to binary, add 1 element-wise: gives [2 2 1 2 2 2 1]
  X@       %   Push current iteration index, starting at 1
  YS       %   Cyclic shift to the right by that amount
  Ys       %   Cumulative sum
  m        %   Ismember. Gives an array of true of false entries
  ?        %   If all true
    @      %     Push current character
           %   End (implicit)
           % End (implicit)
           % Display (implicit)

Mathematica, 110 bytes (ISO 8859-1 encoding)
±i_:=#&@@@Select["A#BC#D#EF#G#"~StringTake~{Mod[#,12,1]}&/@#&/@(Accumulate[i~Prepend~#]&/@Range@12),FreeQ@"#"]

Defines a unary function ± taking a list of integers as input (no restrictions on the size or signs of the integers, actually) and returns a list of one-character strings. For example, ±{3,4} returns {"A","D","E"}.
"A#BC#D#EF#G#"~StringTake~{Mod[#,12,1]}&/@# is a function that turns a list of integers into the corresponding note names, except that # stands for any black key. This is applied to each element of Accumulate[i~Prepend~#]&/@Range@12, which builds up a list of note values from the list input list of note intervals, starting with each possible note from 1 to 12. We filter out all such note-name lists that contain "#" using Select[...,FreeQ@"#"], and then return the first note in each remaining list using #&@@@.

Nice submission!

Question: Does Mathematica use its own byte system? This is 110 characters but in UTF-8 it's 111 bytes because of the +/- symbol.

You can completely strip the assignment and just "implicitly return" a function.

@wizzwizz4: I found I had to name the variable in Accumulate[i~Prepend~#]& because otherwise there'd be a currying clash. Feel free to find a workaround though!

@HyperNeutrino: you're right that UTF-8 is the standard encoding, but Mathematica can (usually) function in ISO 8859-1 encoding as well. I've noted that in the post.

Alright. Thanks, I just needed clarification that the bytecount was correct.

Python 2, 159 155 bytes
(Posting this after making sure there's a valid submission that's shorter than this one)
import numpy
s='C.D.EF.G.A.B'
def k(y):return lambda x:s[(x+y)%12]
for i in range(12):
    if s[i]!='.'and'.'not in map(k(i),numpy.cumsum(input())):print s[i]

Pretty much just the trivial solution. Inputs as a list of integers and outputs with each character on an individual line.
-4 bytes by removing an unnecessary variable

JavaScript (ES6), 72 71 68 bytes
a=>[..."C1D1EF1G1A1B"].filter((c,i,b)=>!+c>a.some(e=>+b[i+=e,i%12]))

Loops through each key omitting black keys, then checking that the cumulative sum of semitones never lands on a black key.
Edit: Saved 3 bytes thanks to @Arnauld.

Readability?! Are you sure you're on the right site? :-)


text:
Golfing end-to-end encryption

This challenge carries a bounty of 200 points for the first to answer and remain unbeaten for at least 3 days. Claimed by user3080953.

There's a lot of talk lately about end-to-end encryption, and pressure on companies to remove it from their products. I'm not interested in the rights-and-wrongs of that, but I wondered: how short can code be that would get a company pressured into not using it?
The challenge here is to implement a Diffie Hellman key exchange between two networked systems, then allow the users to communicate back-and-forth using the generated symmetric key. For the purpose of this task, no other protections are required (e.g. no need to cycle the key, verify identities, protect against DoS, etc.) and you can assume an open internet (any ports you listen on are available to everyone). Use of builtins is allowed and encouraged!
You may choose one of two models:

A server and a client: the client connects to the server, then server or client can send messages to the other. Third-parties in between the two must be unable to read the messages. An example flow could be:

User A launches server
User B launches client and directs it to user A's server (e.g. via IP/port), the program opens a connection
User A's program acknowledges the connection (optionally asking the user for consent first)
User B's program begins generation of a DH secret, and sends the required data (public key, prime, generator, anything else your implementation needs) to User A
User A's program uses the sent data to complete generation of the shared secret and sends back the required data (public key) to User B. From this point, User A can enter messages (e.g. via stdin) which will be encrypted and sent to User B (e.g. to stdout).
User B's program completes generation of the shared secret. From this point, User B can send messages to User A.

Or: A server with two clients connected to it: each client talks to the server, which forwards their message to the other client. The server itself (and any third-parties in between) must be unable to read the messages. Other than the initial connection, the process is the same as that described in the first option.

Detailed rules:

You can provide a single program, or multiple programs (e.g. server & client). Your score is the total code size across all programs.
Your program must be theoretically capable of communicating over a network (but for testing, localhost is fine). If your language of choice doesn't support networking, you can combine it with something that does (e.g. a shell script); in this case your score is the total code size across all languages used.
The Diffie Hellman key generation can use hard-coded "p" and "g" values.
The generated shared key must be at least 1024 bits.
Once the key is shared, the choice of symmetric-key encryption is up to you, but you must not pick a method which is currently known to have a practical attack against it (e.g. a caesar shift is trivial to reverse without knowledge of the key). Example permitted algorithms:

AES (any key size)
RC4 (theoretically broken, but no practical attacks that I can find mention of, so it's allowable here)

Users A and B must both be able to send messages to each other (two-way communication) interactively (e.g. reading lines from stdin, continually prompting, or events such as pressing a button). If it makes it easier, you may assume an alternating conversation (i.e. after a user sends a message, they must wait for a response before sending their next message)
Language builtins are permitted (no need to write your own cryptographic or networking methods if they're already supported).
The underlying communication format is up to you.
The communication steps given above are an example, but you are not required to follow them (as long as the necessary information is shared, and no middle-men are able to calculate the shared key or messages)
If the details needed to connect to your server are not known in advance (e.g. if it listens on a random port), these details must be printed. You can assume that the IP address of the machine is known.
Error handling (e.g. invalid addresses, lost connections, etc.) is not required.
The challenge is code golf, so the shortest code in bytes wins.

Is hardcoding p and g allowed?

@ASCII-only from what I can tell, hard-coding good quality p & g values is considered fine (unless the developer maliciously uses values known to be vulnerable to particular attacks). So for this challenge it's OK (as long as the resulting secret is at least 1024 bits)

Node.js (372 423+94=517 513 bytes)
Golfed
Linebreaks added for "readability".
chat.js (423 419 bytes)
No line breaks
[n,c,p]=["net","crypto","process"].map(require);r="rc4",a="create",h="DiffieHellman",z="pipe",w="write",o=128,g=p.argv;s=e=d=0,y=c[a+h](8*o),k=y.generateKeys();v=n.connect(9,g[2],_=>{g[3]&&(v[w](y.getPrime()),v[w](k));v.on("data",b=>{s||(g[3]||(y=c[a+h](b.slice(0,o)),k=y.generateKeys(),v[w](k),b=b.slice(o)),s=y.computeSecret(b),e=c[a+"Cipher"](r,s),p.stdin[z](e)[z](v),d=c[a+"Decipher"](r,s),v[z](d)[z](p.stdout))})})

Line breaks
[n,c,p]=["net","crypto","process"].map(require);
r="rc4",a="create",h="DiffieHellman",z="pipe",w="write",o=128,g=p.argv;
s=e=d=0,y=c[a+h](8*o),k=y.generateKeys();
v=n.connect(9,g[2],_=>{g[3]&&(v[w](y.getPrime()),v[w](k));
v.on("data",b=>{s||(g[3]||(y=c[a+h](b.slice(0,o)),k=y.generateKeys(),
v[w](k),b=b.slice(o)),s=y.computeSecret(b),e=c[a+"Cipher"](r,s),p.stdin[z](e)[z](v)
,d=c[a+"Decipher"](r,s),v[z](d)[z](p.stdout))})})

echo_server.js (94 bytes)
c=[],require("net").createServer(a=>{c.forEach(b=>{a.pipe(b),b.pipe(a)});c.push(a)}).listen(9);

Ungolfed
Node has built-in networking and crypto capabilities. This uses TCP for networking (because it's simpler than Node's interface for HTTP, and it plays nicely with streams).
I use a stream cipher (RC4) instead of AES to avoid having to deal with block sizes. Wikipedia seems to think it can be vulnerable, so if anyone has any insights into which ciphers are preferred, that would be great.
Run the echo server node echo_server.js which will listen on port 9.
Run two instances of this program with node chat.js <server IP> and node chat.js <server IP> 1 (the last argument just sets which one sends a prime). Each instance connects to the echo server. The first message handles the key generation, and subsequent messages use the stream cipher.
The echo server just sends everything back to all the connected clients except the original.
Client
var net = require('net');
var crypto = require('crypto');
var process = require('process');
let [serverIP, first] = process.argv.slice(2);

var keys = crypto.createDiffieHellman(1024); // DH key exchange
var prime = keys.getPrime();
var k = keys.generateKeys();
var secret;

var cipher; // symmetric cipher
var decipher;

// broadcast prime
server = net.connect(9, serverIP, () => {
    console.log('connect')
    if(first) {
        server.write(prime);
        console.log('prime length', prime.length)
        server.write(k);
    }

    server.on('data', x => {
        if(!secret) { // if we still need to get the ciphers
            if(!first) { // generate a key with the received prime
                keys = crypto.createDiffieHellman(x.slice(0,128)); // separate prime and key
                k = keys.generateKeys();
                server.write(k);
                x = x.slice(128)
            }

            // generate the secret
            console.log('length x', x.length);
            secret = keys.computeSecret(x);
            console.log('secret', secret, secret.length) // verify that secret key is the same
            cipher = crypto.createCipher('rc4', secret);
            process.stdin.pipe(cipher).pipe(server);
            decipher = crypto.createDecipher('rc4', secret);
            server.pipe(decipher).pipe(process.stdout);
        }
        else {
            console.log('sent text ', x.toString()) // verify that text is sent encrypted
        }
    });
})

Echo server
var net = require('net');
clients = [];

net.createServer(socket => {
    clients.forEach(c=>{socket.pipe(c); c.pipe(socket)});
    clients.push(socket);
}).listen(9)

Thanks Dave for all the tips + feedback!

Don't add readability to the golfed version, that's what the ungolfed version is for. Or if you do that, remove the semicolons before the line breaks, so it's the same length.

@mbomb007 the "readability" is mostly to avoid having to scroll. unfortunately, the body of the code has no semicolons, so that doesn't work. I figured a quick find and replace wouldn't be too onerous. will definitely keep your tip in mind for future comments though!

@Dave thanks for all the feedback!
I've made changes to use vanilla DH, which actually added quite a bit of length because you need to exchange primes as well
AES actually works as a drop-in replacement, but the problem with AES is that nothing sends until you've completed a block, and padding would be a pain. also rc4 is shorter than aes128

I wasn't sure if it would work over a network, but it probably won't, and I wrote it on a bus so I had no way of checking. the new version uses an echo server instead. This also solves the timeout problem. I was trying to avoid a server + client, but it is much better form.
finally, thanks for this challenge, I learned a tonne about how to actually use node instead of just grabbing libraries from everywhere :)

@user3080953 sounds good. With those updates you should be in the running for the bounty!

The goal of having your golfed version be exact is so that we can copy-paste it and the byte count will be accurate.

Node.js, 638 607 bytes
Now that it's been well and truly beaten (and in the same language), here's my test answer:
R=require,P=process,s=R('net'),y=R('crypto'),w=0,C='create',W='write',D='data',B='hex',G=_=>a.generateKeys(B),Y=(t,m,g,f)=>g((c=y[C+t+'ipher']('aes192',w,k='')).on('readable',_=>k+=(c.read()||'').toString(m)).on('end',_=>f(k)))+c.end(),F=C+'DiffieHellman',X=s=>s.on(D,x=>(x+'').split(B).map(p=>p&&(w?Y('Dec','utf8',c=>c[W](p,B),console.log):P.stdin.on(D,m=>Y('C',B,c=>c[W](m),r=>s[W](r+B)),([p,q,r]=p.split(D),r&&s[W](G(a=y[F](q,B,r,B))),w=a.computeSecret(p,B))))));(R=P.argv)[3]?X(s.Socket()).connect(R[3],R[2]):s[C+'Server'](s=>X(s,a=y[F](2<<9))[W](G()+D+a.getPrime(B)+D+a.getGenerator(B)+B)).listen(R[2])

Or with wrapping:
R=require,P=process,s=R('net'),y=R('crypto'),w=0,C='create',W='write',D='data',B
='hex',G=_=>a.generateKeys(B),Y=(t,m,g,f)=>g((c=y[C+t+'ipher']('aes192',w,k=''))
.on('readable',_=>k+=(c.read()||'').toString(m)).on('end',_=>f(k)))+c.end(),F=C+
'DiffieHellman',X=s=>s.on(D,x=>(x+'').split(B).map(p=>p&&(w?Y('Dec','utf8',c=>c[
W](p,B),console.log):P.stdin.on(D,m=>Y('C',B,c=>c[W](m),r=>s[W](r+B)),([p,q,r]=p
.split(D),r&&s[W](G(a=y[F](q,B,r,B))),w=a.computeSecret(p,B))))));(R=P.argv)[3]?
X(s.Socket()).connect(R[3],R[2]):s[C+'Server'](s=>X(s,a=y[F](2<<9))[W](G()+D+a.
getPrime(B)+D+a.getGenerator(B)+B)).listen(R[2])

Usage
This is a server/client implementation; one instantiation will be the server, and the other the client. The server is launched with a specific port, then the client is pointed to the server's port. DH can take a few seconds to set-up if your machine is low on entropy, so the first messages may be delayed a little.
MACHINE 1                       MACHINE 2
$ node e2e.js <port>            :
:                               $ node e2e.js <address> <port>
$ hello                         :
:                               : hello
:                               $ hi
: hi                            :

Breakdown
s=require('net'),
y=require('crypto'),
w=0,                                      // Shared secret starts unknown
Y=(t,m,g,f)=>g(                           // Helper for encryption & decryption
  (c=y['create'+t+'ipher']('aes192',w,k=''))
  .on('readable',_=>k+=(c.read()||'').toString(m))
  .on('end',_=>f(k)))+c.end();
X=s=>s.on('data',x=>(x+'').split('TOKEN2').map(p=>
  p&&(w                                   // Have we completed handshake?
    ?Y('Dec','utf8',c=>c.write(p,'hex'),console.log) // Decrypt + print messages
    :                                     // Haven't completed handshake:
     process.stdin.on('data',m=>          //  Prepare to encrypt + send input
       Y('C','hex',c=>c.write(m),r=>s.write(r+'TOKEN2')),(
       [p,q,r]=p.split('TOKEN1'),         //  Split up DH data sent to us
       r&&                                //  Given DH details? (client)
          s.write(
            (a=y.createDiffieHellman(     //   Compute key pair...
              q,'hex',r,'hex')            //   ...using the received params
            ).generateKeys('hex')),       //   And send the public key
       w=a.computeSecret(p,'hex')         //  Compute shared secret
       //,console.log(w.toString('hex'))  //  Print if you want to verify no MITM
))))),
(R=process.argv)[3]                       // Are we running as a client?
  ?X(s.Socket()).connect(R[3],R[2])       // Connect & start chat
  :s.createServer(s=>                     // Start server. On connection:
    X(s,                                  //  Start chat,
      a=y.createDiffieHellman(1024))      //  Calc DiffieHellman,
    .write(                               //  Send public key & public DH details
      a.generateKeys('hex')+'TOKEN1'+
      a.getPrime('hex')+'TOKEN1'+
      a.getGenerator('hex')+'TOKEN2')
  ).listen(R[2])                          // Listen on requested port

The only requirement for the tokens is that they contain at least one non-hex character, so in the minified code other string constants are used (data and hex).

source: Stack Exchange

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

sort: votes


text:
Binary Branches
Given a binary number, your task is to create a 'branch' of that number, with a depth of 2.
For example, given 0 as input, you should output exactly this:
     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

This should be fairly self explanatory of how the branches should be created. Depth 2 means we calculate branches for numbers of up to 2 numbers longer. We also calculate the branches in order, with zeroes at the top and ones at the bottom.
More test cases:
0

     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

1

     /100
  /10
 /   \101
1
 \   /110
  \11
     \111

00

       /0000
   /000
  /    \0001
00
  \    /0010
   \001
       \0011

01

       /0100
   /010
  /    \0101
01
  \    /0110
   \011
       \0111

10

       /1000
   /100
  /    \1001
10
  \    /1010
   \101
       \1011

11

       /1100
   /110
  /    \1101
11
  \    /1110
   \111
       \1111

Rules

You will never receive characters in the input other than 1 and 0.
0 < length of input < 11.
Trailing whitespace allowed at the end of lines.

0 < length of input < 11 is 11 decimal or binary? :P

@ETHproductions Decimal :P

Jelly, 39 38 bytes
L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’

Try it online!
How?
The art to be printed is:
L  L /N00
L /N0
L/ L \N01
N
L\ L /N10
L \N1
L  L \N11

Where N is the input string and L is a string of spaces of the length of the input string.
As such it is comprised of eight components (L, N, /, 0, the newline character, \, 1, and the space character) and hence may be stored as a base-8 number ( which may be compressed as a base-250 number in Jelly). The ṃ atom combines base conversion and indexing into a list (effectively one may define arbitrary digits to be used).
L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - Main link: binary string s  e.g. "100"
 ⁶                                     - space character
  ẋ                                    - repeat by:
L                                      -     length(s)                    [' ',' ',' ']
    W                                  - wrap s in a list                 [['1','0','0']]
   ,                                   - pair               [[' ',' ',' '],['1','0','0']]
      “/0¶\1 ”                         - char list: ['/','0',<newline>,'\',','1',' ']

     ;                                 - concatenate        [[' ',' ',' '],['1','0','0'],'/','0',<newline>,'\',','1',' ']
                “ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - base 250 number: 91531517467460683226372755994113932025707662527
              ṃ@                       - base decompression [reversed @arguments]
                                        -     this uses the concatenated list above as
                                        -     the 8 digits of that number in base 8.
                                        - implicit print

Batch, 178 170 159 bytes
@set/pb=
@set s=%b:0= %
@set s=%s:1= %
@set e=@echo %s%
%e%  %s% /%b%00
%e% /%b%0
%e%/ %s% \%b%01
@echo %b%
%e%\ %s% /%b%10
%e% \%b%1
%e%  %s% \%b%11

Edit: Saved 11 bytes thanks to @ConorO'Brien.

I only count 149 bytes.

I assume Neil is counting line breaks as the Windows-style CRLF whereas TIO is counting them as LF. I'm not sure whether LF works for Batch on Windows.

Python 3.6, 172 153 128 bytes
Literally does not get more straightforward than this... This is actually shorter than my original attempt at generating it with an algorithm. How sad.
k=input()
l=len(k)
b=' '*l
print(f'{b*2}   /{k}00\n{b} /{k}0\n{b}/ {b}\\{k}01\n{k}\n{b}\\ {b}/{k}10\n{b} \\{k}1\n{b*2} \\{k}01')

-19 bytes thanks to @Leo
-25 bytes thanks to @L3viathan

I think it would be shorter to drop a, c, and d, and use only b and spaces in the final string. (a is b*2+'   ')

Weird, still seems 172 bytes for me.

@programmer5000 Sorry, that would be because I forgot to update the code itself.

Save 26 characters with format strings: print(f'{a}/{k}00\n{b} /{k}0\n{b}/  {b}\\{k}01\n{k}\n{b}\\  {b}/{k}10\n{b} \\{k}1\n{b*2}   \\{k}01')

@L3viathan Can you check the syntax on that? It's giving me a syntax error.

Are you on Python 3.6?

@L3viathan No, 3.4.3.

Well, in the latest version of Python (3.6+), it's not a syntax error, as f-strings were introduced then.

@L3viathan Oh okay. I'll take your word for it, I'll install 3.6 at some point in time. Thanks!

{b}{b} can become {b*2} or {b+b}.

JavaScript (ES6), 112 bytes
s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

Demo

let f =

s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

console.log(f('0'))
console.log(f('11'))
console.log(f('101'))

why not [n,n,s.replace(/./g,' '),s,'\\'][n]?

@tsh That would require to search for /\d/g rather than /./g to ignore non-numeric characters.

Python 3, 117 109 bytes
lambda k:'ll   /g00\nl /g0\nl/l  \g01\ng\nl\l  /g10\nl \g1\nll   \g11'.replace('l',' '*len(k)).replace('g',k)

Try it online!

saved 8 bytes thanks to JonathanAllan (Use of lambda function)

The format string when printed looks like:
ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

This looks good already for string of length of 1. All we got to do is replace l by spaces of length equal to that of g and, of course, g is to be replaced by the original string

You can save a byte using an unnamed lambda, which also means you can get rid of the print (since returning the string should be acceptable) and save another seven bytes. You can then save two more by using a multiline string getting you down to 107... TIO

C, 170 168 bytes
Thanks to @Neil for saving two bytes!
n;f(char*s){n=strlen(s);printf("%*c%s00\n%*c%s0\n %*c%*c%s01\n%s\n %*c%*c%s10\n%*c%s1\n%*c%s11",2*n+4,47,s,n+2,47,s,n,47,n+3,92,s,s,n,92,n+3,47,s,n+2,92,s,2*n+4,92,s);}

Try it online!

Rather than printing a / or \ padded to width n+1, why not print a space, and then a / or \ padded to width n?

Ugh, let me try that again. Rather than printing a / or \ padded to width n+1, why not print a space, and then a / or \ padded to width n?

PHP, 128 bytes
Only a simple Output

<?=$b=str_pad("",strlen($a=$argn)),"$b   /{$a}00\n$b /{$a}0\n$b/$b  \\{$a}01\n$a\n$b\\$b  /{$a}10\n$b \\{$a}1\n$b$b   \\{$a}11";

Try it online!

Python 3, 96 bytes
lambda s:"""   /00
 /0
/  \01

\  /10
 \1
   \11""".translate([s,' '*len(s),s])

Try it online! The unprintable characters do not display correctly; the string format is the same as officialaimm's, but with \x01 for l and \x02 for g.
ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

Uses string substitution with Python 3's flexible translate. The translate list [s,' '*len(s),s] maps \x01 to ' '*len(s) and \x02 to s. Any larger characters are unchanged because they give indices that are out-of-bounds for the list. \x00 could not be used because a null byte is read as a program end, so the first entry is wasted.

Stacked, 81 bytes
{!n#'' '*@s's  s /n00
s /n0
s/ s \n01
n
s\ s /n10
s \n1
s  s \n11' '\l'$#~1/repl}

Try it online!
Not very interesting, unfortunately. Here's the most interesting part:
'\l'$#~1/repl
         repl     replace all
'\l'              letters
    $#~           by evaluating
       1/         over one argument (otherwise, it would evaluate the "last" thingy)

This is basically string interpolating, but 10 bytes shorter than the builtin.

///, 116 bytes
/[/\\\///x///*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

Try it online!
Input is as follows:
/[/\\\///x/INPUT HERE!!!!!!!!//*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

Works by using a basic template, and adding spaces and characters where needed.
The byte count went up because Ørjan Johansen realized that it did not handle spacing at first. But the problem is know fixed.

I gave you an upvote before checking that it worked - but you're not adjusting the spacing for length. I don't see a succinct way to do that with such a literal input format.

Or wait, it's not totally hopeless since there's an input length limit of 11.

Something like /*/\/y0\/ y\/\/y1\/ y\//**********/y///s/yx/ and then you get spacing with s.

@ØrjanJohansen Oops, forgot about spacing... thanks. How would I incorporate your code into the answer?

FWIW /00/0|0//01/0|1//10/1|0//11/1|1//|/<\\y>//z/<y>x//<y>0/ //<y>1/ //<\\y\>///s/z/ can handle arbitrary length.

Put it after the first substitution, and otherwise use s where you need variable spacing of the length of the input.

Hm just testing the short version, it's not quite right. Oh duh you need \\\ inside y0 and y1.

Not very deliberately, but (1) Your mention of my BCT interpreter was what drove me to join this site (2) We seem to have similar tastes (3) As a result of (1) and (2), I now do notice when your nick is on the front page.

@ØrjanJohansen Fair... On the other hand, what is the completed spacing fix? "Inside" could mean a lot if things.

Sample use, replace the xsx at then end as needed: /x/01001100//*/\/y\\0\/ y\/\/y\\1\/ y\//**********/y///s/yx/xsx.

Python 2, 101,91 bytes113 bytes
lambda y:'   ++/_00\n +/_0\n+/  +\\_01\n_\n+\\  +/_10\n +\\_1\n   ++\\_11'.replace('_',y).replace('+',' '*len(y))

Try it online!
Input is a string of 0's and 1's of length 1 or 2! That is 0,01,10 or 11!
+12  bytes - corrected the spacing in \ for length two input.

your output does not adjust as per the length of the string.

...and the question specifies "0 < length of input < 11".

@officialaimm oh yeah. Just noticed. Thanks. Will update my answer! Jonathan.. that was a typo. Thanks I corrected it.

Charcoal, 34 bytes
Ｐ<³←⮌θＦ²«Ｊ³⁻×⁴ι²θＰ<²Ｉι↗Ｆ²«Ｐ⁺⁺θικ↓↓

Try it online! Link is to verbose version of code. Explanation:
Ｐ<³

Print the left pairs of /s and \s.
←⮌θ

Print the input right-justified at the current position.
Ｆ²«

Loop through the branches.
Ｊ³⁻×⁴ι²

Move the the position of the branch. We can do this because the root was printed right-justified so that the middle branch is always at the same absolute position.
θ

Print the input.
Ｐ<²

Print the right pair of / and \.
Ｉι

Print the branch suffix.
↗

Move to the first leaf.
Ｆ²«

Loop through the leaves.
Ｐ⁺⁺θικ

Print the input and the branch and leaf suffix.
↓↓

Move to the next leaf. Note: If trailing whitespace was acceptable then Ｆ²⁺⁺⁺θικ¶¶ would save a byte.

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


text:
How fast is my Hot Wheels car?
Several years back, Hot Wheels made a simple flash game called "Formula Fuelers Racers"*.  To play the game, you select three ingredients from a fridge to put into your car, which is then raced against the computer's randomly-generated car.  It turns out the mechanics of this game are pretty simple.  First off, the actual race "time" of your car is randomly generated and has no bearing on whether or not you win the race.  Secondly, the winner of the race is determined by a score which is calculated from the selected ingredients (duplicate ingredients are allowed, and the order matters).  Each ingredient has an associated "value" and an associated "operation" as shown in the following table:
#   ingredient     val  op
1   Hot Salsa       2   +
2   Root Beer       1   +
3   Milk            1   +
4   Pickle Juice    2   +
5   Mystery Lunch   -3  *
6   BBQ Sauce       2   +
7   Egg             1   +
8   Ketchup         2   +
9   Mustard         -1  *
10  Melon           1   +
11  Chocolate Milk  1   +
12  Mayonnaise      -2  *
13  Baby Food       0   +
14  Pepper          1   +
15  Salt            2   +
16  Syrup           -1  *
17  Salad Dressing  2   +
18  Orange Juice    1   +
19  Soy Sauce       2   +

For convenience, this challenge will be referring to ingredients by their number and not their name.  Here are the steps to compute a score:

First, initialize the score with the value of the first ingredient.
Then, use the second ingredient's operation to combine the current score and the second ingredient's value to get an updated score.
Finally, use the third ingredient's operation to combine the current score and the third ingredient's value to get the final score.

Higher scores are better and always beat lower scores.
For example, the ingredients 1 2 3 have a score of (2+1)+1 = 4.  The ingredients 7 5 6 have a score of (1*-3)+2 = -1.  Therefore, 1 2 3 beats 7 5 6.
Challenge
In this challenge, you shall write a program which takes an ordered list of 3 integers and outputs the corresponding score.
Input
Your program may accept a list of three integers in the most convenient format.  You are allowed to use either 1-indexing for the ingredient names (as above) or 0-indexing (subtract 1 from every index above).
Ouput
Your program must output a single integer indicating the score.
Test Cases
4 5 5  =>  18 // max score
5 5 5  =>  -27 // min score
13 13 13  =>  0
1 2 3  =>  4
7 5 6  =>  -1
16 2 19  =>  2
19 7 12  =>  -6

*This page is pretty outdated and doesn't work in some browsers, but you don't need to play the game for this challenge.

So basically Salsa+Lunch+Mayo=Invincible?

@SIGSEGV Duplicate ingredients are allowed. Salsa, Lunch, Lunch is allowed for a score of 18 that beats your 12.

For reference, here is an archive of the game.

Who keeps salt in the fridge? :)

LUNCH LUNCH LUNCH means your car explodes the second the wheels touch pavement then I s'pose.

I don't know why salt would be in a fridge.  2. Yes, once you discover an 18-point combo you become literally invincible and the game becomes meaningless.

Can we take input ingredients in reverse order? ([3,2,1] instead of [1,2,3])

@carusocomputing No, the score would then be 0, which is beaten by 18.

@EriktheOutgolfer the score is -27 for L L L. I meant "explode" with a negative connotation.

@Arnauld I'm leaning towards "no" mainly because that will probably affect the "golfiness" of the other existing answers.

Jelly, 24 bytes
“zẈ€$ụ¤’b6’ị@µỊị⁾+×żCFḊV

Takes a list of 0-indexed ingredients.
Try it online! or see a test suite
How?
Uses a slightly convoluted form of compressing the values as a base-6 number and the fact that the multiplicative entries are the negative ones. Instead of simply shifting up by 3 to get the base-6 digits, the complemented values incremented are used - this saves bytes by allowing the Ị atom to pick out the negative entries prior to the complement step while also saving a byte in the base-250 compression.
“zẈ€$ụ¤’b6’ị@µỊị⁾+×żCFḊV - Main link: 0-based ingredient list  e.g. [6,4,5]
“zẈ€$ụ¤’                 - base 250 compressed number: 120851767994004
        b6               - convert to base 6: [1,1,0,5,0,1,0,3,1,1,4,2,1,0,3,0,1,0,0]
          ’              - decrement: [0,0,-1,4,-1,0,-1,2,0,0,3,1,0,-1,2,-1,0,-1,-1]
           ị@            - index into [reversed @rguments]          [0,4,-1]
             µ           - monadic chain separation (call that x)
              Ị          - insignificant(x)? (abs(x)<=1)            [1,0,1]
                ⁾+×      - ['+','×']
               ị         - index into                               ['+','×','+']
                    C    - complement(x) (1-x)                      [1,-3,2]
                   ż     - zip                                      [['+',1],['×',-3],['+',2]]
                     F   - flatten                                  ['+',1,'×',-3,'+',2]
                      Ḋ  - dequeue                                  [1,'×',-3,'+',2]
                       V - evaluate as Jelly code                   -1

How does the "base 250 compressed number" part work?

@ckjbgames The zẈ€$ụ¤ are read as their (1-indexed) indexes in the Jelly code-page, which are [123,188,13,37,226,4], and interpreted as a base-250 number: 123*250**5+188*250**4+13*250**3+37*250**2+226*250**1+4*250**0=120851767994004 (see the string-literal section of the tutorial.)

Oh, a string literal.

This was my approach until I realized "-3" doesn't mean "-3" when evaluating as 05AB1E code.

JavaScript (ES6), 89 84 82 78 73 bytes
Takes input as an array of 3 integers, using 0-indexing.
a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

Test cases

let f =

a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

console.log(f([3, 4, 4]))     // =>  18
console.log(f([4, 4, 4]))     // =>  -27
console.log(f([12, 12, 12]))  // =>  0
console.log(f([0, 1, 2]))     // =>  4
console.log(f([6, 4, 5]))     // =>  -1
console.log(f([15, 1, 18]))   // =>  2
console.log(f([18, 6, 11]))   // =>  -6

Previous version, 78 bytes
Takes the 3 integers in currying syntax (a)(b)(c), using 0-indexing.
a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

How it works
One slightly unusual thing about this code is that it only takes 2 arguments in 'common' currying syntax a => b => and eventually returns a function that takes the 3rd one.
Breakdown
F = n => '5445054524413452545'[n] - 3
o = a => b => (n = F(b)) < 0 ? a * n : a + n
f = a => b => o(o(F(a))(b))

f(a)(b)(c)
  |  |  |
  |  |  +-- 'b' argument of the function returned by the outer call to 'o'
  |  +----- 'b' argument of the function returned by 'f'
  +-------- 'a' argument of 'f'

Test cases

let f =

a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

console.log(f(3)(4)(4))     // =>  18
console.log(f(4)(4)(4))     // =>  -27
console.log(f(12)(12)(12))  // =>  0
console.log(f(0)(1)(2))     // =>  4
console.log(f(6)(4)(5))     // =>  -1
console.log(f(15)(1)(18))   // =>  2
console.log(f(18)(6)(11))   // =>  -6

Strictly speaking, you're taking 1 argument and returning a function that takes 1 argument, computes a value to invoke a function that takes 1 argument and returns a function that takes 1 argument, and returns that final function...

PHP, 128 Bytes
$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($i[$c]-3<0?mul:add))((bc.($i[$b]-3<0?mul:add))($i[$a]-3,$i[$b]-3),$i[$c]-3);

PHP, 138 Bytes
$d=decbin(506743);$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

Online Version
Expanded
$d=decbin(506743);
$i="5445054524413452545";
[,$a,$b,$c]=$argv;
echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

Befunge, 74 73 bytes
>&:0`!#^_1g68*-^:0`!#v_+
^2112-212/11.012/212 >*
^   @.$<       >">"35*0p

Try it here! It's weird that my code works on this one interpreter only.
The second row basically contains all of the values from the table. The non-numeric values are actually negative values as they come before the digits on the ASCII table. There's a bit of logic there that determines if the number is negative or not, and if it is, this number is multiplied by the result.
The right side of the third row initializes the first number. If I didn't have to do that, I could save a lot of bytes.

Python 2, 123 110 107 bytes
a,b,c=input()
s=[int(i)-3for i in'05445054524413452545']
n=s[a]
for i in s[b],s[c]:n=[n*i,n+i][n>0]
print n

Try it online!

-3 bytes thanks to @mathjunkie

Here is an improved version, 118 bytes

5445054524413452545 then subtract 3 may save you tons of bytes.

n=[n+i,n*i][i<0] inside the loop saves you 3 bytes

05AB1E, 29 bytes
•6SÚ²ÄOÃ•6BS3-©¹è|v®yèD0‹i*ë+

Try it online!
•6SÚ²ÄOÃ•6BS3-©               # Push [2, 1, 1, 2, -3, 2, 1, 2, -1, 1, 1, -2, 0, 1, 2, -1, 2, 1, 2] and store.
               ¹è             # Get first score.
                 |v           # Iterate through remaining scores.
                   ®yèD0‹i*ë+ # Push score list, grab relevant score.
                              # If negative, multiply, else add.

This actually works for as many or as few inputs as you'd like, so you can have cars with 4 or more traits or cars with just 2. This was not intentional, just how it ended up.

CJam, 43 38 bytes
q~[YXXY-3YXYWXX-2TXYWYXY]f={_W>42+c~}*

There might be a way to compress the list further...
Uses 0-based indexing.
Try it online!
Explanation
This program makes use of the fact that a value is multiplicative instead of additive if and only if its negative.
q~                     e# Get the list from input
  [...]                e# Push the list of values for each ingredient. T=0, W=-1,
                       e#   X=1, Y=2.
       f=              e# Get the elements at the given indices
         {             e# Reduce over this block:
          _W>          e#  Check if the second number is > -1 (returning 0 or 1)
             42+c      e#  Add the result to 42 and cast to a char.
                       e#    (ASCII 42 is * and 43 is +)
                 ~     e#  Eval the char (* is multiply, + is add)
                  }*   e# (end block)

Nice + * trick!

Lua, 140 131 bytes

i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)loadstring(("print("..i[a].."+"..i[b].."+"..i[c]..")"):gsub('%+%-','*-'))()end

i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)x,y,z=i[a],i[b],i[c]v=y>0 and x+y or x*y;print(z>0 and v+z or v*z)end

JavaScript, 85 72 bytes
a=a=>eval(a.map(x=>(b="5445054524413452545"[x]-3,b<0?"*":"+")+b).join``)

Takes input in format [a,b,c]
-13 bytes thanks to ETHproductions

You can do x=>(b="...",b<0?"*":"+")+b to avoid the return, I think. (Also, you don't need the [... ], indexing works on strings)

@ETHproductions I get "Expected ';'. It may be my browser, does a=a=>eval(a.map(x=>(b="5445054524413452545"[x]-3,b<0?"*":"+")+b)).join``) work for you?

You've got an extra ) after +b, I believe

R, 125 123 bytes
function(a,b,c){v=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)-3
o=rep("+",19)
o[v<0]="*"
get(o[c])(get(o[b])(v[a],v[b]),v[c])}

Anonymous function that takes three integers as input. Defines a list of values and operations, and then just evaluates the ones called by the input, i.e. o3(o2(v1,v2),v3). There's almost definitely a golfier way to do this!
Update: after some re-working, I have an alternative, also 123 bytes. Again, an anonymous function, but takes input as a single vector of three values. Uses the same approach, defining a list of values and operations and evaluating it.
function(x,f=c(sum,prod)[x[-1]%in%c(5,9,12,16)+1],s=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)[x]-3)f[[2]](el(f)(s[-3]),s[3])

Haskell, 186 116 112 108 bytes
o x|x<0=(*)|0<1=(+)
v=(map((-51+).fromEnum)"95445054524413452545"!!)
w [x,y,z]=(o z)((o y)x y)z
k=w.map v

Main function is k.  New to Code Golf so I am sure there are a few bytes I could shave off with clever use of $ operator versus parentheses.  I will probably update the answer as I continue to find improvements.
Essentially the program can be broken down like this:

v is a function that takes a 1 based index and returns the value of that food id.
o is a function that takes the food value and returns the appropriate operator (Eg. negative values are always * where positive values are always +)
w is a function that takes a List of 3 partial functions of v mapped to input integers and fetches the appropriate operations and values from each and returns the proper output.
k is the main function in point free style that maps v to input and composes this list for w to return the output.

UPDATE
Special thanks for pointing out the fromEnum trick!  That worked out nicely.  Also I missed the part in the rules that stated an acceptable solution could be a function that takes a list of integers.  That saved a tremendous amount of work.
UPDATE 2
As per other suggestions, shaved a handful of bytes by reordering operations, creating an else guard that always evaluates to True, and a pattern matching on W that pattern matches on a List of 3 elements.  Thanks for the suggestions!
UPDATE 3
Another thanks to Laikoni for pointing out more code golf rules that I was not aware of.  Also mapping v to my input to create a list of partially applied functions was a phenomenal idea and saved me 4 additional bytes!

Welcome to PPCG and Haskell golfing in particular! You can save a lot of bytes by writing a function [Int] -> Int instead of reading from stdin and writing to stdout. Doing so is allowed by default, but in this case its even explicitly mentioned in the challenge that taling a list of integers as input is acceptable.

Using fromEnum instead of digitToInt is likely to be shorter because it allows you to drop the import.

@Laikoni Much thanks to you for pointing out some of the rules I wasn't aware of!  The fromEnum trick worked like a charm too, don't know why I didn't think of working from the ASCII code but that saved a tremendous amount of bytes as well.

v=(map((-51+).fromEnum)"95 ... 5"!!) saves two parenthesis. o x|x<0=(*)|0<1=(+) saves one byte in the second guard.

In w is an extra space left. Also, as you only need to handle lists of length 3, you can use w[x,y,z]= as pattern matching.

@Laikoni Thanks for the additional suggestions.  I still think I can shave an additional byte off of w but I am having trouble with it.  I will see what I can do.

Anonymous functions are allowed as submission, so you can have w.map v as main function and save all the calls to v in w. Then v is only used once and can be inlined.

92 bytes: o x|x<0=(*)|0<1=(+);k w|[x,y,z]<-([read[q]-3|q<-"95445054524413452545"]!!)<$>w=zoo y x y$z

@BlackCap sounds like you should post this as an answer

Haskell, 92 87 bytes
x#y|x<0=(y*)|0<1=(y+)
k[x,y,z]=z#z$y#x$y
k.map([read[q]-3|q<-"95445054524413452545"]!!)

Try it online!

Based on @maple_shaft's answer, I just factorized it a bit.
Thanks to @Laikoni for 5 bytes!

87 bytes: Try it online!

@Laikoni I am pretty sure the newlines count

I didn't count the two bytes for f= because anonymous functions are allowed as submission. They are only required to make the tio example work.

8086 machine code, 62 bytes
00000000  be 3b 01 31 c0 86 c4 ac  e8 0a 00 81 fe 3e 01 72  |.;.1.........>.r|
00000010  f4 b4 4c cd 21 bb 32 01  d0 e8 d7 73 03 c0 e0 04  |..L.!.2....s....|
00000020  c0 f8 04 e3 05 31 c9 c3  86 c4 78 03 00 e0 c3 f6  |.....1....x.....|
00000030  ec c3 21 12 d2 12 f1 1e  01 2f 12 00 00 00        |..!....../....|
0000003e

The last three bytes contain the (zero-indexed) input. Hey, you told me I could use the most convenient input format. In this case, that's hardcoding!
Output is the error code returned to the shell.
How it works:
            |   org 0x100
            |   use16
be 3b 01    |       mov si, input   ; source = input
31 c0       |       xor ax, ax      ; clear ax
86 c4       |   @@: xchg al, ah     ; swap al/ah (ah = total value)
ac          |       lodsb           ; al = *si++
e8 0a 00    |       call fn
81 fe 3e 01 |       cmp si, input+3 ; end of input?
72 f4       |       jb @b           ; repeat if not
b4 4c       |       mov ah, 0x4c    ; dos function: exit with al=error code
cd 21       |       int 0x21        ; syscall
            |
bb 32 01    |   fn: mov bx, table   ; pointer to lookup table
d0 e8       |       shr al, 1       ; divide input by 2
d7          |       xlatb           ; al = *(bx + al)
73 03       |       jnc @f          ; skip next instruction if input was odd
c0 e0 04    |       shl al, 4       ; shift low nibble to high nibble
c0 f8 04    |   @@: sar al, 4       ; shift high nibble to low nibble with sign-extension
e3 05       |       jcxz @f         ; return if cx is non-zero (only happens for the first input)
31 c9       |       xor cx, cx      ; clear cx
c3          |       ret
86 c4       |       xchg al, ah     ; swap al/ah (al = total value)
78 03       |   @@: js @f           ; multiply if negative, add if positive
00 e0       |       add al, ah      ; al = al+ah
c3          |       ret
f6 ec       |   @@: imul ah         ; ax = al*ah
c3          |       ret
21 12 d2 12 |   table db 0x21, 0x12, 0xd2, 0x12, 0xf1, 0x1e, 0x01, 0x2f, 0x12
f1 1e 01 2f |                       ; each value is stored in a 4-bit nibble
12          |
00 00 00    |   input db 3 dup(0)

C, 171 161 bytes
#include<stdio.h>
r,z[3],*a=z,i;f(x){i?x<0?r*=x:(r+=x):(r=x);}main(){scanf("%d %d %d",a,a+1,a+2);for(;i++<3;f("05445054524413452545"[*a++]-51));printf("%d",r);}

105 bytes


text:
How much reputation does a steam user have?
Introduction
For those not familiar with steam - or at least this particular aspect:
Often on peoples' profiles, people leave comments saying either "+rep _____" or "-rep _____". These are an unofficial means of showing whether you think someone in the community has a good or a bad reputation, for a number of reasons. Such comments look like:

+rep a good player
+rep helpful
-rep hacker
-rep scammer

Task
The program must take input through any consensual way. The input consists of a string with optional newlines (\n). At the very start of each line, '+rep ' or '-rep ' might be present. The rest of the line can be discarded. If the line doesn't start with '+rep ' or '-rep ' (note the trailing space), the line should be ignored.
The program then must keep a total reputation score. Starting at 0, this score should be incremented on every line that starts with '+rep ' and decremented on every line that starts with '-rep '.
This result should be output in any agreed-upon way.

Test cases
Input:
+rep fast trade
+rep nice person
-rep too good

Output: 1

Input:
-rep hacker
-rep scammer
-rep was mean

Output: -3

Input:
first
i don't like him
+rep good at cs go

Output: 1

Input (note the lack of a trailing space on the third line):
+rep +rep
hi +rep
-rep

Output: 1

Input:
+ rep

Output: 0

Input:
+rep like
-thing

Output: 1

Bonus
I don't even know if it's possible, but bonus points if you can somehow get these comments from Steam.

Assuming the bonus points are imaginary, correct? They don't actually affect your score.

Will we ever get empty input? What about no occurrences of +/-rep? Will +/-rep always have a trailing space?

Can we assume the only plus and minus signs are in the '+rep'/'-rep'? Will the rep only be at the start of the line, or could it be in the middle also?

@Riker "Each line of the text will start with either "+rep" or "-rep". The rest of the line could contain anything."

dupe?

I would recommend adding a test case where there is a +rep or -rep that isn't at the start of the line

s/+rep.*/1 and s/-rep.*/\x08?

Will the input contain any other symbols other than + and -?

What is the set of characters the input will contain?

Okay:
The bonus points are imaginary
The input can be empty, in which case the output will be 0
+/-rep will always have a trailing space
It is codegolf
The +/- signs are not necessarily in the rep
The +/-rep must be at the start of a line

@JacobGarby What does +rep output?

@KritixiLithos 1

@JacobGarby But you said that rep will always have a trailing space, yet the testcase I provided does not seem to fit that rule

@KritixiLithos True... In which case no, +rep would output 0

We aim for a strict definition of the rules so that there aren't 500 different interpretations.

By this point, there are very few interpretations, with very little variation between them. But okay - I think I've cleared everything up now.

I believe that example 4 should have output 0, not 1.

Hi Jacob, and welcome to PPCG. You've managed to get a quite active conversation for your first challenge here! Since no one else has yet mentioned it, I'll direct you to the Sandbox where you can get meaningful feedback and hammer out any details or clarification issues before posting the challenge to Main. In the future, that will help you avoid downvotes, closevotes, and the like. I hope you stick around and enjoy your stay!

What about +rep -rep?

The spec says that there isn't any need for a trailing space, 3rd test case and you are saying the opposite. Please update the post accordingly to what you meant.

Hey everyone, I'd like to kinda hijack the comments and note down that the reputation comments usually don't mean much as malicious people can and do pay people in items to post +rep comments to their profile. Stay safe!

05AB1E, 18 16 17 bytes
Saved 2 bytes thanks to Okx
+1 byte due to change in spec where rep now need to be followed by a space.
|vy5£„+-S„·Ý «QÆO

Try it online!
Explanation
|v                   # for each line of input
  y5£                # get the first 4 chars of input
     „+-S„·Ý «       # push the list ['+rep ','-rep ']
              Q      # check each for equality
                     # results in either [1,0] for +rep, [0,1] for -rep or [0,0] for others
               Æ     # reduce by subtraction, gives either 1, -1 or 0
                O    # sum

You can replace ð¡0è with 4£. I was working on a solution to this at the same time you were.

@Emigna I feel like my idea of |ðý#D'·Ý©.åÏ®1:O can be 14 or 15, I'm just not seeing it. Also stuck at 16, maybe it will help you though. I'll leave it here. Basically replacing the word "rep" with the number "1" so you can direct sum.

@carusocomputing: I think I have it at 14 yes. Just gotta some more tests :)

Better to beat the inevitable Jelly tie before it happens ;).

@carusocomputing: actually my way 0|vy4£'·Ý1:R.V doesn't work for lines not starting with +/- rep. Back to the drawing board :(

I think it's actually 17 bytes: |vy5£„+-S„·Ý «QÆO, since you need to check for the space after rep too.

@carusocomputing Jelly is highly unlikely to beat 05AB1E here.

@EriktheOutgolfer: Yeah that seems to have been edited in to the question as someone was asking to have it... :/

@Emigna fəˈnɛtɪk edited it in.

@EriktheOutgolfer I edited it in but it was already specified by the OP.   "The input can be empty, in which case the output will be 0 +/-rep will always have a trailing space It is codegolf The +/- signs are not necessarily in the rep The +/-rep must be at the start of a line" – Jacob Garby

I don't think mine is affected by the change, so you can use |ðý#D'·Ý©.åÏ®1:O for 16 if you like; because it's splitting on spaces, the space is accounted for. Half of that was inspired by this answer anyhow.

@carusocomputing: Unfortunately, that counts rep's which are not at the start of the line as well. I like the idea of using the operations from the input together with 1, but I haven't found a way to modify it below 17.

Python 3, 73 bytes
I'm sure this answer is garbage and will be beaten soon, but there's no other python answers yet
lambda x:sum(["- +".index(i[0])-1for i in x.split('\n')if i[1:4]=="rep"])

Use like this:
f = lambda x:sum(["- +".index(i[0])-1for i in x.split('\n')if i[1:4]=="rep"])
print(f("PUT INPUT HERE"))

Fetching from steam
Here's some sample code which fetches the first 100 comments from KennyS' profile and calculates his rep.
import requests
from bs4 import BeautifulSoup

# Kenny's profile as Steam ID 64
# You can adjust this to whatever numbers you want
STEAM_PROFILE_URL = "76561198024905796"
payload =  {"start" : 0, "count" : 100}
r = requests.post("http://steamcommunity.com/comment/Profile/render/{}/-1/".format(STEAM_PROFILE_URL), payload)

# Comments are html inside a json object
soup = BeautifulSoup(r.json()["comments_html"], "html.parser")

# Get raw text for every comment.
# The " ".join() strips out the newlines and tabs which are part of html
comments = [" ".join(s.text.split()) for s in soup.find_all("div", {"class" : "commentthread_comment_text"})]

calculateRep = lambda x:sum(["- +".index(i[0])-1for i in x.split('\n')if i[1:4]=="rep"])

print(calculateRep("\n".join(comments)))

if"rep"==i[1:4] for -1

You don't need the square brackets

Perl 5, 25 bytes
24 bytes of code + -p flag.
$\+=/^\+rep /-/^-rep /}{

Try it online!
/^\+rep / returns 1 if the line starts with +rep; /^-rep / returns 1 if the line starts with -rep (so only one of them will be one at most). We use $\ to store the result, as it is implicitly printed at the end (thanks to -p flag and those unmatched }{).

Add two bytes because there needs to be a space after rep

This doesn't seem very clear from the spec but since pretty much everyone is doing it, I'll edit that as soon as I get my hands on a computer.

I added it to the specs because the OP had left it as a comment

Python 2, 54 bytes
q=('\n'+input()).count;print q('\n+rep ')-q('\n-rep ')

Try it online! Takes a multiline string as input.
Counts the appearances of '+rep ' and '-rep ' only at starts of lines by searching for the string following a newline symbol. To catch the first line, a newline is prepended to the input.

Retina, 63 51 50 49 bytes
Didn't quite comply with the spec so I fixed some issues but also golfed it a lot (by borrowing the first line from Kritixi Lithos's solution).
Saved another byte thanks to Kritixi Lithos.
ms`(?!^[+-]rep ).

+`\+-|-\+

(.)+
$1$.&
T`+
$^
0

Try it online!
Explanation
ms`(?!^[+-]rep ).

First, everything from the input is deleted, except for the + and - from any +rep or -rep at the start of a line.
+`\+-|-\+

Then adjacent pairs of + and - are removed until no more can be removed. After this, what's left is either a run of +s, a run of -s, or nothing.
(.)+
$1$.&

Then a run of one or more characters (either + or -) is replaced with the character making up the run followed by the length of the run. This way, + is preserved at the start for positive results and - for negatives.
T`+

Then all +s are removed, in the event that the rep is positive.
$^
0

Finally, if the string is empty at this point, the rep is 0, so we write 0.

You can do drop the |¶ and add a s (single-line mode) after the m on the first line

PHP, 118 bytes
function s($a,$c=0){foreach(explode("
",$a)as$b){$b=substr($b,0,1).'1';if(is_numeric($b){$c+=$b});}return$c-($a=="");}

Try it online!
Used like this:
echo s("-rep bad
+rep good
+rep very good
+rep exceeds expectation");

This outputs 1 if you feed it the empty string

@fəˈnɛtɪk fixed

Would recommend fixing your link. It also errors after outputting if you give it a non +/-rep line :P

JavaScript, 55 bytes
Thanks @Neil for golfing off 12 bytes
Thanks @Arnauld for golfing off 2 bytes
x=>x.split(/^\+rep /m).length-x.split(/^-rep /m).length

Try it online!

var y=x=>(x.match(/^\+rep /gm)||'').length-(x.match(/^-rep /gm)||'').length

document.querySelector('div').innerText=y(document.querySelector('textarea').value)
textarea{
  width: 95%;height: 100px;
  }
<textarea oninput = "document.querySelector('div').innerText=y(this.value)">
-rep Cheater!!
+rep very good, fun to play with
+rep my friend +rep
good
</textarea>

Save 12 bytes by using split instead of match (it always returns an array which is 1 longer that you normally want but the two 1s cancel). I also tried to eliminate the duplication but it came out at 57 bytes again.

Retina, 59 53 52 50 bytes
ms`(?!^[+-]rep ).

+`\+-|-\+

-+
-$.&
\++
$.&
^$
0

Try it online!
Check out Basic Sunset's shorter answer in the same language!
Explanation
ms`(?!^[+-]rep ).

Removes everything except for [+-]rep s.
+`\+-|-\+

Repeatedly removes 1 - for every + and vice versa.
-+
-$.&

Prepend a - (because the number is negative) to -s as well as replacing the -s with the number of -s.
\+
$.&

Do the same for +s, but don't prepend a -.
^$
0

Finally, if there is nothing, replace it with a 0.

@fəˈnɛtɪk > +/-rep will always have a trailing space

OK so I edited that into the actual question.

Mathematica, 47 bytes (ISO 8859-1 encoding)
(±c_:=StringCount["
"<>#,c];±"
+rep"-±"
-rep")&

Pure function taking a newline-separated string as input and returning an integer. Note that the three newlines in the code are flanked by quotes and are thus each equivalent to "\n" in a string (but this way is one byte shorter than "\n"). StringCount does the heavy lifting; we manually add a newline to the beginning of the string so that the first line matches when appropriate. ± is a unary helping function to avoid repetition of StringCount.
The alternative solution
(±c_:=StringCount["
"<>#,"
"<>c<>"rep"];±"+"-±"-")&

is 4 bytes longer, but I do like the sequence ±"+"-±"-"....

I think you might need to add a space behind the +/-rep as that was apparently part of the requirements

Röda, 53 bytes
{{|l|[1]if[l=~`\+rep .*`];[-1]if[l=~`-rep .*`]}_|sum}

Try it online!

Java, 109 bytes
l->{int i=0;for(String s:l.split("\n")){if(s.startsWith("+rep "))i++;if(s.startsWith("-rep "))i--;}return i;}

Trying to make this shorter using Stream's

Needs a space after rep

Stacked, 45 bytes
'^([+-])rep |.'{.a:''['#'a+]a if}mrepl'0'\+#~

Try it online!
Alternatively (49 bytes):
lines'^[-+]rep 'match$#'YES[0#0# '#'\+]"!''#`0\#~

Explanation
'^([+-])rep |.'{.a:''['#'a+]a if}mrepl'0'\+#~

This basically extracts all + or - attached to the beginning of the line and rep. Then, to each, it prepends a #. Then, to the entire thing, a 0 is prepended. #~ evaluates the string, which now looks something like:
0#+#+#-

#+ is increment and #- is decrement. Thus, we obtain our desired result.

Retina, 38 bytes
M!m`^[+-]rep
Os`.
+`\+-

*\M1!`-
[+-]

Try it online!
A different (and shorter) solution than the ones already posted in Retina.
Explanation
M!m`^[+-]rep

(This line has a trailing space). Keep only the relevant parts of the input, i.e. the +rep or -rep at the beginning of a line.
Os`.

Sort all characters (including newlines). this will put +s and -s next to each other.
+`\+-

Repeatedly remove +- couples until at most one of the two signs remains.
*\M1!`-

Match the first - (if present) and print it without modifying the string.
[+-]

Count the number of signs remaining, and print it since this is the final stage of the program.

JavaScript ES6, 85 79 bytes
l=>eval(l.split`
`.map(i=>(r=i.slice(0,5))==`+rep `?1:r==`-rep `?-1:0).join`+`)

Try it

f=l=>eval(l.split`
`.map(i=>(r=i.slice(0,5))==`+rep `?1:r==`-rep `?-1:0).join`+`);

console.log(f(`+rep fast trade
+rep nice person
-rep too good`));

console.log(f(`-rep hacker
-rep scammer
-rep was mean`));

console.log(f(`first
i don't like him
+rep good at cs go`));

console.log(f(`+rep +rep
hi +rep
-rep`));

console.log(f(`+ rep`));

console.log(f(`+rep like
-thing`));

Ungolfed
const repcount=list=>{
    let array=list.split("\n");
    let values=array.map(item=>{
        let rep=item.slice(0,5);
        return rep==="+rep "?1:rep==="-rep "?-1:0;
    });
    let result=values.reduce((a,b)=>a+b);
    return result;
};

History
85 bytes
l=>l.split`\n`.map(i=>(r=i.slice(0,5))=="+rep "?1:r=="-rep "?-1:0).reduce((a,b)=>a+b)

C#, 87 bytes
s=>{int n=0;foreach(var t in s.Split('\n'))n+=t.IndexOf("rep ")==1?44-t[0]:0;return n;}

Anonymous function which splits the input string by using the newline character, searches for the "rep " string prefixed by a character and, if it finds it, increments the reputation (the n variable) by 1 or -1.
Full program with ungolfed method and test cases:
using System;

class P
{
    static void Main()
    {
        Func<string, int> f =
        s=>
        {
            int n = 0;
            foreach (var t in s.Split('\n'))
                n += t.IndexOf("rep ") == 1 ?
                    44 - t[0]
                    :
                    0;

            return n;
        };

        // test cases:
        Console.WriteLine(f(@"+rep fast trade
+rep nice person
-rep too good"));       // 1

        Console.WriteLine(f(@"-rep hacker
-rep scammer
-rep was mean"));       // -3

        Console.WriteLine(f(@"first
i don't like him
+rep good at cs go"));  // 1

        Console.WriteLine(f(@"+rep +rep
hi +rep
-rep"));            // 1

        Console.WriteLine(f(@"+ rep"));     // 0

        Console.WriteLine(f(@"+rep like
-thing"));          // 1
    }
}

Note that the ASCII code for + is 43 and for - is 45. This method passes all test cases from the OP. However, if the first character is something else, this will lead to wrong answers!
This can be fixed at the cost of 17 bytes:
C# fixed, 104 bytes
s=>{int n=0;foreach(var t in s.Split('\n'))n+=t.IndexOf("rep ")==1?t[0]==43?1:t[0]==45?-1:0:0;return n;}

The modified anonymous function will check for a + or - sign as the first character in each line.

Japt, 14 bytes
r`œp`1 f".%d

Try it online!
+1 byte for -x flag

C++, 144 bytes
#import<iostream>
int f(){int r=0;for(std::string s;std::getline(std::cin,s);)if((s[0]==43|s[0]==45)&s.substr(1,4)=="rep ")r-=s[0]-44;return r;}

Try it online!

138 bytes

Ruby, 46 bytes
->x{rep=1;eval ?0+x.map{|a|a[/^[+-]rep /]}*''}

Get all the +/-rep from input, and put together in a single string. Then evaluate that for rep=1.

C#, 104 bytes

Despite existing already one solution -- and mine being longer -- I still think I should post it, since the on already here might fail if something like '=rep ' gets in it's way.

Golfed
i=>{var c=0;foreach(var o in i.Split('\n'))c+=o.IndexOf("rep ")!=1?0:o[0]==43?1:o[0]==45?-1:0;return c;}

Ungolfed
i => {
   var c = 0;

   foreach( var o in i.Split( '\n' ) )
      c += o.IndexOf( "rep " ) != 1
         ? 0
         : o[ 0 ] == 43
            ? 1
            : o[ 0 ] == 45
               ? -1
               : 0;

   return c;
}

Ungolfed readable
i => {
   // Counter for the 'reputation'
   var c = 0;

   // Cycle through every line
   foreach( var o in i.Split( '\n' ) )
      // Check if the "rep " string has index 1
      //   ( Index 0 should be the sign )
      c += o.IndexOf( "rep " ) != 1
         // Add 0 if the rep isn't on the right position
         ? 0
         // Check for the '+' sign
         : o[ 0 ] == 43
            // Add 1 if the sign is found
            ? 1
            // Check for the '-' sign
            : o[ 0 ] == 45
               // Add -1 if the sign is found
               ? -1
               // Add 0 if another char is found
               : 0;

   // Return the 'reputation'
   return c;
}

Full code
using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, Int32> f = i => {
            var c = 0;

            foreach( var o in i.Split( '\n' ) )
               c += o.IndexOf( "rep " ) != 1
               ? 0
                  : o[ 0 ] == 43
                  ? 1
                  : o[ 0 ] == 45
                     ? -1
                     : 0;

            return c;
         };

         List<String>
            testCases = new List<String>() {
               @"+rep fast trade
+rep nice person
-rep too good",
               @"-rep hacker
-rep scammer
-rep was mean",
               @"first
i don't like him
+rep good at cs go",
               @"+rep +rep
hi +rep
-rep",
               @"+ rep",
               @"+rep like
-thing",
         };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $"{testCase}\n{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Releases

v1.0 - 104 bytes - Initial solution.

Notes
Nothing to add


text:
Let's do some location arithmetic!
From the Wikipedia article:

Location arithmetic (Latin arithmeticæ localis) is the additive (non-positional) binary numeral systems, which John Napier explored as a computation technique in his treatise Rabdology (1617), both symbolically and on a chessboard-like grid.

What?
Location numerals is a way of writing numbers using letters of the alphabet.

Binary notation had not yet been standardized, so Napier used what he called location numerals to represent binary numbers. Napier's system uses sign-value notation to represent numbers; it uses successive letters from the English alphabet to represent successive powers of two: a = 2^0 = 1, b = 2^1 = 2, c = 2^2 = 4, d = 2^3 = 8, e = 2^4 = 16 and so on.

An example
ab = 1+2 = 3 in base 10
aabb = 1+1+2+2 = 6 in base 10
Note that aabb can be shortened to bc by replacing any 2 instances of a letter by a higher one.
Addition
You just concatenate the two numbers and simplify.
acd + bde = acdbde = abcdde = acebe = abcf = 39 in base 10
Subtraction
Just remove all digits appearing equally in both parts of the subtraction. Expanding (converting b to aa) may be necessary
abde- ad = be = 18 in base 10
Multiplication
This is a bit harder.
Lets say we want to multiply acd (13) by def (56). First you arrange acd vertically:
a
c
d

Then you add def after the first a:
a def
c
d

Now, c is 2 positions later in the alphabet than a, so we add 2 positions in the alphabet to def to make fgh. That is added to the second row.
a def
c fgh
d

Lastly, d is 1 position later in the alphabet than c, so we add 1 position in the alphabet to fgh to make ghi. That is added to the third row.
a def
c fgh
d ghi

Then you take the sum of the right: def + fgh + ghi = deffgghhi = deggghhi = deghhhi = deghii = deghj (728)
Another example of multiplication
Input:
bc * de

First:
b
c

Then
b ef
c

Then
b ef
c fg

Note that we wrote down ef on the first line. That's because bc starts with b, and b is the second letter in the alphabet, so we need to shift de by 1 letter, so it becomes ef.
Then
ef+fg

Output:
eh

Division
This is not part of this challenge, because it can get very complex.
Your actual challenge
Your program or function must take input as a string that looks like this:
a + b

And you must output:
ab

Of course, your program or function must support numbers of arbitrary length (up to the string or input limit of your language) with any of the operators +, -, or *. Some more examples:
Input:
ab + bd

Output:
acd

Input:
d - ab

Output:
ac

Input:
ab * cd

Output:
cf

Notes:

The order of letters in the output doesn't matter, but you can always assume that the order of letters in numbers in the input will be ascending (a before z).
You may take input with a trailing newline and output with a trailing newline.
You may not take input as a list of ab, * and bd for ab * bd.
The english alphabet is used (abcdefghijklmnopqrstuvwxyz)
Your output must be simplified (aa is not allowed, b is required)
The input will be simplified (b + c, not aa + bb or aa + aaaa)
You may require a space before and the operator (+, -, or *), or you may require there to be none.
There will only be one operator per input.
You may assume that the output and the input will never go over 2^27-1 (abcdefghijklmnopqrstuvwxyz)
This is code-golf, so the shortest answer in bytes wins!

d is 2 positions later in the alphabet than c is this wright? shouldn't it be 1? That is added to the second row. on the same sentence, shouldn't it be third?

@FelipeNardiBatista the english alphabet is used here, edited that.

@programmer5000 still, bc*de==efgh but efgh is 240 not 144

bc*de should be eh

@Dada there will only be one operator per input.

May we use our languages native operators in the input string if they differ from the given +-*?

@JonathanAllan yes. Out of curiosity, what language uses something other than +-* for addition, subtraction, and multiplication that you would use for golfing?

Thanks - I asked because Jelly uses × for multiplication and _ for subtraction, I will post in a second (it would have cost seven bytes to perform the required translations).

Are we allowed to output an array of characters?

@Arnauld no, you may not.

Jelly, 26 25 bytes
i@€Øað’2*S;ḟ.Ḣ
ḲÇ€VBṚTịØa

Uses Jelly's operators (× rather than * and _ rather than -) in the input string as allowed by the OP.
(Requires spaces around the operators)
Try it online! or see the test suite
How?
i@€Øað’2*S;ḟ.Ḣ - Link 1, transform from input sub-string to value or operator: sub-string
i@€            - 1st index of, for €ach (or 0 if not found) [reversed @rguments] in:
   Øa          -      lowercase alphabet (i.e. a->1, b->2, ..., non-alpha->0)
     ð         - dyadic chain separation i.e. f(result above, substring):
      ’        - decrement (i.e a->0, b->1, ..., non-alpha->-1)
       2*      - 2 raised to that power
         S     - sum
          ;    - concatenate with the substring
           ḟ   - filter out:
            .  -     0.5 (for an operator substring the evaluated 0.5 is removed)
             Ḣ - head (i.e. the evaluation for a location, and the operator otherwise)

ḲÇ€VBṚTịØa - Main link: string                        e.g. 'ab × cd'
Ḳ          - split on spaces                               [['a','b'],['×'],['c','d']]
 Ç€        - last link (1) as a monadic function for €ach  [3,'×',12]
   V       - evaluate as Jelly code                        36
    B      - convert to binary                             [1,0,0,1,0,0]
     Ṛ     - reverse                                       [0,0,1,0,0,1]
      T    - truthy indexes                                [3,6]
       ị   - index into:
        Øa -     lowercase alphabet                        ['c','f'] (i.e. "cf", which is implicitly printed when run as a full program)

JavaScript (ES6), 136 134 133 bytes
Saved 1 byte thanks to Luke
s=>[...a='abcdefghijklmnopqrstuvwxyz'].filter((c,i)=>eval(s.replace(/\w+/g,s=>[...s].reduce((p,c)=>p|1<<a.search(c),0)))&1<<i).join``

Test cases

let f =

s=>[...a='abcdefghijklmnopqrstuvwxyz'].filter((c,i)=>eval(s.replace(/\w+/g,s=>[...s].reduce((p,c)=>p|1<<a.search(c),0)))&1<<i).join``

console.log(f('ab + bd'));  // acd
console.log(f('d - ab'));   // ac
console.log(f('ab * cd'));  // cf

Nicely done! You beat me to it...

Does this convert to decimal and back? It appears so.

@programmer5000 Yes indeed. I suspect that many answers will. (Except of course Mathematica, which probably has a built-in for it. ^^)

It looks like your comment was missing a link. What has a built-in fot it?

@programmer5000 (In fact, it was missing a word.)

How about [...a='abcdefghijklmnopqrstuvwxyz'].reduce(...?

@Luke I may have missed an optimization somewhere, but s=>[...a='abcdefghijklmnopqrstuvwxyz'].reduce((p,c,i)=>eval(...)&1<<i?p+c:p,'') is 3 bytes longer.

True. If you use .filter, you can save 9 bytes: a=>[...d='abcdefghijklmnopqrstuvwxyz'].filter((b,c)=>eval(a.replace(/\w+/g,e=>[...e].reduce((f,g)=>f|1<<d.search(g),0)))&1<<c)

@Luke Looks good! I'm waiting for the OP answer to know if we're allowed to return an array. It would still save 1 byte otherwise.

Mathematica, 168 bytes
FixedPoint[StringReplace[x_~~x_:>FromCharacterCode[c@x+1]],Table["a",ToExpression@StringReplace[#,x:LetterCharacter..:>ToString@Tr[2^((c=ToCharacterCode)@x-97)]]]<>""]&

My initial solution (before the post was edited to clarify that the output must be simplified) was 64 bytes shorter:
Table["a",ToExpression@StringReplace[#,x:LetterCharacter..:>ToString@Tr[2^(ToCharacterCode@x-97)]]]<>""

This just modified that solution to work. It's probably shorter to actually use the methods described in the challenge, but I wanted to put this up anyway.
Explanation:
Replaces each sequence of letters with its corresponding integer by character code arithmetic, then converts the resulting string to an expression (which will automatically simplify to an integer), then produces a string of a characters of length equal to that integer, and finally replaces adjacent identical characters with the next character code up until a fixed point is reached.

Oh, there's no 1-char builtin? Suprising!

Perl 5, 95 bytes
94 bytes of code + -p flag.
s/\w/a x 2**(-97+ord$&)/ge;s/(.*)-\1|\+//;/\*/&&($_=$`x length$');1while s/(.)\1/chr 1+ord$1/e

Try it online!
Three steps here:
- s/\w/a x 2**(-97+ord$&)/ge; converts the input into a string of a only.
- s/(.*)-\1|+//;/*/&&($_=$`x length$') will execute the operator (that are very simple on strings of a): + is the concatenation, - means removing from the first part as many a as there are in the second part, and * means duplicating the first part as many times as there are a in the second part.
- 1while s/(.)\1/chr 1+ord$1/e folds the consecutive same letters into the next letter in the alphabet.

The only answer that doesn't convert to decimal! Nice job!

@programmer5000 Out of 2 answers, I wouldn't call that impressive!

05AB1E, 29 bytes
ð¡À¬U¦v0yvAyko+}}X.VbRvyiANèJ

Try it online! or as a Test suite
Explanation
ð¡                             # split input on string
  À                            # rotate left
   ¬U¦                         # get the operator, store it in X and remove it from list
      v                        # for each side of the equation
       0                       # push 0 as an accumulator
        yv                     # for each letter in each side of the equation
          Ayk                  # get its index in the alphabet
             o                 # raise 2 to this power
              +                # add to the accumulator
               }}              # end loops
                 X.V           # apply the operator to the 2 numbers now on the stack
                    bR         # convert to binary and reverse
                      v        # for each binary digit
                       yi      # if it is true
                         ANè   # get the letter at that index in the alphabet
                            J  # join stack to a single string

C & x86 asm, 340 Bytes
Compile with -O0
#define G getchar()
g(){int c,a=0;for(;islower(c=G);)a+=1<<(c-97);return a;}
main(){short o[]={[43]=0x4403,[45]=0x442b,[42]=0x6cf7};
mprotect((long)&&l&~4095,4096,7);
for(;;){int c,b=0,a=g();*(short*)&&l=o[G];G;g();asm("xchg %%eax,%0":"+m"(a));
l:asm("addl %1,%%eax":"=a"(c):"m"(a));
for(;a=c>>b;b++)if(a&=1)putchar(97+b);putchar(10);}}

Explanation
Since C doesn't have eval(), I used a table of x86 instructions in its place. I had to choose instructions which were all the same length (or padded with nops), and which expected src and destination of the same types. Of particular annoyance was that MUL can only write to registers, and the 1-byte MUL opcodes can only write to EAX. Additionally, there seemed to be no register-writing SUB instruction which subtracted from memory, instead of the other way around, hence the XCHG.
edit
Since it was asked in the comments, a more traditional appraoch would look
like this:
#define G getchar()
#define return r
#define int i
g(){i c,a=0;for(;islower(c=G);)a+=1<<(c-97);r a;}
a(i x,i y){r x+y;}s(i x,i y){r x-y;}m(i x,i y){r x*y;}
main(){i(*o[])(i,i)={[43]=a,[45]=s,[42]=m};
for(;;){i c,b,a=g();b=G;G;g();c=o[b](a,g());
for(b=0;a=c>>b;b++)if(a&=1)putchar(97+b);putchar(10);}}

It's actually a bit shorter, at 301 chars, for a few reasons: 1. Because there need to be a lot of functions, the overhead of each can be chopped with some preprocessor rules. 2. Modern linux protects from execution on the stack, so the mprotect() call to disable this sacrificed 34 bytes. 3. The XCHG call is very sub-optimal, costing another 30 bytes. If not for those things, the x86 combo would win by about 10-20 bytes.
Also chopped 2 bytes from both by improving the islower() call in g.

I can't really tell how it would compare to a more classical approach in terms of code-size, but I really like your solution. +1

GNU sed + coreutils, 329 bytes
Yeah, I have no idea what got into me, but at least I know sed scripting a bit better now. Note that this solution requires GNU sed's e extension, which runs a shell command.
/\+/{s/\+//
b S}
/-/{:E
/a+-a+/{s/(a*)(a*)-\2/\1/
b S}
s/.*/echo &|tr b-z- A-Y-/
e
s/([A-Z])/\L\1\1/g
b E}
/\*/{h
:M
/^\*/{x
s/[^\n]*//
s/\n//g
b S}
s/(.).*\*(.*)/echo \2|tr a-z \1-za-z/
e
H
g
s/.(.*)/\1/
h
s/\n.*//
b M}
:S
s/^.*$/echo &|grep -o .|sort|tr -d '\n'/
e
:L
s/(.)\1/\u\1/g
/^[a-z]*$/ q
s/.*/echo &|tr A-Z b-za/;e
b L

I assume that there will not be spaces around the operators. From my terminal:
$ sed -rf golf.sed <<< a+b
ab
$ sed -rf golf.sed <<< ab+bd
acd
$ sed -rf golf.sed <<< abc+b
ad
$ sed -rf golf.sed <<< d-ab
ca
$ sed -rf golf.sed <<< ab*cd
cf
$ sed -rf golf.sed <<< bc*de
eh
$ sed -rf golf.sed <<< acd*def
deghj

And, for those saner than I: the commented version!
#!/bin/sed -rf

/\+/ {
    s/\+//
    b simplify
}

/-/ {
    # expand pattern space; everything will now be 'a's
    :E
    /a+-a+/{
        # Remove doubled 'a's on either side of the dash. For example,
        # for input d-ab, space is now 'aaaa-aaa'; substitute this to 'a'
        s/(a*)(a*)-\2/\1/
        b simplify
    }
    # shift letters that aren't 'a' down and double them
    s/.*/echo &|tr b-z- A-Y-/;e
    s/([A-Z])/\L\1\1/g
    b E
}

/\*/ {
    # Hold space: line 1 is pattern, other lines are output
    h
    :M

    # if space starts with *, we've eaten entire arg0; sum and simplify
    /^\*/ {
        x
        s/[^\n]*//      # remove first line, which is our pattern
        s/\n//g         # remove newlines to add results together
        b simplify
    }

    # convert pattern into shifting command
    s/(.).*\*(.*)/echo \2|tr a-z \1-za-z/

    # execute it, append result to hold space
    e
    H

    # restore pattern, with leading char and all output lines removed
    g
    s/.(.*)/\1/
    h
    s/\n.*//

    b M
}

:simplify
# reorder all letters so all 'a's are before all 'b's are before all 'c's
# are before ... etc
# See https://stackoverflow.com/questions/2373874
s/^.*$/echo &|grep -o .|sort|tr -d '\n'/
e

:L
# Replace repeated characters with themselves upper-cased, then translate
# upper-cased characters to what they should be.
s/(.)\1/\u\1/g
/^[a-z]*$/ q
s/.*/echo &|tr A-Z b-za/;e
b L

+1 for the sed code and welcome to PPCG! The convention here when not solving in pure GNU sed (or in any other pure language), is to add to the title the system commands used, like "GNU sed + coreutils" for example, even if you mention calling a shell command in description. This is done to differentiate, especially in challenges with leader-boards, from pure GNU sed answers.

Also, except for the flag 'f' needed every time, any other flag must be counted as 1 byte. So your score is 329. You might want to mention that in description. And for completion, you might think of adding a link to an online sed interpreter, like TIO.

To not be all talk and no action, here is a 43 bytes shorter! version of your code (286 bytes including -r), that I found by golfing the commands. I'm sure it can be even shorter.

Ah, alright, good to know! Also, nice golfing! What version of sed are you using, though? Yours works in TIO, but in GNU sed 4.4 I just get sed: file golf.sed line 24: ":" lacks a label

The nameless label is a well known bug in GNU sed, that was fixed in version 4.3. But on PPCG, you can write programs for any sed variant and version, using bugs as features if it helps in golfing. Differences between versions are too small to mention (4.2 vs 4.4), but the variant (standard POSIX sed vs extended GNU sed) needs to be specified in the title, with the mention of system programs called, if any.

FYI, you are allowed to use the golfing suggestions that people post in comments to update your code, with credits or not depending up to you. It's also very common to show in title the various golfing stages by using the html strike tag, like so: "329 286 bytes".

PHP, 168
Output Ascending with use of eval
[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for(eval("\$k=d($a)$o d($b);");$i<26;)echo$k&2**$i++?chr(96+$i):"";

PHP, 185 Bytes
Output Ascending
[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for(;$i<26;)echo(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b))&2**$i++?chr(96+$i):"";

Online Version
Expanded
[$a,$o,$b]=explode(" ",$argn); # part the input into variables
function d($s){ # make decimal value
    for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);
    return$n;
}
for(;$i<26;)
echo(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b))&2**$i++?chr(96+$i):""; # Bitwise Compare and Output

PHP, 201 Bytes
Output Decending
[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for($r=(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b));$r;$r-=2**$l)$t.=chr(97+$l=log($r,2)^0);echo$t;

Online Version
Expanded
[$a,$o,$b]=explode(" ",$argn); # part the input into variables
function d($s){ # make decimal value
    for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);
    return$n;
}
for(
$r=(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b)) # result of the operation
;$r;
$r-=2**$l) # subtract the letter value
$t.=chr(97+$l=log($r,2)^0); # find greatest letter
echo$t; # Output

Python 3, 176 167 bytes
i=lambda a:str(sum(1<<ord(i)-97for i in a))
def f(a):
 a,b,c=a.split();m=eval(i(a)+b+i(c));r=''
 while m:
  t=0
  while m>=2**t*2:t+=1
  r+=chr(97+t);m-=2**t
 return r

Try it online!

saved 9 bytes: Thanks to tutleman

Unless I'm mistaken, you can shave off two bytes by replacing m>=2**(t+1) with m>=2**t*2, and five bytes by replacing a=a.split();m=eval(i(a[0])+a[1]+i(a[2])) with something like b,c,d=a.split();m=eval(i(b)+c+i(d)).

Oh, and two more bytes by replacing 2**(ord(i)-97) with 1<<ord(i)-97.

I am amazed how readable this solution is compared to other solutions.

Thank you :). But i think its also because of python being the language used. The indentation makes the byte count increase, however readable. ;)

PHP, 130
for($d=a;$e=$argn[$i++];)$e!=' '?$d!=b?$$d+=1<<ord($e)-97:$b=$e:++$d;eval("for(;\$j++<27;)echo($a$b$c>>\$j-1)&1?chr(96+\$j):'';");

expanded version:
for($d=a;$e=$argn[$i++];)       // for each char in the input
  $e!=' '?                      //   if space
    $d!=b?                      //     if not the operation
      $$d+=1<<ord($e)-97:       //       add 2^(char - 'a')
      $b=$e:                    //     else save operation
    ++$d;                       //   else increase "pointer"
eval("for(;\$j++<27;)           // for each bit in the output
        echo($a$b$c>>\$j-1)&1?  //   calulate the result and check the bit
          chr(96+\$j):          //     output corrosponding char
          '';                   //     output nothing
     ");

run with php -R <code>.

AWK, 201 bytes
BEGIN{RS="(.)"}n=index(V="abcdefghijklmnopqrstuvwxyz",RT){s+=2^--n}index("+-*",RT){a=s RT
s=0}END{RS="\n"
"(awk '$0="a s"'<<<1)"|getline v
for(j=26;j--;)if((s=v-2^j)>=0){v=s;c=substr(V,j+1,1)c}print c}

"(awk '$0="a s"'<<<1)"|getline v is the best way I could come up with to do an evaluate in AWK.  I may be "cheating" a little to call this just AWK, since I am executing a command, but at least the command is also AWK :)
I'm sure I'm missing some way to reduce the byte-count, but I sure can't see it.
Usage is fairly standard, e.g. put the code in FILE and do:
awk -f FILE <<< "bc + ab"

Note that spaces are not required and any non-op/non[a-z] character will be silently ignored. Could be extended to work with numbers greater than "abcdefghijklmnopqrstuvwxyz" by changing the loop.  To do division, simply add the / character to the operation string :).  Also, will print a blank line if the result <= 0.