text:
Minecraft Mirrored
This is Calvin. Just trying to get 20 rep so this user can chat in the PPCG Minecraft Server chatroom.
Write a program or function that takes in a positive integer.
If the integer is even (2, 4, 6, ...), print or return this exact ASCII art string:
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |

If the integer is odd (1, 3, 5, ...), print or return this exact ASCII art string:
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

You may assume the input is always a positive integer.
In both output cases there may optionally be any number of trailing spaces up to the right edge of the "T" on each line, and/or a single trailing newline. Note how there are two columns of spaces between each letter.
The shortest code in bytes wins.

I'd name-drop Calvin too if I was a new user looking for rep ;)

@Geobits It's me.

@Geobits No, its me. I knew no-one would upvote if I revealed its actually me.

Shouldn't the "M" in "Minecraft" have vertical legs?

@mbomb007 I prefer it this way.

Okay, it's just that the Minecraft logo has a vertically-legged 'M'.

Why does it matter who created it? Shouldnt the rep be based on the content of the post?

@marsh In theory, yes. In reality, people are flawed. It'd be an interesting experiment to run, having a high-rep user create a new account to post a few challenges to gauge the difference in reception.

@Geobits but then the name-dropping would already pollute the sample. Need more params to run the experiment.

@Mindwin Oh, sure this one's polluted. My name-dropping comment was explicitly calling out that likely effect in a (IMO) humorous way.

xD I had what I thought was working in only like 100 something bytes, but I forgot to reverse the /s and the \s and the _s so i failed...

In both output cases there may optionally be any number of trailing spaces up to the right edge of the "T" on each line, and/or a single trailing newline. Does this mean the trailing newline on the last line is optional?

@samgak Correct.

@Geobits a la Richard Bachman

@cairdcoinheringaahing I can understand good humor. So if I don't laugh, now you know why.

JavaScript (ES6), 343 336 289 267 265 260 bytes
Just for fun... :) (Thanks to Xufox for cutting off 46 bytes, and encouraging me to cut off another 37 on my own.)
n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')

Called as a(4) or similar. Try it here:

a=n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')
document.getElementById("a").innerHTML = "
"+a(2)+"
";
document.getElementById("b").innerHTML = "
"+a(3)+"
";

I've condensed the whitespace into strings of digits from 2 to 8 (e.g. 887 = 23 spaces). Each digit is then replaced with the corresponding number of spaces. 0 represents |  |, and 1 represents __. All in all, this program is 170 bytes shorter than the two strings combined (203 + 227 = 430), so I'm happy. :)
Edit: Somehow, it's exactly the same length as the only other entry at this point.... o_o
Edit 2: Saved some space by changing n%2<1? to n%2? and swapping the strings. Also took advantage of the fact that the beginnings of the two strings are the same to reduce another 5 bytes.
Edit 3: |2| seemed to show up an awful lot, so simplified each occurence to x, saving 7 bytes. Xufox's suggestions cut off another 40 bytes.
Edit 4: Xufox's suggestion to replace \n with actual line breaks paid off, removing 6 bytes from the total. Changing x to 0 and __ to 1 (insert evil laugh here), then combining all of the (insert plural of Regex here), as he did in his entry, saved an extra 16 bytes.
Edit 5: Since I've chosen to use the ES6 standards, I used custom template string interpolation to shave off 2 final bytes.

That number must have something to it! In addition to being a perfect cube, that is :-) Can't vote on your answer since I have no idea of JavaScript...

Put r='replace' in your first [r], i.e. [r='replace'].

How about .replace(/\d/g,d=>' '.repeat(d))?

@Xufox: Thanks a ton! Your first tip saves one byte, and the second saves another 38 (!!!).

@ETHproductions Nice! Now, can you beat my answer? Only 9 bytes to go… ;) By the way, when I count your bytes it says 289, using the gEdit counting tool…

@Xufox: My bad, it seems that I had forgotten to remove an extraneous line break from the end of the code, after copy-pasting it into Notepad++. Perhaps I could use some tricks from your answer to golf mine even further. :)

Maybe using template strings to be able to make actual line breaks instead of \n, saving one byte per line break?

Thanks for the tip! That saved me 6 bytes, and I managed to save another 16 by changing x to 0, __ to 1, and combining the three (Regexes? Regices? Regi?) into one. That leaves mine at 14 bytes less than yours. :) Any other suggestions?

That’s just amazing! I didn’t think it was possible!

@Xufox There, I'm done. I shaved off two final bytes by using ES6's custom template string interpolation, but I don't think it's possible to go any further. But maybe I'm wrong...

Hm… did you remove any unnecessary trailing spaces?

Yeah, that was actually the first thing I did before condensing the whitespace.

Now I’ve got 2 bytes less than you. =P

Darn.... Nice job :)
I love this highly competitive nature of code golf! Now, let's see if we can golf even further. >:-D

Matlab, 343 341
a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))

The input number is provided from stdin.
Sample run:
>> a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
1
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |

That's just crazy lol. +1.

@rayryeng Yeah :-) Pity that Matlab only allows base up to 36. A larger value would have saved quite a few bytes

@LuisMendo Exactly what I thought while making my JavaScript solution…

@Xufox in JS the btoa() and atob() functions are base64 encode and decode, respectively.

CJam, 158 149 145 138 bytes
li2%"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"281b7b"/
 -_\|"f=N/S3**_"_ ":T/TW%*4/zW%1m>N*1>"\/"_W%er"^W^]5OU"{i_32>T=t}/\4/zN*?

The above uses caret notation, since the code contains unprintable characters.
Try it online in the CJam interpreter.
If the permalink doesn't work in your browser, you can copy the code from this paste.
Example run
$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 6c69322522412bd772b585c6ffbba3ba6f5523fc2054159d5a653cc4ca4bded2a39b5757f835daeda7b9549aea65721eb0837dc30130523222323831623762222f0a202d5f5c7c22663d4e2f53332a2a5f225f20223a542f5457252a342f7a5725316d3e4e2a313e225c2f225f5725657222171d354f55227b695f33323e543d747d2f5c342f7a4e2a3f
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
$ cjam minecraft.cjam <<< 1; echo
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Idea
Instead of encoding the MINECRAFT string (padded to achieve a constant line length) directly, we'll encode a "zipped" version of it, where rows and columns have been transposed.
After zipping and removing the linefeeds, this string (let's call it R) has to be encoded:
   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_

There are many runs of spaces, so we'll replace each occurrence of a space triplet with a linefeed.
This leaves us with seven different characters (\n -/\_|), so we assign each of them a number from 0 to 6 and consider the resulting array digits of a base 7 number, which we then encode as a byte string.
Decoding works by reversing the steps from above.
The mirrored string can be constructed from the original one.
If we reverse the order of the four rows and swap the soliduses, we obtain the following:
\        /  |  |  /|  |__   /__  |   /  \    /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   |
  \/  \/    |  |/  |  |     \    |  |     \/    |     |
                       __    __   __             __  ___

Somehow similar, but we'll clearly have to rotate the rows to bring the bottom row to the top:
                       __    __   __             __  ___
\        /  |  |  /|  |__   /__  |   /  \    /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   |
  \/  \/    |  |/  |  |     \    |  |     \/    |     |

That would be it if it wasn't for those pesky underscores.
If we read the original string from top to bottom and ignore linefeeds (thus obtaining R) and replace each underscore followed by space with a space followed by an underscore before shifting the rows, this is the result:
                         _     _                      _
\        /  |  |  /|  |_    /_   |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Much better! All that's left to do is deleting the first space of the first row (shifting all underscores in the first row one character left), moving the misplaced underscores in E and C one row up and discarding the underscore over T.
Code
li2%           e# Read an integer from STDIN and push its parity.

"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"

281b7b         e# Convert the byte string from base 281 to base 7.
"/\n -_\\|"f=  e# Replace each digit by its corresponding character.
N/S3**         e# Turn linefeeds into three spaces.
_              e# Copy the resulting string.
"_ ":T         e# Define T.
/TW%*          e# Replace occurrences of T with T reversed.
4/z            e# Split into chunks of length 4 and zip.
W%1m>          e# Reverse and rotate the rows.
N*             e# Join the rows, separating by linefeeds.
1>             e# Discard the first character.
"\/"_W%er      e# Swap the soliduses.
"^W^]5OU"      e# Push the string that corresponds to [23 29 53 79 85].
{              e# For each character:
  i            e#   Push its code point.
   _32>        e#   Push 1 iff the code point is larger than 32.
       T=      e#   Select the element at that index from T = "_ ".
         t     e#   Replace the element at the code point's index with that char.
}/             e#
\              e# Swap the partially generated MINECARFT string on top.
4/z            e# Split into chunks of length 4 and zip.
N*             e# Join the rows, separating by linefeeds.
?              e# Select the first string iff the input was odd.

How does it work?

@anatolyg I've edited my answer.

Pyth - 182 bytes
Uses base encoding approach. Since indexing is modular in Pyth, I don't even have to do anything for the even odd, just put it in the correct order, and use @Q. As a bonus this also works with negative numbers.
@mjbcs@L"_| /\\-"jCd6 56,"EWbòH\x00B)þKÙ£ÄIOõìæ«FFãbÐÄBØ\«¼,vã<RN>º:w÷ò¾<éifP9e|ÉWf!FÔèà""EWbòH\x00B)þOHÿ$@ËþçX'D[¾«Â?°´=&£üá ¹»ázH×Æz3äkÕg{`!|ðY!ðGV"Q

I had tries only encoding the first one, then flipping and switching the slashes, but the first and last line were too hard.
I could save 6 bytes by putting actual null bytes in the code, but that's too much trouble.
Try it online here.
It looks really bad online because the output box is too small and wraps. I recommend fiddling with the dev-console and changing the col-md-5 to a col-md-7.

The two strings have a bunch of duplicated characters, you can remove 11 bytes like so.

JavaScript (ES6), 312, 285, 281, 272, 270, 263, 262, 260
For previous edits see the edit history.
Edit 5: In the conversion, I switched the number associated with - (now 0) and whitespace (now 1). In the resulting block, the numbers 1, 2 and 3 weren’t used as much anymore. This allowed me to use an array with the missing numbers.
Edit 6: Improved the array literal. I tried this previously, but used 777 and 77 as strings instead of numbers and noticed only now that I had missed this.
Edit 7: The “Golfed code” is a function, as specified by the question and there’s no need for f= to meet this specification. Thus, removing it, saving two bytes.

Runnable in Firefox 39:

// Testing:

f=

// Golfed code:

n=>[...`11111113ss17ss1pp11117pp3ppp
97dj3dj7822j78z213e17z3v8397gm78212
7f3kf3k1z27k7z20021200k17fppk1z001z
d7983987j2287jz2ss1lss2aabj3d7987j2aa3aza`.replace(/[123]/g,x=>[,777,'77z',77][x])].map(a=>isNaN(i=parseInt(a,36))?a:'- /\\_|'[n%2?i%6:~~(i/6)]).join``

// Testing:

;document.body.appendChild(document.createElement('pre')).innerHTML=f(0);
document.body.appendChild(document.createElement('pre')).innerHTML=f(1);
document.body.appendChild(document.createElement('pre')).innerHTML=f(2);
document.body.appendChild(document.createElement('pre')).innerHTML=f(35);

It’s based on the base 6 number system and each ASCII character stands for a number:
"-": 0
" ": 1
"/": 2
"\": 3
"_": 4
"|": 5

Then, I’ve combined the number representation of each ASCII string. For example: when the first ASCII string contains a / at one position and the other one contains a \ at the same position, that position becomes 32, which is base 6 (20 in decimal). If you convert this to base 36 (to get one base-36 number for every two base-6 numbers), you get k.
All this was done beforehand and the function basically undoes this process.
Now the two JavaScript answers both have one other answer each, that has the same byte count…

PS: As a note to myself and a reference to others, this is the code I used:
// 1. ASCII here
a=`|\\-/ _`;

// 2. ASCII here
b=`/|\\_ -`;

// Note: the ASCII strings’ backslashes have to be escaped!

[...a]
  .map((c,i)=>parseInt((c+b[i])
    .replace(/-/g,'0')
    .replace(/ /g,'1')
    .replace(/\//g,'2')
    .replace(/\\/g,'3')
    .replace(/_/g,'4')
    .replace(/\|/g,'5'),6))
  .map(c=>isNaN(c)
    ?`
`
    :c.toString(36))
  .join``
// Returns "wn3g7o", which is then put into the function as the block at the top.

Gosh, why is ~NaN == -1?!

I also thought about reversing the ASCII strings line by line, to get rid of yet more trailing spaces (it also saved two bytes in the replacement: […][x]+77, 77 doesn’t need to be a string anymore), but the additional reversing in the golfed code didn’t make it worth it…

I didn't understand this when I first read it a year ago, but now I see the technique. Combining every pair of chars into one is very clever :-) I think you can replace isNaN with 1+, and ~~(i/6) with i/6|0.

Haha, I'm now a byte ahead ;)

@ETHproductions Well, hold on a second… I just noticed that you don’t have the f= at the beginning, but I do. I also read that it’s accepted to remove it, thus I’ll do so myself, and now I have 260 bytes. ;)

Well, I found one more byte to golf off my function, so... I guess we'll call it a tie?

@ETHproductions Wow, neat. Yes, it’s a tie for now, I guess…

CJam, 136 bytes
"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^Ã 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b[S9*'|3*+S2*]"/-_\| "+f=s4/56/ri=zN*

The above uses caret notation, since the code contains unprintable characters.
The linefeed is solely for "readability". Try it online in the CJam interpreter.
If the permalink doesn't work in your browser, you can copy the code from this paste.
Example run
$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 220153d338a5c8f70bafbe2f08d53284cb316ad2dd048130ee6c3b294852a7fb7c8a9e87ddc59f4e6c7a1466d1986a3ec08320342362485cbf84eeb7edec05017e28bff8b328fab42c8828a16a3ee83f2327bb76e750ef6a75383729d7223236356238625b53392a277c332a2b53322a5d222f2d5f5c7c20222b663d73342f35362f72693d7a4e2a
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
$ cjam minecraft.cjam <<< 1; echo
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Idea
This approach has some similarities to the one in my other answer, but it is a lot simpler and (rather disappointingly) a bit shorter.
We search for a way to encode the following string:
                       __    __   __             __  ___                       __    __
  /\  /\    |  |\  |  |     /    |  |     /\    |     | \        /  |  |  /|  |     /    |   /  \ __ /  |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |  \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |   \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

After padding each row (to achieve a constant line length), zipping (transposing rows and columns) and removing the linefeeds, this string has to be encoded:
   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_    \    \    \   /  /   \    \   /  /  /           |||         |||   /  /  /   |||         |||_ -__ -_          |  / \_  __  _         |||  -_  -_  /| /           \    \  _ \ _ /  /  /           |||  -_  -_           _ |||   _

We'll replace each substring "         |||" with a 0, each substring "  " with a 1 and the characters of "/-_\| " with 2 to 7, forming an array of base 8 digits, which can be encoded as a byte string.
Decoding works by reversing the steps from above.
Code
"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^Ã 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"

265b8b        e# Convert from base 265 to base 8.
[S9*'|3*+S2*] e# Push ["         |||" "  "].
"/-_\| "+     e# Concatenate to push ["         |||" "  " '/' '-' '_' '\' '|' ' '].
f=            e# Select the elements that correspond to the base 8 digits.
s4/           e# Flatten and chop into chunks of length 4 (columns).
56/           e# Chop into two subarrays of 56 columns.
ri            e# Read an integer from STDIN.
=             e# Select the corresponding subarray.
              e# Arrays wrap around, so [A B]0= eq. [A B]2= and [A B]1= eq. [A B]3=.
zN*           e# Zip and join the rows, separating by linefeeds.

"Alleged readability?" :P

Racket, 443 434 386 Bytes
(require file/gunzip net/base64)(define(f n)(define o(open-output-bytes))(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))o)(list-ref(string-split(get-output-string o)"a")(modulo n 2)))

Just for kicks.
(require file/gunzip net/base64)
(define (f n)
  (define o (open-output-bytes))
  (gunzip-through-ports
   (open-input-bytes
    (base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))
   o)
  (list-ref (string-split (get-output-string o) "a") (modulo n 2)))

N.B. you may need the #lang racket line to run in DrRacket.

Exactly 100 bytes off.

Come on! I know you can also make it to 343

I don't see that happening unless I abandon this approach.

You dont need to use base 64 characters.You can use just the raw unicode characters that gunzip sends out

05AB1E, 179 177 176 bytes
"
 -/\_|"•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huÑ¦%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆË²’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•7вèJ2äIè

Try it online.
Explanation:
•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huÑ¦%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆË²’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•

is the compressed number:
669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

Try it online.
7в converts it to Base-7 as list, so we get the list of digits:
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,5,5,0,1,1,3,4,1,1,3,4,1,1,1,1,6,1,1,6,4,1,1,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,6,1,1,1,1,1,3,4,1,1,1,1,6,1,1,1,1,1,6,0,1,3,1,1,4,3,1,1,4,1,1,1,6,1,1,6,1,4,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,4,1,1,1,1,3,5,5,4,1,1,1,6,2,2,1,1,1,6,0,3,1,1,1,1,1,1,1,1,4,1,1,6,1,1,6,1,1,4,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,1,1,1,4,1,1,3,1,1,1,1,4,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,4,1,1,1,1,1,1,1,1,3,1,1,6,1,1,6,1,1,3,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,1,3,1,1,4,1,5,5,1,3,1,1,6,1,1,1,1,1,6,0,1,4,1,1,3,4,1,1,3,1,1,1,6,1,1,6,1,3,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,3,1,1,1,1,4,1,1,3,1,1,1,6,2,2,1,1,1,6,0,1,1,4,3,1,1,4,3,1,1,1,1,6,1,1,6,3,1,1,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,5,5,6,1,1,1,1,1,4,3,1,1,1,1,6,5,5,1,1,5,6,5]

Try it online.
è indexes each digit in the string "\n-/\_|", and J then joins the entire list together, which gives us the following:
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Try it online.
2ä splits the string into two parts.
Iè take the input, and indexes it (with automatic wrap-around) to get one of the two parts, which is then being output implicitly.
Huge thanks to @MagicOctopusUrn's ASCII compressor which was used to generate the compressed number and Base-7 transliteral. Try it online. (After which the transliterate has been golfed by reversing the string and number on the stack, using в instead of B to make it a list of digits, and index into the string with è.

Perl, 292 259 246 bytes
$_="Svv __SS__S nnSv nnSnnn
i kjSkj hw|j h|wS /SwrhSi pq hwS |
 mSlmSlS |S| l |S|--wS |--lSSmnnlS |--S |
k ihSih jw|h j|S|__S g__S|oosjSk ih jS|ooSo|o";s/v/SSSSS/g;s/w/S|S/g;s/S/  /g;<>&1?y"g-s"\\/\\  /\\ ___ |":y"g-s"\\  \\/\\/_ /\\| ";print $_

It takes advantage of the fact that the two strings are mostly similar (e.g. the entire I E and C) and makes the string out of characters that are displayed differently depending on which version is being displayed. e.g m means "a forward slash for the right-way-up string, a backward slash in the upside down one". It does a transliteration substitution to display the correct character. Spaces are also run-length encoded using string substitutions.
multi-line:
$_="Svv __SS__S nnSv nnSnnn
i kjSkj hS|S|j h|S|SS /SS|SrhSi pq hS|SS |
 mSlmSlS |S| l |S|--S|SS |--lSSmnnlS |--S |
k ihSih jS|S|h j|S|__S g__S|oosjSk ih jS|ooSo|o";
s/v/SSSSS/g;
s/w/S|S/g;
s/S/  /g;
<>&1?
    y"g-s"\\/\\  /\\ ___ |"
:
    y"g-s"\\  \\/\\/_ /\\| ";
print $_

Idea:
Since there are only 22 unique columns in the output, it should be possible to store it as 22*4 = 88 characters with a range of 0-17 (all the possible "dual-meaning" characters), along with a 56 character lookup table with one entry in the range of 0-21 per column. In theory this could be encoded with < 100 bytes however it's hard to make this a net win because of the more complicated code to decode it.

You can shave a couple of bytes - y/foo/bar/ is a synonym for tr/foo/bar/

C, 251 bytes
k(w){char*f="_-/\\|]^^^\0<&*&)&3&(&&WX&J&*&\0t_&/&3&\0`);35)I5M\0a).@7).8-;./.-\0j()(0(1+4()(*+4+4()(04+",*o=f+4,m[229]="",i=7,c=10,p;for(memset(m,32,228);i;c=*f++^(w%2&i--/2==2)*115)for(p=0;*++o;m[(w%2?4-i/6-p/57:p/57)*57+p%57]=c)p+=*o-37;printf(m);}

This is a function k that receives a parameter and prints the message to stdout.
A more readable version:
k(w)
{
    char*f="\n_-/\\|", // characters to fill in
        *o= " "// for each character, the list of positions to put it in, difference-encoded
        "]%%^^^\0"                  // for '\n' (newline)
        "<&*&)&3&(&&WX&J&*&\0"      // for '_' (underscore)
        "t_&/&3&\0"                 // for '-' (minus)
        "`);35)I5M\0"               // for '/' or '\' (slashes)
        "a).@7).8-;./.-\0"          // for '\' or '/' (slashes)
        "j()(0(1+4()(*+4+4()(04+",  // for '|' (vertical bar)
        m[229]="",  // message to generate
        i, // index of character, running 7...1
        c, // current character to fill in
        p, // where to place the character
        y; // y-coordinate of the character

    memset(m,32,228); // fill the message with spaces
    for(i=7;--i;)
    {
        c=*f++;
        c^=~w%2|i/2^1?0:115; // flip the direction of slashes, if needed
        for(p=0;*++o;)
        {
            p+=*o-37; // jump to next position
            y=p/57; // extract the y-coordinate
            y=w%2?4-i/5-y:y; // flip the y-coordinate, if needed
            m[y*57+p%57]=c; // place the character
        }
    }
    printf(m); // print the message
}

First, it prepares an empty message (filled with spaces). For each character (e.g. | or -), it has a list of positions to place that character in.
For each position, if the upside-down version should be printed, the position is flipped. That is, its vertical coordinate y is replaced by 4-y or 3-y (depending on whether the character is an underscore). Also, the directions of the slashes are flipped - this is performed by a XOR with 115.
This control structure is also used to place the newline characters - it seems more efficient to add 4 more coordinates to the list than to write an explicit loop.

There are a few minor glitches with this system. First of all, the final letter T looks a bit different in the flipped version:
___
 |    |
 |    |
 |   _|_

To output it correctly, the code has to place the | characters after the _ characters.
In addition, in order to make sure the control string contains only ASCII characters, I encoded it:

It records the differences between the positions instead of the positions themselves - this reduces the range
The numbers in the string have 37 added to them, to shift them into the ASCII Range 32...127. I could add a smaller number, but 37 avoids characters like " and \, which have to be escaped inside string literals.
Two of the numbers were greater than 127 - for example, the first - character appears at position 137. To account for this, I added an artificial - character at another position (79), which is later overwritten - the character | also appears at position 79.

Another funny thing was that I couldn't use puts to output the string - this would produce an extra trailing newline. So I used printf instead.
Also, the number 57 appears 4 times in the golfed code - the seemingly long-winded expression (w%2?4-i/6-p/57:p/57)*57+p%57 makes it possible to eliminate the variable y, making the code shorter.

C seems to be such a "always write this construct with this code" kind of language... This... is... very... um...
+1 ;)

CJAM, 206
The two ascii pictures are base-216 encoded, one byte = 3 characters.
" _\/|-":A;S7*"!D!D"+:B;qi2%{B"h  °°¤8 2 °2,J° °"",4# °³8=Ô° Ó\"# Ó °""\"z °Â89D-D·° z ·!¶"}{B"'    '!J"+"#h °¼88 2 °°  ° °""2/\" °²8=Ô° Óh#L Ó °""  h°°9D-D°,2 h° °"}?]{{i32-__36/A=@6/6%A=@6%A=}/N}/

Test it here

Powershell, 275 253 248 bytes
param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

Test script:
$f = {

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

}

&$f 2
&$f 1

Output:
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Main ideas
The compression method is extended method of CJam by Dennis♦:

Create a string before compression:

chars of the first column of both ASCII arts, then
chars of the second column, then
chars of the third column and so on...

Compress using 10 consecutive replacements (10 because Powershell can use numbers 0..9 as strings, this makes the decompress algorithm shorter. Replacements found by brute force.)

The script for compression:
$src =
"                       __    __   __             __  ___", # line1, art1
"                       __    __                         ", # line1, art2
"  /\  /\    |  |\  |  |     /    |  |     /\    |     | ", # line2, art1
"\        /  |  |  /|  |     /    |   /  \ __ /  |     | ", # line2, art2
" /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | ", # line3, art1
" \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | ", # line3, art2
"/        \  |  |  \|  |__   \__  |   \  /    \  |     | ", # line4, art1
"  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_"  # line4, art2

$z=-join(0..$src[0].Length|%{
    $p=$_
    $src|%{$_[$p]}
})
$z

The before compression string is:
   \  /     /\    /    \  \    /    \/      /\    /    \  \    /    \/     /  \                   ||||||                  ||||||  \    /    \/     /  \   ||||||          ||||||__  --____  --__                    ||    //  \\__    ____    __                  ||||||_   -- __   -- _  | \/ |   /  \                    \  /     /\  /__  \  \__  /    \/     /  \                   ||||||_   -- __   -- _                _      __ ||||||_      _

The explanation in your answer was probably put more effort into than all my answers combined! +1

SAS, 442 bytes
%macro a(b);&b=tranwrd(&b,put(i,1.),repeat('A0'x,i));%mend;%macro b(z);length a b c d$99;if mod(&z,2)then do;a='992__3__';b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';end;else do;a='992__3__2__65__1___';b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';end;do i=0to 9;%a(a)%a(b)%a(c)%a(d)end;put a/b/c/d;%mend;`

Non-golfed:
%macro a(b);
  &b=tranwrd(&b,put(i,1.),repeat('A0'x,i));
%mend;

%macro b(z);
length a b c d$99;
if mod(&z,2)then do;
  a='992__3__';
  b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';
  c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';
  d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';
end;
else do;
  a='992__3__2__65__1___';
  b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';
  c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';
  d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';
end;
do i=0to 9;
  %a(a)
  %a(b)
  %a(c)
  %a(d)
end;
put a/b/c/d;
%mend;

Tests:
data a;
  %b(1)
  %b(2)
  %b(0)
  %b(35)
run;
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Could possibly save a bit of code by putting them in input blocks, but that adds the restriction that the macro can only be once per datastep which I feel violates the spirit of writing it as a macro.  (And I suspect adding a prompt to get input in the datastep adds more characters).

bash, 247 bytes
(($1%2)) && c=tail || c=head
base64 -d <<<H4sIAF/3uFUCA31Q2w3AIAj8ZwoWMLcQyS3i8JWXtWlTI6BwPA7Vz0Nunc9HhKSowlJU57qWJjBoZ/4a41o8aC4NsTBjbMgYkQDStCIrDz3AbmRuYjpzPTOGG5P9/gmKtQddFy8eMbOn4Khb7NE88ObRs+DgUez3iqrtwYPMAoWJhU/KBeJFPOCqAQAA | zcat | $c -n4

Strings are concatenated and gziped.

Javascript (ES6), 403 296 bytes
(Moved from my previous answer) Trying out a new method:
n=>`55555559Å9Å${n%2?`55555558556776}}5Y75Y¥Æ75786¡YAA[7ćA5Fï5¡YFéA8Y§5}\x83AEÅKÅ\x99}5§5\x999\x95`:`Q5555Q9Ý>6¡77¡}}5Y7756¡75768Y¡AA£7ćA5Fû5u¡FéAY55¡}}EÅKÅ}G;5¡}5}`}`.replace(r=/./g,x=>(163+x.charCodeAt()).toString(6).slice(1)).replace(r,x=>' /|\\_-'[x]).match(/.{56}/g).join`
`

Note that there is a few unprintable character; these have been replaced with e.g. \x83.
The encoding itself is about 40 bytes shorter than the other, but the decoding process is more elaborate. I used the base-216 system that others have used to encode the text. For reference, here's the code I used:
// normal MINECRAFT
a='00000000000000000000000440000440004400000000000004400444'+
  '00130013000020023002002000001000020020000013000020000020'+
  '01003100300020020302002550020000025530000144300025500020'+
  '100000000300200200320024400034400200030010000300200000200';

// upside-down MINECRAFT
// un-comment this one to run it
/*
a='00000000000000000000000440000440000000000000000000000000'+
  '30000000010020020012002000001000020001003044010020000020'+
  '03001300100020020102002550020000025510000300100025500020'+
  '003100310000200210020024400034400244200000310000244004240';
*/

console.log(a.replace(/.../g,x=>String.fromCharCode(parseInt(b[i],6)+53)));

This basically takes the ASCII text (pre-converted to base 6) and triples it up on itself, changing it to base 216. 53 is then added to remove most non-printable characters.
Suggestions welcome!

Here's the original 403-byte code:
a=n=>{y=[' ','/','|','\\','_','-'],x=`55555559Å9Å${n%2?`55555555¡55Y}}eA5;5};GÝY}5}¡k;77;} 757Ĉ5G;7ć75§H5AB77Ý8ÝEÑ5H5EÅÕ`:`Q5555Q9Ý6¡k5}\u008FAA5;5}}5k5}5}Y§G77G} 757Ċ5?×7ć7;55GAAI7Ý8ÝA865GA5A`}`;b=x.split('').map(x=>x.charCodeAt(0)-53);for(c=[],i=b.length;i--;){c[i]=b[i].toString(6);while(c[i].length<3)c[i]='0'+c[i]}d=c.join('').replace(/\d/g,x=>y[x]).split('');d[56]=d[112]=d[168]=`
`;return d.join('')};

Using a for loop, a while loop, four variables that were only used once, and a ton of long algorithms for simple things. Boy, have I improved...

You can probably completely remove y=[' ','/','|','\\','_','-'], and instead of y[x] write ' /|\\_-'[x]. =)

@Xufox I've done that and a whole lot more, golfing 107 bytes in total!

PHP, 225 bytes
Ugly, brute-force solution.
echo str_split(gzinflate(base64_decode('dZDdDcAgCITfnYIFzC1Ecos4fOW3Nm2NgsohfIp8DrJtbB8RkkMEGktk7anhXIO6jFNpzA4Lqq2SqLs5WzKnJ4BUycjOQzXQhdScd6dmV8Rwa7rqP9/QukE9ixeGt2wpODASHoWBN0a1ggMj4fuHsuyBQcYDqfH/XrwA')),224)[$argv[1]%2];

I compressed then base64 encoded the concatenated strings to be displayed. The code decodes, decompresses and splits it in pieces of 224 characters. The first string is 224 characters without a trailing newline, the second is 201 characters (also no newline after it). The parity of the command line argument ($argv[1]%2) is used as index in the array generated by str_split().

Haskell, 138 bytes
m x=do
 h<-readFile"a"
 return$take 225.drop(225*mod x 2)<$>find((==h).hash.pack)(replicateM 425"/\\|_- ")

This is a bit of a hack. I am bruteforcing the SHA256 hash of the concatination of the two minecraft texts, and then splitting them apart and choosing the appropriate text based on parameter x. This is of cource very impractical and cannot be computed in real time, and there may even be collisions along the way for all I know.
Because Haskell cannot have the ASCII representation of that hash in a string, I am reading it from a file called "a", and has therefor added 32 bytes to my score.

readFile and pack is from Data.ByteString.Char8
hash is from Crypto.Hash.SHA256

Explaination:
replicateM 425"/\\|_- "

Creates a list of every combination of the letters "/\|_- " on 425 letters (the length of both minecraft texts combined)
find((==h).hash.pack)

Pick the first one that matches the hash
take 225.drop(225*mod x 2)

The first text is 225 letters long, the other one is exactly 200.

106 bytes, not 138

See my explanation, I added 32 bytes because I am reading a 32 byte long file

Python, 312 bytes
def y(b):
 x=int(['4vwhclv10tuk4z18gf73aimn6zvwkrhxekphfn1lxocj9ezchd1cd1cv97p3f6k12s8hcjznnm5iq3om4vgxvugp3makgu4n3f6qxvdrtl4c0lva12hwt','8uzwdylhtrf6oqnwnck8pfxu25m5844tuo2700v3zoeuvossx1b47rnwyrmqodau3feu3spi9jydhyxvntv48vojx9iq9af78wufzn1'][b%2],36);x<<=69;s="";t=" /\\-|_\n"
 while x:s+=t[x&7];x>>=3
 print s

Function prints output given an int

Yeah, I'm just looking at a neat way of compressing it down further then that though

How does this work?

Is is base-36? but if it is whats 16598125653940296495007405984048067937906981182427207589486265398555496561913976121109917896233762115477615438181875147062369253802653987802486539858466848179256705775331854915993645

Basically, it stores the two results in a list and then gets the correct one using the modulus function. It then decodes it from base 36 as you thought. Because it was a big power of 2, I removed some chars by doing >>69. I then use a basic translation function to turn it into the correct output.

C, 321 bytes
Encoded the repetition and the character index into a string.
main(n,v,p,c)char**v,*p,*c;{c=" _/\\|-\n";for(p=atoi(v[1])%2?"8@8iXivs8rhththrthtPrXt`rhspiprhtPtvpshrshr`thtprpthtmhtPtmrXshr`tm`tvhsrhsrXthtrhthti`sihtitPsrXtihqtq":"8@8iXi`i8PihavhrshrsXthtshthtPrXthtPrsXtPtvprhsrhs`thtpspthtmhtPtmsXris`tm`tvr8shththsthti`siht`shrXshtPtw";*p;p++)for(n=*p/8^15;n--;)putchar(c[*p&7]);}

Python 3, 486 533 612
r=str.replace;m,p=r(r(r('''YYYYY   __YA AYY   A___
  /\  /\YX\  X Y/YX Y/\Y| Y|
 /  \/  \   X \ X--  | Y|--\Y/__\   |--   |
/YY\  X  \XA \A|   \  /Y\  | Y| ''','X','|  |'),'Y','    '),'A','__  '),print;
if int(input())%2==0:p(m)
else:
 q,i,u=m.split('\n')[::-1],0,[[23,24,29,30],[42,43],[],[23,24,29,30,34,35,53,49,50,55]];q.insert(0,q.pop())
 while i<len(q):
  x=list(r(q[i],'_',' '))+[' ']
  for a in u[i]:x[a]='_'
  p(r(r(r(r(''.join(x),'___',''),"\\",'t'),'/',"\\"),'t','/'))
  i+=1

PHP, 263 bytes
<?=strtr('3333 20220'.['2 0332 020_
2/\2/\211\113/2113/\212 1
 /2\/2\ 11 \ |1412 14\22/0\ 14 1
/32 \112\|102 \012 \2/22\12 1',
'
\32 /112/|13/212 /2\ 0 /12 1
 \2/\2/ 11 / |1412 14/22\2/ 14 1
2\/2\/211/1102 \010|3\/2102_|_'][$argn&1],[__,"  |","  ","     ","--"]);

Try it online!

You can save eight more bytes with an own replacement for 3 spaces.

Ruby, 290 bytes
$><<(gets.to_i%2<1?"xCeCdCnCcC_
c/Bc/Be|ABAAf/e|Af/Be|f|
b/cB/cBd|AbBb|A--Af|--Be/CBd|--d|
/iBAAcB|ACdBCAdBc/eBAf|":"xCeC
Bi/AAc/|Af/e|d/cBbCb/Af|
bBc/Bc/d|Ab/b|A--Af|--/eBc/d|--d|
cB/cB/e|A/AACdBCAC|fB/e|Cc_|_").gsub(?C,'__').tr(?B,?\\).gsub(?A,'c|').gsub(/[a-z]/){|e|' '*(e.ord-97)}

Probably a weak and improvable entry. Basically a very simple (handcrafted) compression where lowercase letters mean that many spaces (actually ord(ch) - 'A' spaces) and uppercase letters are just some common terms that saved a few bytes.

SOGL V0.12, 72 71 bytes
═j;ΗD^⌡⁾yō⁶⅜┐≡¼τ~≡š┘,┼◄‚4øDqψ∫‛²′Ζdκ↓±ģ░○∙ΘΝ◄ōΞ06║⁶╗i-η}┌^JY³‘''n.2%?№↕

Try it Here!
SOGLs vertical mirroring worked perfectly for this.

Canvas, 70 bytes
Ｃ＜aT［≤＾５ｔ‽◂6Ｚｒ!ｖ↓［ｕ0F∙ＯＦ－╫＃ｔ┬ａ*７ＺfK1!&)y＠½（＋M⇵ＰV-¼G:Ｕju╋╷(╫:N‟‾)ｎ⁸２％？↕

Try it here!


text:
ASCII Scores
Digging around in the depths of your temp folder, you find some compositions for the piano. Unfortunately, these compositions were written with note names and durations only, and you only have access to a text terminal. Therefore, your task is to write a program to display the compositions as ASCII art.
Input
Your program should accept two strings as input. The first string will represent the notes of the top staff (with the treble clef), while the second string will represent the notes of the bottom staff.
The notes will be passed in scientific pitch notation. The top staff's notes will always be between C4 and C6 inclusive. The bottom staff's notes will always be between C2 and C4 inclusive.
Each note will come with a duration, which will be one of: 1, 2, 4, 8. These represent a whole note (semibreve), a half note (minim), a quarter note (crotchet), and an eighth note (quaver) respectively.
Notes of any other duration will never appear in the input.
How the note and duration is separated, and how each note is separated from other notes in the input is up to your discretion. The following is a sample input for the top staff:
E4/4 A4/8 C#5/8 E5/2

Here, the notes are separated by a space, and the duration is separated from the note with a forward slash. These delimeters are not fixed, and you may choose to change them or omit them altogether.
You may assume there is at least one note in each staff. There are no rests in the input.
Output
Your program is to output the score as ASCII art, conforming to the following descriptions.
The clefs should be the first thing at the left of your output (the distance between the two staves should not be changed):
       ^
      | |
------|/----
      /
-----/|-----
    / |
---/--__----
   | /  \
---\-\|-|---
    \ | /
------|-----
      |
    \_/

----___-----
   /   \ |
---\---|----
       | |
-------/----
      /
-----/------

------------

A note's stem (the vertical line next to the circle) should point upwards if the note is below the middle line of a staff. It should point downwards if the note is above the middle line of a staff. If the note is on the middle line, then the stem may point in either direction. (The only exception to this is for the bonus, and occurs when connecting eighth notes, described later). The stem should begin on the line above/below the circle, and be 6 lines tall.
All types of notes except whole notes have stems. The flag of an eighth note is represented by two forward slashes on different lines (see example notes below).
A filled in note head (for quarter and eighth notes) is represented by (@). An empty note head (for half and whole notes) is represented by ( ).
Accidentals (sharps, flats, naturals) should be placed as shown in the example notes, with exactly one character between the right side of the accidental and the left side of the note head.
Ledger lines should be used when necessary, and should be 7 characters in length, centered around the note head.
Each note should be 12 characters wide.
Example notes:
                                         |_
                                         |_| ( )
                      |                    |------
                      |
------------ ---------|-- ------------ ------------ ------------
                      |
------------ ---------|-- ---|-------- ------------ ------------
      (@)    _|_|_    |      |_
-----|------ _|_|_-( )--- ---|/-(@)--- ------------ ---------|\-
     |        | |              |                             | \
-----|------ ------------ -----|------ ------------ ---------|--
     |                         |                             |
-----|------ ------------ -----|------ ------------ ---------|--
     |                         | /                           |
                               |/                       --(@)--

quarter note half note    eighth note  whole note   eighth note
              sharped      flatted      natural

After the 12-character note, leave 2 * 12 - 12 = 12 characters blank (either  or - depending on the line) if the note is a quarter note. If the note is a half note, leave 4 * 12 - 12 = 36 characters blank. If the note is a whole note, leave 8 * 12 - 12 = 84 characters blank. Do not add extra characters for eighth notes.
At the end of each measure (96 characters after either the clef or bar line), output a bar line. This is done by going down every character between the uppermost and bottom-most lines (inclusive), and replacing  with | and - with +. (See example output at bottom of question).
At the end of the piece, output the music end by outputting 3 bar lines in a row, but with a space between the first and second. That is:
+-++
| ||
+-++
| ||
. ..
. ..

Note that sharps, flats, and naturals last until the end of the measure. The natural sign should only be used to cancel out a sharp or flat used earlier in the same measure.
For the purpose of this task, sharps, flats, and naturals only affect a note in one octave, and in one clef (a sharp on A5 does not cause A4 to be sharped, and a flat on C4 in the top staff does not cause C4 in the bottom staff to be flatted).
Information for the bonus only
The bonus involves properly connecting eighth notes.
When there are two consecutive eighth notes, aligned to the quarter note beat (in other words, the number of characters before the first eighth note is a multiple of 24), the two eighth notes are to be connected.
Let note A be the note farthest from the middle of the staff. If both notes are the same distance from the middle, either note may be note A. Let the other note be note B.
The direction of both stems should be the direction of the stem of note A.
The stem of one of the notes should be 6 lines tall (as is the case for stems in general), and the stem of the other note should be extended to the end of the stem of the other note.
The stems should be connected with _.
Example connected eighth notes:
                                   ___________
                                  |           |
                                  |           |
                                  |           |
                                  |           |       --(@)--
                            |     |           |        |
------------------------ ---|_----|-----------|-- -----|------------------
                            |/ (@)            |        |        |_
------------------------ ---------------------|-- -----|--------|_|-(@)---
      (@)   _|_|_                             |        |          ||
-----|------_|_|_-(@)--- ---------------------|-- -----|-----------|------
     |       | | |                            |        |           |
-----|-----------|------ ---------------------|-- -----|-----------|------
     |           |                            |        |           |
-----|-----------|------ ------------------(@)--- -----|___________|------
     |           |
     |___________|

Example input and output
Input:
A#4/4 G#4/4 F#4/2 A#4/4 G#4/4 F#4/2 F#4/8 F#4/8 F#4/8 F#4/8 G#4/8 G#4/8 G#4/8 G#4/8 A#4/4 G#4/4 F#4/2
A#3/4 G#3/4 F#3/2 A#3/4 G#3/4 F#3/2 F#3/2 G#3/2 F#3/4 E#3/4 F#3/2

Output:
       ^
      | |            |                                                                                |                                                                                |
------|/-------------|-----------------------|--------------------------------------------------------------+---------|-----------------------|--------------------------------------------------------------+----------___________-------------___________------------|\----------|\----------|\----------|\-+---------|-----------------------|--------------------------------------------------------------+-++
      /              |                       |                       |                                      |         |                       |                       |                                      |         |           |           |           |           | \         | \         | \         | \|         |                       |                       |                                      | ||
-----/|--------------|-----------------------|-----------------------|--------------------------------------+---------|-----------------------|-----------------------|--------------------------------------+---------|-----------|-----------|-----------|-----------|-----------|-----------|-----------|--+---------|-----------------------|-----------------------|--------------------------------------+-++
    / |              |                       |                       |                                      |         |                       |                       |                                      |         |           |           |           |           |           |           |           |  |         |                       |                       |                                      | ||
---/--__----_|_|_----|-----------------------|-----------------------|--------------------------------------+_|_|_----|-----------------------|-----------------------|--------------------------------------+---------|-----------|-----------|-----------|-----------|-----------|-----------|-----------|--+_|_|_----|-----------------------|-----------------------|--------------------------------------+-++
   | /  \   _|_|_ (@)               _|_|_    |                       |                                      |_|_|_ (@)               _|_|_    |                       |                                      |         |           |           |           |  _|_|_    |           |           |           |  |_|_|_ (@)               _|_|_    |                       |                                      | ||
---\-\|-|----|-|--------------------_|_|_-(@)---------------_|_|_----|--------------------------------------+-|-|--------------------_|_|_-(@)---------------_|_|_----|--------------------------------------+_|_|_----|-----------|-----------|-----------|--_|_|_-(@)---------(@)---------(@)---------(@)---+-|-|--------------------_|_|_-(@)---------------_|_|_----|--------------------------------------+-++
    \ | /                            | |                    _|_|_ ( )                                       |                         | |                    _|_|_ ( )                                       |_|_|_ (@)         (@)         (@)         (@)    | |                                            |                         | |                    _|_|_ ( )                                       | ||
------|------------------------------------------------------|-|--------------------------------------------+-------------------------------------------------|-|--------------------------------------------+-|-|--------------------------------------------------------------------------------------------+-------------------------------------------------|-|--------------------------------------------+-++
      |                                                                                |                                                                                |                                                                                |                                                                                | ||
    \_/                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
            _|_|_                                                                                |_|_|_                                                                                |                                                                                |                                                                                | ||
----___-----_|_|_-(@)---------------_|_|_-------------------------------------------------------------------+_|_|_-(@)---------------_|_|_-------------------------------------------------------------------+------------------------------------------------_|_|_-------------------------------------------+------------------------------------------------------------------------------------------------+-++
   /   \ |   | | |                  _|_|_ (@)               _|_|_                                           | | | |                  _|_|_ (@)               _|_|_                                           |_|_|_                                           _|_|_ ( )                                       |_|_|_                                                                                | ||
---\---|---------|-------------------|-|-|------------------_|_|_-( )---------------------------------------+-----|-------------------|-|-|------------------_|_|_-( )---------------------------------------+_|_|_-( )----------------------------------------|-|-|------------------------------------------+_|_|_ (@)---------------_|_|_-------------------------( )---------------------------------------+-++
       | |       |                       |                   | | |                                          |     |                       |                   | | |                                          | | | |                                               |                                          | | | |                  _|_|_ (@)                    |                                          | ||
-------/---------|-----------------------|-----------------------|------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-----|-----------------------------------------------|------------------------------------------+-----|-------------------|-|-|-----------------------|------------------------------------------+-++
      /          |                       |                       |                                          |     |                       |                       |                                          |     |                                               |                                          |     |                       |                       |                                          | ||
-----/-----------|-----------------------|-----------------------|------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-----|-----------------------------------------------|------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-++
                                         |                       |                                          |                             |                       |                                          |     |                                               |                                          |     |                       |                       |                                          | ||
-----------------------------------------------------------------|------------------------------------------+-----------------------------------------------------|------------------------------------------+-----|------------------------------------------------------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-++
                                                                                |

For the sake of demonstration, in the third measure, the F# eighth notes are connected, whereas the G# eighth notes are not. Your program should either connect the eighth notes whenever applicable (for the bonus), or leave them all disconnected.
Other information

Any amount of trailing whitespace/lines is acceptable.
There should be no extra whitespace before the clefs, nor whitespace between notes. Any number of blank lines may be emitted before/after the output.
The bonus for connecting eighth notes is 0.75 * number of bytes of source code.
This is code-golf, so shortest code wins.

You've not filled in the quaver on middle C (assuming treble cleff) in one of your examples.

@Muzer Thanks, fixed.

Also, I have to say, what a wonderful challenge. I don't have time myself to write an entry at the moment but I'm very interested to see what people come up with. (PS: Is it bad that I instantly recognised the tune? ;))

@steveverrill You are correct, fixed.

This is awesome! Hard, but awesome.

Will we be required to implement both staves?

@SpeedyNinja yes,  both staves are required

Great challenge! One thing I noticed is that in the example notes some of the stems are facing the wrong way

I might just code this without making it short lol

The final note of the bass clef line in the data is a quarter note, when it should be a half note (as shown in your demo)
(i.e. the final F#3/4 should be F#3/2)

@iAmMortos Thanks, fixed.

What if doing bonus and connected thing cross another stave (https://pastebin.com/uPpc1bMy) ?

Python - 8.85... KB (9369 9066 B)
HaHA! Fastest gun in the... West?
This is FAR from being properly golfed, but it at least functions. At the moment of posting this, it's the shortest entry, so... yay?
Let me start by saying that I've never golfed anything this big, and I don't even know where to START.
This entry does not contain the bonus points yet, but I'd still like to add that before golfing.
I basically wrote a kind of ASCII rendering class that stores the characters that make up each "block" in a 2D format so that any number of different "symbols" could be drawn over the 2D grid. For note blocks, the staff was drawn first, then any staff extending bars as necessary, then the note head, followed by the stem and tail (where applicable) and last the accidental.
When given the following two inputs for trebble and bass clefs:
A#4/4 G#4/4 F#4/2 A#4/4 G#4/4 F#4/2 F#4/8 F#4/8 F#4/8 F#4/8 G#4/8 G#4/8 G#4/8 G#4/8 A#4/4 G#4/4 F#4/2
A#3/4 G#3/4 F#3/2 A#3/4 G#3/4 F#3/2 F#3/2 G#3/2 F#3/4 E#3/4 F#3/2

The following output results:
       ^
      | |            |                                                                                |                                                                                |
------|/-------------|-----------------------|--------------------------------------------------------------+---------|-----------------------|--------------------------------------------------------------+---------------------------------------------------------|\----------|\----------|\----------|\-+---------|-----------------------|--------------------------------------------------------------+-++
      /              |                       |                       |                                      |         |                       |                       |                                      |         |\          |\          |\          |\          | \         | \         | \         | \|         |                       |                       |                                      | ||
-----/|--------------|-----------------------|-----------------------|--------------------------------------+---------|-----------------------|-----------------------|--------------------------------------+---------|-\---------|-\---------|-\---------|-\---------|-----------|-----------|-----------|--+---------|-----------------------|-----------------------|--------------------------------------+-++
    / |              |                       |                       |                                      |         |                       |                       |                                      |         |           |           |           |           |           |           |           |  |         |                       |                       |                                      | ||
---/--__----_|_|_----|-----------------------|-----------------------|--------------------------------------+_|_|_----|-----------------------|-----------------------|--------------------------------------+---------|-----------|-----------|-----------|-----------|-----------|-----------|-----------|--+_|_|_----|-----------------------|-----------------------|--------------------------------------+-++
   | /  \   _|_|_ (@)               _|_|_    |                       |                                      |_|_|_ (@)               _|_|_    |                       |                                      |         |           |           |           |  _|_|_    |           |           |           |  |_|_|_ (@)               _|_|_    |                       |                                      | ||
---\-\|-|----|-|--------------------_|_|_-(@)---------------_|_|_----|--------------------------------------+-|-|--------------------_|_|_-(@)---------------_|_|_----|--------------------------------------+_|_|_----|-----------|-----------|-----------|--_|_|_-(@)---------(@)---------(@)---------(@)---+-|-|--------------------_|_|_-(@)---------------_|_|_----|--------------------------------------+-++
    \ | /                            | |                    _|_|_ ( )                                       |                         | |                    _|_|_ ( )                                       |_|_|_ (@)         (@)         (@)         (@)    | |                                            |                         | |                    _|_|_ ( )                                       | ||
------|------------------------------------------------------|-|--------------------------------------------+-------------------------------------------------|-|--------------------------------------------+-|-|--------------------------------------------------------------------------------------------+-------------------------------------------------|-|--------------------------------------------+-++
      |                                                                                |                                                                                |                                                                                |                                                                                | ||
    \_/                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
                                                                                |                                                                                |                                                                                |                                                                                | ||
            _|_|_                                                                                |_|_|_                                                                                |                                                                                |                                                                                | ||
----___-----_|_|_-(@)---------------_|_|_-------------------------------------------------------------------+_|_|_-(@)---------------_|_|_-------------------------------------------------------------------+------------------------------------------------_|_|_-------------------------------------------+------------------------------------------------------------------------------------------------+-++
   /   \ |   | | |                  _|_|_ (@)               _|_|_                                           | | | |                  _|_|_ (@)               _|_|_                                           |_|_|_                                           _|_|_ ( )                                       |_|_|_                                                                                | ||
---\---|---------|-------------------|-|-|------------------_|_|_-( )---------------------------------------+-----|-------------------|-|-|------------------_|_|_-( )---------------------------------------+_|_|_-( )----------------------------------------|-|-|------------------------------------------+_|_|_-(@)---------------_|_|_-------------------------( )---------------------------------------+-++
       | |       |                       |                   | | |                                          |     |                       |                   | | |                                          | | | |                                               |                                          | | | |                  _|_|_ (@)                    |                                          | ||
-------/---------|-----------------------|-----------------------|------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-----|-----------------------------------------------|------------------------------------------+-----|-------------------|-|-|-----------------------|------------------------------------------+-++
      /          |                       |                       |                                          |     |                       |                       |                                          |     |                                               |                                          |     |                       |                       |                                          | ||
-----/-----------|-----------------------|-----------------------|------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-----|-----------------------------------------------|------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-++
                                         |                       |                                          |                             |                       |                                          |     |                                               |                                          |     |                       |                       |                                          | ||
-----------------------------------------------------------------|------------------------------------------+-----------------------------------------------------|------------------------------------------+-----|------------------------------------------------------------------------------------------+-----|-----------------------|-----------------------|------------------------------------------+-++

Here's a working version of the code with some faux input code since this particular python web IDE didn't allow for simulated input or separate files.
grandstaff.py
Contains both trebble and bass clef staffs, and handles drawing the barlines between the two.
class GrandStaff:
  def __init__(self, trebbleStr, bassStr):
    self.trebbleStr = trebbleStr
    self.bassStr = bassStr
    self.trebbleStaff = Staff("trebble", self.trebbleStr)
    self.bassStaff = Staff("bass", self.bassStr)
    self.bassOffset = 16

    self.lines = {}
    maxmin = self.trebbleStaff.getYExtremes()
    for y in range(maxmin[0], maxmin[1] + 1):
      self.lines[y] = self.trebbleStaff.lines[y]
    maxmin = self.bassStaff.getYExtremes()
    for y in range(maxmin[0], maxmin[1] + 1):
      self.lines[y + self.bassOffset] = self.bassStaff.lines[y]

    for y in range(5, 12):
      self.lines.setdefault(y, [" " for x in range(len(self.trebbleStaff.getLineStr(0)))])
      xpos = 0
      for block in self.trebbleStaff.getBlocks():
        if block.type == "barline":
          self.lines[y][xpos] = '|'
        elif block.type == "finalDoubleBarline":
          for x in [0, 2, 3]:
            self.lines[y][xpos + x] = '|'
        xpos += block.width

  def __str__(self):
    outstr = ""
    maxmin = sorted(self.lines.keys())
    for y in range(maxmin[0], maxmin[-1]):
      self.lines.setdefault(y, [" " for x in range(len(self.trebbleStaff.getLineStr(0)))])
      outstr += ''.join(self.lines[y]) + '\n'

        return outstr

staff.py
A single staff. Contains an array of "Block" objects that represent notes, barlines, clefs, etc. This class handles the spacing of the notes and insertion of the barlines at the appropriate places.
class Staff:
  def __init__(self, clef, inputStr):
    self.clef = clef
    self.inStr = inputStr
    self.lines = {}
    self.__blocks = []
    if clef == "trebble":
      self.__blocks.append(Block("trebbleClef"))
    elif clef == "bass":
      self.__blocks.append(Block("bassClef"))

    notes = inputStr.split(" ");
    measureLength = 0
    for note in notes:
      if measureLength >= 1:
        self.__blocks.append(Block("barline"))
        measureLength -= 1
      parts = note.split("/")
      noteLength = 0
      if len(parts) == 2:
          noteLength += 1 / float(parts[1])
          measureLength += noteLength
      self.__blocks.append(Block("note", note, self.clef))
      for n in range(int(noteLength * 8) - 1):
          self.__blocks.append(Block("staff"))
    self.__blocks.append(Block("finalDoubleBarline"))

    sharps = []
    flats = []
    naturals = []
    for block in self.__blocks:
      if block.type == "note":
        val = block.value

        if block.isSharp:
          if val not in sharps:
            sharps.append(val)
          else:
            block.clearAccidental()
        elif block.isFlat:
          if val not in flats:
            flats.append(val)
          else:
            block.clearAccidental()
        else:
          if val in sharps:
            sharps.remove(val)
            block.setNatural()
          if val in flats:
            flats.remove(val)
            block.setNatural()

      elif block.type == "barline" or block.type == "finalDoubleBarline":
        sharps = []
        flats = []

    maxmin = self.getYExtremes()
    for y in range(maxmin[0], maxmin[1] + 1):
      self.lines[y] = list(self.getLineStr(y))

  def getLineStr(self, lineNum):
    outstr = ""
    for block in self.__blocks:
      outstr += block.getLineStr(lineNum)
    return outstr

  def getYExtremes(self):
    maxmin = [0, 0]
    for block in self.__blocks:
      mm = block.getYExtremes()
      maxmin[0] = mm[0] if mm[0] < maxmin[0] else maxmin[0]
      maxmin[1] = mm[1] if mm[1] > maxmin[1] else maxmin[1]
    return maxmin

  def getBlocks(self):
    return self.__blocks

  def __str__(self):
    maxmin = self.getYExtremes()
    outstr = ""
    for line in range(maxmin[0], maxmin[1] + 1):
      outstr += self.getLineStr(line) + "\n"
    return outstr

block.py
This class handles the "rendering" (or perhaps composition) of the ASCII text. Inside are the hard-coded symbols such as the trebble and bass clefs, a blank staff, barlines, accidentals, and the necessary pieces to build notes of different durations. These are "drawn" onto a 2D grid of character "pixels" in sequential order to produce the final ASCII block.
class Block:

  __staff = [[range(-4, 5, 2),"w",'-']]
  __trebble = [[-6, 7, '^'], [range(-5, 6), 6, '|'], [-5, 8, '|'], [-4, 7, '/'], [-3, 6, '/'], [-2, 5, '/'], [-1, 4, '/'], [0, 3, '/'], [0, range(6,8), '_'], [1, 3, '|'], [1, 5, '/'], [1, 6, ' '], [1, 8, '\\'], [2, 3, '\\'], [2, 5, '\\'], [2, 8, '|'], [3, 4, '\\'], [3, 8, '/'], [6, 4, '\\'], [6, 5, '_'], [6, 6, '/']]
  __bass = [[-4, range(4, 7), '_'], [-3, 3, '/'], [-3, 7, '\\'], [range(-3, 0, 2), 9, '|'], [-2, 3, '\\'], [range(-2, 0), 7, '|'], [0, 7, '/'], [1, 6, '/'], [2, 5, '/']]
  __sharp = [[range(-1, 1), range(0, 5), '_'], [range(-1, 2), range(1, 4, 2), '|']]
  __flat = [[range(-2, 1), 3, '|'], [-1, 4, '_'], [0, 4, '/']]
  __natural = [[range(-1, 1), 2, '|'], [range(-1, 1), 3, '_'], [range(0, 2), 4, '|']]
  __noteOpen = [[0, 6, '('], [0, 7, ' '], [0, 8, ')']]
  __noteClosed = [[0, 6, '('], [0, 7, '@'], [0, 8, ')']]
  __stemUp = [[range(-6, 0), 9, '|']]
  __stemDown = [[range(1, 7), 5, '|']]
  __eighthTailUp = [[-6, 10, '\\'], [-5, 11, '\\']]
  __eighthTailDown = [[6, 6, '/'], [5, 7, '/']]
  __barline = [[range(-4, 5), 0, '+'], [range(-3, 4, 2), 0, '|']]
  __finalBarline = [[range(-4, 5, 2), [0, 2, 3], '+'], [range(-3, 4, 2), [0, 2, 3], '|'], [range(-4, 5, 2), 1, '-']]
  __staffExtender = [[0, range(4, 11), '-']]

  def __init__(self, type, notestr = "", clef = "trebble"):
    if type == "note":
      self.clef = clef
      self.notestr = notestr.upper().split('/')[0]
      self.duration = int(notestr.upper().split('/')[1])
      self.isSharp = True if notestr[1] == '#' else False
      self.isFlat = True if notestr[1] == 'b' else False
      self.isNatural = False;
      self.__clefCallibration = {"trebble":{"A":1,"B":0,"C":6,"D":5,"E":4,"F":3,"G":2,"octave":4}, "bass":{"A":-4,"B":-5,"C":1,"D":0,"E":-1,"F":-2,"G":-3,"octave":3}}
      self.value = self.__clefCallibration[self.clef][self.notestr[0]] + ((self.__clefCallibration[self.clef]["octave"] - int(self.notestr[-1])) * 7)

    self.lines = {}
    self.type = type

    self.__drawBlock()

  def __drawBlock(self):
    self.lines = {}
    if self.type == "note":
      self.width = 12
      self.__draw(self.__staff)

      for y in range(6, self.value + 1, 2):
        self.__draw(self.__staffExtender, y)
      for y in range(-6, self.value - 1, -2):
        self.__draw(self.__staffExtender, y)

      if self.duration in [1, 2]:
        self.__draw(self.__noteOpen, self.value)
      else:
        self.__draw(self.__noteClosed, self.value)

      if self.duration != 1:
        if self.value < 0:
          self.__draw(self.__stemDown, self.value)
          if self.duration == 8:
            self.__draw(self.__eighthTailDown, self.value)
        else:
          self.__draw(self.__stemUp, self.value)
          if self.duration == 8:
            self.__draw(self.__eighthTailUp, self.value)

      if self.isSharp:
        self.__draw(self.__sharp, self.value)
      elif self.isFlat:
        self.__draw(self.__flat, self.value)
      elif self.isNatural:
        self.__draw(self.__natural, self.value)

      # self.__draw(__staffExtender, self.value)
    elif self.type == "staff":
      self.width = 12
      self.__draw(self.__staff)
    elif self.type == "barline":
      self.width = 1
      self.__draw(self.__barline)
    elif self.type == "finalDoubleBarline":
      self.width = 4
      self.__draw(self.__finalBarline)
    elif self.type == "trebbleClef":
      self.width = 12
      self.__draw(self.__staff)
      self.__draw(self.__trebble)
    elif self.type == "bassClef":
      self.width = 12
      self.__draw(self.__staff)
      self.__draw(self.__bass)

  def __draw(self, data, yOffset = 0):
    for char in data:
        self.__drawChunk(char, yOffset)

  def __drawChunk(self, char, yOffset = 0):
      xrng = []
      yrng = []
      drawChr = char[2]

      if type(char[0]) == int:
        yrng = [char[0]]
      elif type(char[0]) == list:
        yrng = char[0]
      else:
        print("ERROR: invalid y range input")

      if type(char[1]) == str:
        if char[1] == 'w':
          xrng = range(self.width)
      elif type(char[1]) == int:
        xrng = [char[1]]
      elif type(char[1]) == list:
        xrng = char[1]
      else:
        print("ERROR: invalid x range input")

      yrng = [y + yOffset for y in yrng]

      for y in yrng:
        self.lines.setdefault(y,[" " for i in range(self.width)])
        for x in xrng:
          self.lines[y][x] = drawChr

  def getLineStr(self, lineNum):
    return "".join(self.lines.setdefault(lineNum, [" " for i in range(self.width)]))

  def getYExtremes(self):
    k = sorted(self.lines.keys())
    return [k[0], k[-1]]

  def setSharp(self):
    self.isSharp = True
    self.isFlat = False
    self.isNatural = False
    self.__drawBlock()

  def setFlat(self):
    self.isSharp = False
    self.isFlat = True
    self.isNatural = False
    self.__drawBlock()

  def setNatural(self):
    self.isSharp = False
    self.isFlat = False
    self.isNatural = True
    self.__drawBlock()

  def clearAccidental(self):
    self.isSharp = False
    self.isFlat = False
    self.isNatural = False
    self.__drawBlock()

  def __str__(self):
    strOut = ""
    first = sorted(self.lines.keys())[0]
    last = sorted(self.lines.keys())[-1]
    for line in range(first, last + 1):
        strOut += self.getLineStr(line) + "\n"
    return strOut

main.py
This class simply "runs" the program by creating an instance of GrandStaff, passing it the given string inputs, and printing it's string value.
import sys
from block import *
from grandstaff import *
from staff import *

print (GrandStaff(sys.argv[1],sys.argv[2]))

source: Stack Exchange

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

sort: votes


text:
FizzBuzz Reverse Solver

Synopsis: Given the output of a generalised FizzBuzz program, return the list of factors and words used for the program.

Challenge Description
Imagine a generalised FizzBuzz program that takes in as input a list of factors and words to use and the number to start from. For instance, if the input of this program was
3 2,Ninja 5,Bear 7,Monkey

The program would print out numbers from 3 to 100, replacing numbers divisible by 2 with Ninja, numbers divisible by 5 with Bear, and numbers divisible by 7 with Monkey. For numbers that are divisible then more than one of those terms, the program will concatenate the words, printing things such as NinjaBear or BearMonkey or NinjaMonkey or NinjaBearMonkey. Here's the output of that input:
3
Ninja
Bear
Ninja
Monkey
Ninja
9
NinjaBear
11
Ninja
13
NinjaMonkey
Bear
Ninja
17
Ninja
19
NinjaBear
Monkey
Ninja
23
Ninja
Bear
Ninja
27
NinjaMonkey
29
NinjaBear
31
Ninja
33
Ninja
BearMonkey
Ninja
37
Ninja
39
NinjaBear
41
NinjaMonkey
43
Ninja
Bear
Ninja
47
Ninja
Monkey
NinjaBear
51
Ninja
53
Ninja
Bear
NinjaMonkey
57
Ninja
59
NinjaBear
61
Ninja
Monkey
Ninja
Bear
Ninja
67
Ninja
69
NinjaBearMonkey
71
Ninja
73
Ninja
Bear
Ninja
Monkey
Ninja
79
NinjaBear
81
Ninja
83
NinjaMonkey
Bear
Ninja
87
Ninja
89
NinjaBear
Monkey
Ninja
93
Ninja
Bear
Ninja
97
NinjaMonkey
99
NinjaBear

Note that whenever the program needs to combine words together, it always goes from lowest number to highest number. So it won't print out something like MonkeyBear (since Monkey is a higher number than Bear is).
Your program should take in the output of the generalised FizzBuzz program as input, and output the input given to the generalised FizzBuzz program. In other words, write a "reverse program" for the generalised FizzBuzz program. For instance, given the code block above as input, your program should output 3 2,Ninja 5,Bear, 7,Monkey.
There are some rules that the words will always follow:

It will always be possible to tell exactly what the factors and words are from the input.
Each word will begin with a capital letter and will not contain any other capital letters, or numbers.
Each factor is unique.

Sample Inputs and Outputs
Input:
Calvins
7
Hobbies
9
10
11
Calvins
13
14
15
Hobbies
17
Calvins
19
20
21
22
23
CalvinsHobbies
25
26
27
28
29
Calvins
31
Hobbies
33
34
35
Calvins
37
38
39
Hobbies
41
Calvins
43
44
45
46
47
CalvinsHobbies
49
50
51
52
53
Calvins
55
Hobbies
57
58
59
Calvins
61
62
63
Hobbies
65
Calvins
67
68
69
70
71
CalvinsHobbies
73
74
75
76
77
Calvins
79
Hobbies
81
82
83
Calvins
85
86
87
Hobbies
89
Calvins
91
92
93
94
95
CalvinsHobbies
97
98
99
100

Output:
6 6,Calvins 8,Hobbies

Input:
FryEggman
7
Am
Fry
The
11
FryAmEggman
13
14
FryThe
Am
17
FryEggman
19
AmThe
Fry
22
23
FryAmEggman
The
26
Fry
Am
29
FryTheEggman
31
Am
Fry
34
The
FryAmEggman
37
38
Fry
AmThe
41
FryEggman
43
Am
FryThe
46
47
FryAmEggman
49
The
Fry
Am
53
FryEggman
The
Am
Fry
58
59
FryAmTheEggman
61
62
Fry
Am
The
FryEggman
67
Am
Fry
The
71
FryAmEggman
73
74
FryThe
Am
77
FryEggman
79
AmThe
Fry
82
83
FryAmEggman
The
86
Fry
Am
89
FryTheEggman
91
Am
Fry
94
The
FryAmEggman
97
98
Fry
AmThe

Output:
6 3,Fry 4,Am 5,The 6,Eggman

Input:
DeliciousTartApplePie
DeliciousCreamPancakeStrawberry
DeliciousProfiterole
DeliciousCream
DeliciousPancake
DeliciousCreamStrawberryTart

Output:
95 1,Delicious 2,Cream 3,Pancake 4,Strawberry 5,Tart 19,Apple 95,Pie 97,Profiterole

You can get the code I used to generate the inputs here.

Does the list always go up to exactly 100?

@Dennis Yes, the upper bound is always 100.

It's just an honor to be in one of your examples.

This is a much better version of your challenge than was originally in the sandbox :)

@NinjaBearMonkey I suppose picking names with many words in them made us better examples. Thanks for including me too @Pyrrha! :)

@Pyrrha The last example seems to imply the factors are guaranteed to be unique, but I don't see this in the text. Is that  supposed to be the case?

@isaacg Huh, I was sure I had that in there somewhere. Yes, the factors are unique. My apologies for forgetting to include that. I've edited the question to reflect this.

Array of strings is acceptable, right?

Pyth, 73 bytes
jd+J-101lK.zjL\,Sm,_-F>2+_Jf}d@KTUKd{smtcdf-@dTGUdf>T\:K

That was certaintly a tough one. I think I've covered all the edge cases, including everything in @MartinBüttner's example, and the no repeat factors example.
NinjaBearMonkey, Deliciousness
At the high level, the program first finds all of the words by chopping up the alphabetical strings on capital letters.
Then, the rows are mapped to whether or not each string appears in the row, and each possible factor is tested to see if it produces the same ordering. If it does, the factor is added to a gobal list, which is check to see if the factor was already present. If it was not already present, the factor is used. The strings are ordered by first appearance in the input, which disambiguates the ordering of strings that each appear only once in the same row.
After that, it's just formatting and printing.

Scala, 350 characters
(s:String)⇒{def g(a:Int,b:Int):Int=if(b==0)a.abs else g(b,a%b);val(j,q)=(s.lines:\100→Map.empty[String,Int]){case(l,(n,m))⇒if(l(0).isDigit)(n-1,m)else(n-1,m++(Seq(Seq(l(0)))/:l.tail){case(x,c)⇒if(c.isUpper)Seq(c)+:x else (x(0):+c)+:x.tail}.map{t⇒val w=t.mkString;w→g(m.getOrElse(w,n),n)})};s"${j+1}"+q.map{case(k,v)=>s" $v,$k"}.toSeq.sorted.mkString}

not winning... but nice question.
tested results:
scala> (s:String)⇒{def g(a:Int,b:Int):Int=if(b==0)a.abs else g(b,a%b);val(j,q)=(s.lines:\100→Map.empty[String,Int]){case(l,(n,m))⇒if(l(0).isDigit)(n-1,m)else(n-1,m++(Seq(Seq(l(0)))/:l.tail){case(x,c)⇒if(c.isUpper)Seq(c)+:x else (x(0):+c)+:x.tail}.map{t⇒val w=t.mkString;w→g(m.getOrElse(w,n),n)})};s"${j+1}"+q.map{case(k,v)=>s" $v,$k"}.toSeq.sorted.mkString}
res0: String => String = <function1>

scala> res0("""DeliciousTartApplePie
     | DeliciousCreamPancakeStrawberry
     | DeliciousProfiterole
     | DeliciousCream
     | DeliciousPancake
     | DeliciousCreamStrawberryTart""")
res1: String = 95 1,Delicious 2,Cream 3,Pancake 4,Strawberry 5,Tart 95,Apple 95,Pie 97,Profiterole

scala> res0("""FryEggman
     | 7
     | Am
     | Fry
     | The
     | 11
     | FryAmEggman
     | 13
     | 14
     | FryThe
     | Am
     | 17
     | FryEggman
     | 19
     | AmThe
     | Fry
     | 22
     | 23
     | FryAmEggman
     | The
     | 26
     | Fry
     | Am
     | 29
     | FryTheEggman
     | 31
     | Am
     | Fry
     | 34
     | The
     | FryAmEggman
     | 37
     | 38
     | Fry
     | AmThe
     | 41
     | FryEggman
     | 43
     | Am
     | FryThe
     | 46
     | 47
     | FryAmEggman
     | 49
     | The
     | Fry
     | Am
     | 53
     | FryEggman
     | The
     | Am
     | Fry
     | 58
     | 59
     | FryAmTheEggman
     | 61
     | 62
     | Fry
     | Am
     | The
     | FryEggman
     | 67
     | Am
     | Fry
     | The
     | 71
     | FryAmEggman
     | 73
     | 74
     | FryThe
     | Am
     | 77
     | FryEggman
     | 79
     | AmThe
     | Fry
     | 82
     | 83
     | FryAmEggman
     | The
     | 86
     | Fry
     | Am
     | 89
     | FryTheEggman
     | 91
     | Am
     | Fry
     | 94
     | The
     | FryAmEggman
     | 97
     | 98
     | Fry
     | AmThe""")
res2: String = 6 3,Fry 4,Am 5,The 6,Eggman

Python 2, 366 340 331 bytes
This program receive input via stdin.
New approach:
Calculate the factor of only one occurrence's words by the distance from the end of the line. For example (from the last sample): DeliciousTartApplePie Pie is calculate as: [95,19,5,1][0] and Apple is: [95,19,5,1][1].
import sys
import re
d=[(i,re.findall('[A-Z][a-z]*',l)[::-1])for i,l in enumerate(sys.stdin)]
e=101-len(d)
print e," ".join(`x`+','+`y`[1:-1]for x,y in sorted({next((j-i for j,t in d if j>i and w in t),[x for x in range(i+e,0,-1)if(i+e)%x==0][d[i][1].index(w)]):w for w,i in{w:i for i,l in d[::-1]for w in l}.items()}.iteritems()))

Old approach:
import sys
import re
l=[(i,re.findall('[A-Z][a-z]*',l))for i,l in enumerate(sys.stdin)]
e=101-len(l)
d={}
for i,s in l:
 for w in s[::-1]:
  if w not in d.values():
   d[next((j-i for j,t in l[i+1:]if w in t),next(m for m in range(i+e,0,-1)if(i+e)%m==0and m not in d))]=w
print e," ".join(`x`+','+`y`[1:-1]for x,y in sorted(d.iteritems()))

Usage:
python FizzBuzzReverseSolver.py < Sample1.txt

Explanation (of Old approach):

In general, the program creates a list of line number and list of
words (e.g. [(0, []), (1, ['Ninja']), (2, ['Bear']), ...].
For each word in every line (starting from the end of the line):

Find the next occurrence of the word and insert the difference and the word to a predefined dictionary.
If it doesn't found, insert the biggest factor of the line number (including itself) that doesnt already exist in the dictionary and the word to the dictionary.

05AB1E, 65 bytes
|ā¤тα©+øUáεDS.uÅ¡J¦}˜ÙDεVXʒнYå}€θ0š¥θ}øí.¡н}εRεćÑRNèš]€`{',ý®>šðý

Try it online.
Explanation:
Step 1: Pair all input-lines with their corresponding value:
|            # Get all inputs as a list of strings
 ā           # Push a list in the range [1,length] (without popping the list itself)
  ¤          # Push its last/largest value (without popping)
   тα        # Get the absolute difference with 100
     ©       # Store this value in variable `®` (without popping)
      +      # Add it to each value in the [1,length]-list
ø            # Create pairs with the list of strings

Try just step 1, one builtin at a time.
Step 2: Get all unique words:
U            # Pop and store the paired-list in variable `X`
 á           # Only leave the letters of each string in the (implicit) input-list
             # (note that it'll use the entire list as input after we've used `|` once)
  ε          # Map each string to:
   D         #  Duplicate the string
    S        #  Convert the copy to a list of characters
     .u      #  Check for each character whether it's uppercase
       Å¡    #  Split at the truthy indices (while keeping them)
         J   #  Join each inner list of characters back to a string
          ¦  #  Remove the leading item, which is always an empty string
  }˜         # After the map: flatten the list of lists
    Ù        # And uniquify it

Try just step 2, one builtin at a time.
Step 3: Map each word to a list of pairs containing that word:
D            # Duplicate the list of words
 ε           # Map over each:
  V          #  Pop and store the current word in variable `Y`
   X         #  Push the paired-list `X`
    ʒ        #  Filter it by:
     н       #   Where its first item (the string)
      Yå     #   Contains word `Y`
    }        #  Close the filter

Try just step 3.
Step 4: Convert each to the step-size, and pair it with the words:
     €       #  Map over each inner list
      θ      #   And only leave the last item (the value)
       0š    #  Prepend a 0 to this list
         ¥   #  Get the deltas/forward-differences
          θ  #  And only leave the last one
 }ø          # After the map: pair each together with its word

Try just step 4, one builtin at a time.
Step 5: Fix any duplicated items (i.e. Apple & Pie both having value 95 now for the last test case):
í            # Reverse each pair
 .¡          # Then group all pairs by:
   н         #  Their first item (the value)
  }ε         # After the group-by, map over each list of pairs:
    R        #  Reverse the list of pairs
     ε       #  Map over each pair:
      ć      #   Extract head; pop and push remainder-list and first item separated
       Ñ     #   Pop this value, and get all its divisors
        R    #   Reverse this list
         Nè  #   Index the map-index into it
           š #   And prepend this value back to the list
   ]€`       # After both maps: flatten the list of lists of pairs one level down

Try just step 5, one builtin at a time.
Step 6: Print the output, including starting item:
{            # Sort this list of pairs (based on their first item, the value)
 ',ý        '# Join each pair with "," delimiter
    ®>       # Push value `®`, and increase it by 1
      š      # Prepend it in front of the list
       ðý    # Join the list by spaces
             # (after which it is output implicitly as result)

Try just step 6, one builtin at a time.

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

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


text:
Find the reference angle
This is a fairly simple question. According to this random website I found — Web Archive, a reference angle is the acute angle formed by the terminal side of the given angle and the x-axis. You have to write a program to find these.
I don't remember anything from algebra 2, what does this mean?
Angles are usually given in standard form, which is measured by placing one side of the angle and measuring to the other side, counterclockwise, like so:

This will be your input. Your output will be the reference angle of this. You can think of this as basically the smallest distance from the terminal side to the x-axis. Except it's an angle, not a distance. Here are some examples:

Clarifications

All the defaults on inputs and submissions.
Angles is in degrees.
Negative angles, non-integer angles, and angles > 360 deg are allowed.
Output in form 60 deg.
This is code-golf, so shortest code in bytes wins!

Another helpful link.
Test Cases
70      ->  70 deg
135     ->  45 deg
210     ->  30 deg
-60     ->  60 deg
91      ->  89 deg
610     ->  70 deg
-1000   ->  80 deg

What do we do on input of 90?

@ThomasKwa it would be 90 from either direction.

A short solution is abs(arcsin(sin(input)))+" deg", though I don't know which language would win (it would need to support degrees and string operations).

Is the input always an integer?

@ThomasKwa good point, no.

Since non-integer angles are allowed, you should include one in the test cases.

Pyth, 17 bytes
+hS%R180,Q_Q" deg

Coincidentally, this is equivalent to @xnor's answer.
Try it online.

Pyth, 18 bytes
+.a-%+QK90yKK" deg

Try it online.

got it down to 19 using your algo but with inline assign, feel free to use: https://pyth.herokuapp.com/?code=%2B.a-%25%2BvwK90yKK%22+deg&debug=0

@Maltysen: Thanks, found another improvement as well

Python 2, 34 bytes
lambda x:`90-abs(x%180-90)`+' deg'

Using "%d deg" string formatting would be longer because of the needed parentheses.

CJam (21 bytes)
180qd1$%z_@@-e<" deg"

Online demo

dc, 25
90?90+d*v180%-d*vn[ deg]p

Note dc uses _ as a -ve sign instead of -.
Test output:
$ for test in 70 135 210 _60 91 610 _1000; do dc -e'90?90+d*v180%-d*vn[ deg]p' <<< $test ; done
70 deg
45 deg
30 deg
60 deg
89 deg
70 deg
80 deg
$

Python 2, 35
lambda x:`min(x%180,-x%180)`+' deg'

The smaller of the angle and its negative modulo 180. Effectively converts the angle to the range from 0 to 180 and takes the distance to the closer of the endpoints. Note that -x%180 groups as (-x)%180.
Same length with string formatting for Python 3:
lambda x:'%d deg'%min(x%180,-x%180)

Mathematica, 22 31
ToString@Abs@Mod[#,180,-90]deg&

@LegionMammal978 If I just multiply it by deg, 0 deg will become 0.

Since you don't care about the output type, you can save 2 bytes like this: Row@{Abs@Mod[#,180,-90],deg}&

Pyth 25 30 bytes
Painfully uncreative solution, using trig functions. Permalink
+.R.t.a.t.t.tQ7Z3 6?%Q1Q0" deg

Any suggestions welcome.

Got it down to 28 by taking the .t calls and putting them in a fold: +.R.t.a.tF[Q7Z3)6?%Q1Q0" deg

Neat. I noticed it doesn't appear to work with a floating point input: 90.5 => 90.0 deg, though.

That's because yours doesn't either: https://pyth.herokuapp.com/?code=%2B.R.t.a.t.t.tQ7Z3+6%3F%25Q1Q0%22+deg&input=90.5&debug=0

Interesting catch. With input -60.5 => 60.5 deg but with 60.5 => 60.0 deg. Looks like an issue with Pyth -- Example using pyth/macros.py

JavaScript (ES6), 43 bytes
Similar to Sp3000's answer, though the modulo is quite lengthy due to the behaviour in JavaScript.
f=x=>90-Math.abs((x%180+180)%180-90)+' deg'

Demo
Code is rewritten in ES5 for browser compatibility:

function f(x){return 90-Math.abs((x%180+180)%180-90)+' deg'}

// Snippet stuff
console.log = function(x){document.body.innerHTML += x + '<br>'};
[70,135,210,-60,91,610,-1000].map(function(v){console.log(f(v))});

CoffeeScript, 45 bytes
f=(x)->90-Math.abs((x%180+180)%180-90)+' deg'

I assume it was a design decision by a PDP hardware engineer which is responsible for the fact that several decades later we still have very few languages which implement % sensibly.

Replacing the first 180 with (t=180) then replacing the following 180s with t would probably save a few bytes

@vihan1086 It's the same

J, 26 bytes
m=:180&|
' deg',~m@-":@<.m

Same as xnor's method.

Matlab, 44
Using an anonymous function:
f=@(x)[num2str(min(mod([x -x],180))) ' deg']

Example:
>> f=@(x)[num2str(min(mod([x -x],180))) ' deg']
f =
    @(x)[num2str(min(mod([x,-x],180))),' deg']

>> f(70)
ans =
70 deg

>> f(210)
ans =
30 deg

>> f(-1000)
ans =
80 deg

This doesn't append the ' deg' at the end though. (Did not downvote.)

@Legendre Oops. Thanks! Corrected

Scala, 40 35 Characters
(a:Int)⇒s"${90-(a%180-90).abs} deg"

Tcl, 83 bytes
proc R a {puts [expr [set a $a%360]>90?$a>180?$a>270?360-$a:$a-180:180-$a:$a]\ deg}

Try it online!

PHP, 44 bytes
Takes one command line parameter. Again PHP suffers from the same issue as JavaScript.
<?=90-abs(($argv[1]%180+180)%180-90)+' deg';

Using the canonical solution requires 53 bytes (the degrees and radians conversion takes a lot of characters):
<?=rad2deg(abs(asin(sin(deg2rad($argv[1])))))+' deg';

Doesn't PHP use . for concatenation?

@vihan1086 Yes, PHP uses .. Downvoted until it is fixed

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