text:
Sample win/loss data generator based on certain criteria
Lets say we have this existing data:
Total - 10
Won   -  7
Lost  -  3
Longest Winning Streak - 5
Longest Losing Streak - 2

Now you need to write a function which generates an array of random boolean values (true representing a win and false representing a loss) which fulfills the above criteria.
So, in this case the output can be any of the following:
0011011111
1111101100
1010011111
..........

Rules:

Solution must be function which takes in Won, Lost, Longest Winning Streak and Longest Losing Streak and returns a boolean array or string formed of a boolean array like (110011001010). It can also display output instead of returning the generated data.
You can safely assume there are no ties/draws/no-results.
This is code-golf so shortest code wins.
Input format can be in any form (Standard Input/Command-Line,etc.). And the real input format should be - <Won> <Lost> <LWS> <LLS> where <..> are place-holders or they can be separate parameters for the function.. whatever you deem best for your code. The parameter Total is unnecessary. So you needn't use it.
As far as random is concerned, you can see that in the example, there are three (and more) possible outputs. Just output any one at random.
If you have any other question, ask in the comments below.

Important - Not any answer as of now is correct.
I provide another example (this one's real data) which is possible but not working with the codes in the current answers:
Total - 171
Won   - 111
Lost  -  60
Longest Winning Streak - 10
Longest Losing Streak  - 4

Real Data:
1110110100111111010000101111111100110001100110111101101011111011011011011111111110110001111011010001101011100101111101001011011110101101001100001111101010110001111110111111

Another possible output (Basically the same, just the third and fourth digits are interchanged):
1101110100111111010000101111111100110001100110111101101011111011011011011111111110110001111011010001101011100101111101001011011110101101001100001111101010110001111110111111

What is the input format?

@Doᴡɴɢᴏᴀᴛ How could I forget that... sorry but now I've posted it.

Can we take input as an array or separate arguments?

How do you measure "random"? I could just go and construct the Array in a deterministic way with the given parameters. If you wanna keep the random requirement, you should add some rules for it.

<Total> <Won> <Lost> <LWS> <LLS> is a single string.

Why so strict on the input?

Given your edit, my program could always output the same array if its called with the same parameters multiple times?

@DenkerAffe Yes.. no problem with that. same thing is allowed as long as it is correct.

No. Winning streak will be <= total wins <= total matches. similarly losing streak will be <= total losses <= total matches.

So we have to take in all the input data or just some?

@Doᴡɴɢᴏᴀᴛ Sorry, could you elaborate... :0

@FarhanAnam In my program, I don't need to take in the Total as input as. Does it still have to be in the input? Like, can I take just 7 3 5 2 for input

The total is unnecessary really.. didn't notice that. I'll remove it.

Do all outputs need to be equiprobable? "Random" might as well be taken as "choose randomly between two possible outputs

JavaScript ES6, 83 70 63 bytes
(b,c,d,e)=>'1'[r='repeat'](d)+'0'[r](e)+'1'[r](b-d)+'0'[r](c-e)

Try it online

Now this doesn't work for (50, 20, 10, 7).

Python3 - 239 238 bytes
W,L,O,S=map(int,input().split())
from itertools import*
P=lambda A,B:len(max(A.split(str(B)),key=len))
for C in product("01",repeat=W+L):
 C="".join(C)
 if P(C,0)==O and P(C,1)==S and W==C.count("1")and L==C.count("0"):
  print(C)
  break

Well, this is way too long, but it works. Very slow. Takes the inputs from STDIN as whitespace separated in the same order as OP does.
Testcases
Input: 7 3 5 2
Output: 0011011111

Input: 15 10 15 5
Output: 0000011111111111111100000

Pyth - 33 bytes
J_E.W|n/H1hQnJmeShMd.gekrH8mO2sQY

Try it online here.
Rejection testing, very slow.

Java 7, 319 317 bytes
import java.util.*String c(int a,int b,int c,int d){String r="",w="",l="";List z=new ArrayList();int i,q=a+b-c-d;for(i=;i++<c;w+=1);for(i=0;i++<d;l+=0);for(;a---c>0;z.add(1));for(;b---d>0;z.add(0));Collections.shuffle(z);for(i=0;i<q;r+=z.get(i++));return new StringBuilder(r).insert(new Random().nextInt(q),w+l)+"";}

NOTE: The winning streak and losing streak will always be right after one-another, everything else, including their positions in the resulting string, is random.
Ungolfed & test cases:
Try it here.
import java.util.*;
class M{
  static String c(int a, int b, int c, int d){
    String r = "",
           w = "",
           l = "";
    List z = new ArrayList();
    int i,
        q = a+b-c-d;
    for(i = 0; i++ < c; w += 1);
    for(i = 0; i++ < d; l += 0);
    for( ; a-- - c > 0; z.add(1));
    for( ; b-- - d > 0; z.add(0));
    Collections.shuffle(z);
    for(i = 0; i < q; r += z.get(i++));
    return new StringBuilder(r).insert(new Random().nextInt(q), w+l)+"";
  }

  public static void main(String[] a){
    System.out.println(c(7, 3, 5, 2));
    System.out.println(c(171, 111, 10, 4));
  }
}

Possible output:
1111100011
100100010110111111110011011100101111011010110011011101111010010010101111101111000010010000110100010111001100100110010011101100111111111111110110110101011100111111111100001011111000111011111010010001010001100111110011111011011011101010101011101011011101101001001100100101100111111101

R - (I don't know how to calculate bytes)
 a <- read.csv("a.csv")
 b <- seq(1,1, seq.length = a$3)
 a$1 <- a$1-a$3
 c <- seq(0,0, seq.length = a$4)
 a$2 <- a$2 - a$4
 append(b,c)
 d <- a$1 + a$2
 while(d >= 0){append(b,c(1,0)); d <- d-2}
 d

where a.csv is a file with the four inputs separated by commas. This program will output a long string of 1's (for the win streak), and then a long string of 0's for the loss streak, and finally a long string of 0,1 for the rest of the games.


text:
Find the nth base-b digit of (b^k-1)^-2
Task
Your task is simple. Write a program or function which takes three positive integer arguments \$n\$, \$k\$, and \$b\$ in any order, such that \$2 ≤ b ≤ 36\$, and returns or outputs the nth (1-indexed) base-\$b\$ digit after the decimal point of the rational number (\$b^k-1)^{-2}\$.
The output must be correct for \$n\$ and \$b^k\$ up to the largest integer value your language of choice can natively represent. This will most likely mean that you cannot depend on built-in floating point representations to exactly represent the base-\$b\$ expansion of the number.
Fortunately, this class of numbers has a rather nice property [Spoiler Alert!]: https://www.youtube.com/watch?v=daro6K6mym8
Rules

Base conversion built-ins are permitted.
Built-in spigot functions capable of indexing digits of exactly represented real numbers are forbidden.
The digits for base \$b\$ are the first \$b\$ symbols in the string 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ or alternately 0123456789abcdefghijklmnopqrstuvwxyz. Your choice.

Winning
This is code golf. Shortest solution in bytes wins.
Test Cases
(You need not be able to correctly handle all of these if \$n\$ or \$b^k\$ overflows your integer datatype.)
Input (n,k,b)               Output
9846658,3,31                5
789234652,4,10              4
4294967295,17,2             1
4294967254,72,15            B
137894695266,3,30           H
184467440737095595,6,26     L
184467440737095514,999,36   T

Is it a part of this challenge to watch the 10-min video and find out what that nice property is? :-)

Not necessarily...you could look at a few of those numbers and figure out the property for yourself. I would definitely encourage this method. Hence the spoiler alert.

IMO, it'd probably be better to standardize the n,k,b variables such that testing them, your input is identical.

I found a bug in my code. It cost me 10 bytes to fix it :-(

You still win by default.

APL (Dyalog Extended), 31 bytes
(⎕D,⎕A)⊃⍨⊃⎕⌽¯1⌽,⍉⎕(⊣⊤⍳⍤*~*-2⍨)⎕

Try it online!
A full program that takes numbers from stdin in the order of k, b, n. n being 1-based cost me 3 bytes ¯1⌽.
How it works
The main mathematical trick is well explained in Neil's answer. The gist is that the repeating part of the base-b representation consists of length-k base-b digits of 0..b^k-1, except b^k-2.
This answer implements it very literally: list all repeating base-b digits, cyclically fetch nth digit from it, and convert it to 0-9A-Z. Cyclic indexing uses ngn's trick.
⎕(...)⎕     ⍝ Take k (the right) and b (the left) from stdin
  ⍳⍤*~*-2⍨  ⍝ Create a list of 0..b^k-1, and remove the number b^k-2
  ⊣⊤        ⍝ Convert these numbers into base-b digits into columns
,⍉          ⍝ Transpose and flatten to get the repeating base-b digits
⊃⎕⌽¯1⌽      ⍝ Take n from stdin and get the nth digit cyclically
(⎕D,⎕A)⊃⍨   ⍝ Convert the number to the corresponding char in 0-9A-Z

ah so you're the one that upvoted the question out of nowhere

ES7, 59 bytes
(n,k,b)=>(1+!(n/k%(d=b**k-1))+d+--n/k%d).toString(b)[n%k+1]

ES6-compatible version for people who don't have Firefox Nightly:
(n,k,b)=>(1+!(n/k%(d=Math.pow(b,k)-1))+d+--n/k%d).toString(b)[n%k+1]

Explanation (possibly the same as in the video; I haven't watched it):
I start with the simple case of (b-1)-1 in b-ary notation. Obviously b-1 does not divide 1, so we add an extra zero after the b-ary point. 1.0 divided by b-1 is 0.1 remainder 0.1. This continues in the obvious manner to give (b-1)-1 as being 0.111... in b-ary notation.
(bk-1)-1 is not much harder; the only difference is that we have to add k extra zeros before we can divide. We then have 1.00...00 [k zeros] divided by bk-1 is 0.00...01 remainder 0.00...01 [k-1 zeros]. This obviously continues to give (bk-1)-1 as being 0.00...0100...0100... [k-1 zeros each time] in b-ary notation.
To form (bk-1)-2 it merely suffices to divide (bk-1)-1 itself by bk-1. Again we consider k digits each time. The first k digits are just 00..01 which obviously don't divide by bk-1, so the first k digits of the result are 00..00. The next k digits are of course also 00..01 so we divide bk+1 by bk-1 giving 1 remainder 2. Considering the next k digits we divide 2bk+1 by bk-1 giving 2 remainder 3. At each step we have mbk+1 = m(bk-1)+m+1. This continues until we reach (bk-3)bk+1 which divides by bk-1 giving bk-3 remainder bk-2. At this point (bk-2)bk+1 is equal to (bk-1-1)(bk-1+1)+1 which can be written as (bk-1)2-12+1 or simply (bk-1)2, which therefore divides exactly by bk-1.
We therefore have managed to divide the first k(bk-1) digits of (bk-1)-1 by bk-1 exactly, and the sequence therefore repeats at this point. In effect, (bk-1)-2 is formed by concatenating all the (zero-padded) k-digit numbers from 0 to bk-3, plus bk-1 itself, and then repeating.
My solution divides n-1 by k and then reduces modulo bk-1 to find the appropriate k-digit number. If n is an exact multiple of k(bk-1) it adds 1 to the number because the last k-digit number is bk-1 itself. Having found the number it then adds bk, which has the effect of forcing the base conversion to generate any required leading zeros. The appropriate digit of the converted number is then returned.

what do i need to do to test this?

@quintopia Does http://meta.codegolf.stackexchange.com/a/8252/17602 help?

Okay, it tests fine. I wish more languages had an equivalent to that toString!

Python 2, 110 bytes
n,k,b=input()
n=~-n%(k*b**k-k)
print"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[(n/k+(n/k+2==b**k))/b**(k-1-n%k)%b]

Maybe answering it myself (poorly) will bring this EASY question some more attention. Usually easy questions get more answers...

source: Stack Exchange

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/

sort: votes


text:
Help me Open the Box
I have an ASCII-art box and I need a program to open it.
Examples
Input:
-------
|     |
|_____|

Output:
      /
     /
    /
   /
  /
 /
/
|     |
|_____|

Specification

The first line will only consist of -, at least 3 of them
The middle rows will start with | have spaces, and end with |

All the middle rows will be the same

The last row will start with | have _ and end with a |
All rows will be the same length

Opening the box:

Each - should be replaced by a / in ascending lines and position.

As opposed to the game "Shut the Box"?

Is a leading newline acceptable?

@ETHproductions errr, uh.... sure, why not ¯\(ツ)/¯

Can I read input from a file?

cough

@CᴏɴᴏʀO'Bʀɪᴇɴ sure, why not ¯\(ツ)/¯;

The lid becomes twice as long when opened?  Oh well, blame ASCII art.

Can I require a training newline in the input? MATL reads each line as a separate input, so an empty line (i.e. a newline) would mark the end

@LuisMendo yeah, just state that in your answer

What's in the box?

@WillihamTotland  Something shiny

This would be 13 bytes in Crayon, just beating all the other entries: '<->+'"↗/%1"r That is, match all the hyphens and store the number of matched hyphens in %1, then replace it with a string of %1 slashes pointing north-east.

Actually, that would be with implicit input, which I've decided against. Fortunately, there's a 10-byte version with explicit input: Ll`/*↗q↩Eq Mind if I post it as non-competing?

@ETHproductions if there is a working interpreter and it complies with the rules then Yes.

There's not a working interpreter, so I guess not then. Doesn't matter; when I do make the interpreter (soon, hopefully), I'll post the answer.

@ETHproductions you can post it now I guess:)

CJam, 14 bytes
l,{N'/@S*}%W%q

Try it online!
How it works
l               Read the first line from STDIN.
 ,              Compute the line's length. Result: L
  {      }%     Map; for each I in [0 ... L-1]:
                  (implicit) Push I.
   N              Push a linefeed.
    '/            Push a slash.
      @           Rotate I on top of the stack.
       S*         Turn I into a string of I spaces.
           W%   Reverse the resulting array of strings and characters.
             q  Read the remaining input from STDIN.

JavaScript ES6, 57 bytes
s=>s[r="replace"](/-+/,s=>s[r](/-/g,`
$'/`))[r](/-/g,' ')

Outputs a leading newline. Works by taking the row of -s and converting them into a triangle, then replacing the -s with spaces.
Edit: Saved 5 bytes thanks to @edc65.

+1 I learned something new ($'). Instead this old trick can save 4 bytes for you: f=s=>s[R='replace'](/-+/,s=>s[R](/-/g,"\n$'/"))[R](/-/g,' ')

@edc65 Thanks, I actually make it 5 bytes; also thanks for fixing my typo (as you might have guessed I develop with \n and convert afterwards).

Pyth, 16 14 bytes
j+_m+*;d\/Uz.z

Explanation
   m      Uz   - [V for d in range(len(input()))]
    +*;d\/     - " "*d + "/"
  _            - ^[::-1]
j+          .z - "\n".join(^+rest_of_input())

Thanks @FryAmTheEggman for new algorithm!
Try it here.

pb (NONCOMPETING), 125 bytes
^w[B!0]{>}w[B!45]{<w[B=10]{t[T+1]b[0]}}v[X]vw[T!0]{vb[124]<[X]b[124]>w[B=0]{>}t[T-1]}w[X!1]{<b[95]}<w[B!0]{^}w[Y!-1]{b[47]>^}

The version of pbi that you need to run this answer is newer than the question. It would have worked in older versions except that I never got around to allowing newlines in input. Oh well.
First, this determines the height of the box by counting newlines in the input. Once it knows that, it goes to the Y location of the right side of the box, goes down to where it needs to be and draws the walls and floor, finishing with the lid.
Check out this fun animation!

The long pause is the brush going over the input.
Ungolfed:
^w[B!0]{>}                # Go to the end of the input
w[B!45]{<                 # Head left until hitting a hyphen
    w[B=10]{                # For each newline on the way:
            t[T+1]                # Count it
            b[0]                  # Delete it
    }
}

v[X]                      # Move down as far as it is right + the number of \n
v                         # ...plus one

w[T!0]{                   # While the counting variable is nonzero:
    vb[124]                 # Go down and draw a pipe
    <[X]b[124]              # Draw a pipe on the left as well
    >w[B=0]{>}              # Go back to the right side
    t[T-1]                  # Decrement variable
}

w[X!1]{<b[95]}            # Draw the bottom of the box
<w[B!0]{^}                # Go up the left wall
w[Y!-1]{b[47]>^}          # Go up and right, drawing the lid

+1 for the cool animation. How did you create it?

@Gowtham I would guess you record your screen and crop the video. Then, take that and convert it to a GIF. Of course, just guessing, I don't know the actual method

@awesomebing1 you got it

Retina, 34 20 bytes
-(?=(-*))¶?
$1/¶
-

In the first step every - is substituted with the -'s following it, a / and a newline.  The newline at the end of the original first line is deleted. In the second step we change the new -'s to spaces which results in the desired output.
Try it online here.

Just for the fun of it, it's also possible in a single stage: http://retina.tryitonline.net/#code=LSg_PSgtKSopwrY_CiQjMSQqIC_Ctg&input=LS0tLS0tLQp8ICAgICB8CnxfX19fX3w (same bytes though)

If you eat the first newline separately you can use $%' to capture the trailing -s which saves you 5 bytes: Try it online!

MATL, 14 15 bytes
' /'jnXyPQ)`jt

Input should have a trailing newline.
Try it online!
Explanation
' /'       % push string (will be indexed into to generate the open lid)
jn         % read first line of input and push its length
Xy         % identity matrix with that size
P          % flip vertically
Q          % add 1. Now the matrix contains 1 and 2, to be used as indices
)          % index into string. Produces a 2D char array for the lid
`          % do-while loop
  j        %   push input line
  t        %   duplicate. Truthy if nonempty
           % implicitly end loop. The loop condition is the top of the stack,
           % that is, the input line that has just been read.
           % This is truthy if non-empty; and in that case another line will
           % be read in the next iteration.
           % implicitly display stack contents, bottom to top

Japt, 28 26 25 22 18 17 bytes
Ur-@"
{SpUa- -Y}/

Test it online!
Outputs a leading newline, which is acceptable according to the OP.
How it works
Ur-@       // Replace each hyphen X in the input and its index Y with this function:
"          //  Start a string that contains a newline.
{        } //  Insert here:
   Ua- -Y  //   Take the index of the last hyphen in the input, subtract Y,
 Sp        //   and return that many spaces.
/          //  Finish off the string with a slash.

This would be 4 bytes shorter if the hinge is allowed to be on the right edge of the box:
Ur-@"
{SpY}\\

JavaScript (ES6), 66
b=>([a,t]=b.split`-
`,[...a+0].map(_=>(t=l+`/
`+t,l+=' '),l=''),t)

TEST

f=b=>([a,t]=b.split`-\n`,[...a+0].map(_=>(t=l+`/\n`+t,l+=' '),l=''),t)

var box = `-------
|     |
|_____|`

console.log=x=>O.textContent=x

console.log(f(box))

Java 8, 158 118 bytes
This is just a start, but hey, FGITWFTW.
n->{String o="";int z=n.lastIndexOf("-"),i=z;for(;i-->0;o+="/\n")for(int y=i;y-->0;o+=" ");return o+n.substring(z+2);}
Expects input as a string, returns the box.

Bash, 85 84 79 characters
(Pure Bash version, no external commands used.)
r(){
a="${a/-
/
$s/
}"
s+=\
[[ $a = -* ]]&&r
}
mapfile a
r
IFS=
echo "${a[*]}"

Outputs a leading newline.
Sample run:
bash-4.3$ bash open-the-box.sh <<< $'-------\n|     |\n|_____|'

      /
     /
    /
   /
  /
 /
/
|     |
|_____|

echo is an external command - /usr/bin/echo ;)

The echo executable exists for the operating system's conformance with the standards. Nowadays that one is only used if portability is important, as that one is up to the standard, But most modern shells have their own builtin echo which is used by default: http://pastebin.com/RnxhweBv @Levi, if you rename/move your /usr/bin/echo, my code will still work.

(it was a joke....)

Oh. Ok. Sorry, I already met people earlier who claimed the same, but seriously.

Perl, 61 54 33 + 3 = 36 characters
s^-^" "x(length$')."/\n"^ge&chomp

Run it as
perl -ple 's^-^" "x(length${chr 39})."/\n"^ge&chomp' closed_box_file

Each - in first line is replaced by a string that is a result of concatenation of some number of , / and \n. ${chr 39} evaluates to perl's (in)famous $' aka $POSTMATCH special variable. Lastly, chomp gets rid of the trailing newline character that was added for the last - character.
Thanks to @manatwork for saving 7 + more characters.
Bonus - s^-^" "x$i++."\\\n"^ge&&chop opens the box from the right edge in 29 + 3 characters :). Run it as:
gowtham@ubuntu:~$ cat a
----
|  |
|__|
gowtham@ubuntu:~$ perl -plE 's^-^" "x$i++."\\\n"^ge&&chop' closed_box_file
\
 \
  \
   \
|  |
|__|

@manatwork Only first line contains -, so yes, I can golf it even more. Thanks!

$.==1 → $.<2, &&chop → &chop, remove the extra pair of parenthesis around length, count {chr 39} as 1, as it not is only needed by the command line version due to shell's syntax: $.<2&&s^-^" "x(length$')."/\n"^ge&chop + 2 character for command line options = 40 according to my counting. http://pastebin.com/iDhUs9XX

@manatwork Actually, $.==1 or $.<2 can be eliminated because only first line contains -

Yes, I saw what you did there. And I was amazed. By the way, you can use a literal line wrap in the code instead of \n.

Doh. Found a shorter one: s^-^$'=~y/-/ /r."/\n"^ge&chomp

Pyth, 26 23 bytes
jXK.z0jm+*\ t-lhKd\/lhK

Yuck. Can definitely be shorter; still working on it.

Python 3, 1̶7̶0̶ 88 bytes
Here is my short(er) code:
EDIT: Now 82 bytes Shorter With @Dennis 's Code Edit!
f=open('f.txt')
d=len(f.readline())-1
a=f.read()
while d:d-=1;print(' '*d+'/')
print(a)

Python 3, 421 bytes
Alternatively, just for fun, you could use one that opens it slowly:
import time
import os
f = open('f.txt', 'r')
e = f.readline()
a = f.read()
d = len(e)
c = 0
t = e + a
g = ''
clear = lambda: os.system('cls')
while c <= d - 1:
    clear()
    print(("\n" * ((d - 1) - (c))) + t)
    c += 1
    e1 = e[0:(d - c)  -1]
    e2 = e[(d - c):len(e)]
    e1 += '/'
    e2 = ' ' * len(e2)
    y = (' ' * len(e1)) + '/' + '\n'
    g += y
    t = (g + e1 + e2 + '\n' + a)[d:len(g + e1 + e2 + '\n' + a)]
    time.sleep(0.2)
f.close()

To use either, you must create a text file in the same directory containing an ascii box of any width or depth called 'f.txt'. It will then open that box.

You can shorten this further by shortening variables to single letters and removing a lot of the whitespace between operators. For general tips for golfing in Python, see here.

Why on earth do you need time? This question only asks for a single output.

Like I said, my interpretation of this puzzle was slightly off and if you output it it'll show you more than the question asked for.

Okay, I have added a simplER answer which does exactly what the question says as I now understand it. It's not pretty but it works. My alternate code is for anyone awesome enough to want to watch it open

A few minor changes bring your byte count down to 81 (reading from STDIN).

Thanks Dennis. The thing is i didn't understand the question in the first place as I thought it was asking for every stage (hence the second code which im sure could be condensed also). I appreciate the improvement.

Feel free to incorporate my suggestions in your post. Collaboration is quite common on PPCG. (I didn't see your reply earlier. If you include @Dennis, I will get a ping.)

@Dennis, thanks! also, I thought so but wasn't sure

Python3, 76 bytes
f=open(0)
w=len(f.readline())
while w:w-=1;print(' '*w+'/')
print(f.read())

Get the length of the first input line.
Print lines of / preceded by a decreasing number of spaces.
Push the rest of stdin straight to stdout.

EDIT: I've just noticed that my code is almost identical to @Dennis' comment edit of @Monster's shorter Python3 code, the only difference being print the remainder of stdin directly instead of store it in a variable.  Great minds!

Canvas, 6 4 bytes
ｊＬ／ｏ

Try it here!
Explanation:
j      remove 1st line of the input
 L     get the width of the remaining input
  /    push a diagonal of that size
   o   and output that diagonal
       and implicitly output the remaining input

Python 2, 100 bytes
def o(b):
 m=b.split('\n')[1:]
 print"\n".join(["/".rjust(i)for i in range(len(m[0]),0,-1)]+m)

Defines a function o that takes a string as its input. (Full program wasn't specified in the question).

PowerShell, 55 bytes
$d,$b=$args-split"`n";($d.length-1)..0|%{" "*$_+"/"};$b

Takes input $args as a string, -splits on newlines  `n (reference link), stores the first line into $d (as a string) and the remaining into $b (as an array of strings). We then loop from the length of the first line (minus 1) to 0 and each iteration output that number of spaces plus a /. Finally, output $b (the rest of the input string) which by default will output one per line.
Example Run
PS C:\Tools\Scripts\golfing> .\help-me-open-the-box.ps1 "----`n|  |`n|__|"
   /
  /
 /
/
|  |
|__|

Split on the linefeed instead of `n, 54 bytes

JavaScript (Node.js), 56 bytes
a=>a[b="replace"](/-+/,c=>c[b](d=/-/g,`
$'/`))[b](d,' ')

Try it online!
Should be written as a comment of @Neil's answer but I can't create comments yet

Hello and welcome to PPCG. I assume you mean Neil's answer which you have golfed further. You may want to add a link to their answer and correct the author's name to give credit.

@JonathanFrech thanks, done

05AB1E (legacy), 9 bytes
g'/1.Λ|»»

Try it online! (legacy-only)
How it works
g'/1.Λ|»» – Full program. Takes input from STDIN.
g         - Length. Only takes the first line into account.
 '/       – Push a slash character, "/".
   1.Λ    – And diagonally up-right, draw a line of slashes of the given length.
      |»  – Push the remaining inputs (all other lines) joined on newlines.
        » – Then join the stack on newlines.

Why legacy-only? This works in rewrite.

Charcoal, 14 bytes
↙Ｌ§⪪θ¶⁰Ｍ→✂⪪θ¶¹

Try it online (verbose) or try it online (pure).
Explanation:
Split the input by newlines, take the length of the first line, and print a line of that length from the Top-Right to Down-Left:
Print(:DownLeft,Length(AtIndex(Split(q,"\n"),0)))
↙Ｌ§⪪θ¶⁰

Move once to the right:
Move(:Right)
Ｍ→

Split the input by newlines again, and remove the first item, and print what's left implicitly:
Slice(Split(q,"\n"),1)
✂⪪θ¶¹

(NOTE: Putting the input split by newlines in a variable (since I do it twice above) is 1 byte longer also 14 bytes by using a slightly different method (thanks to @Neil):
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ Try it online (verbose) or try it online (pure)).

If you reverse the input split by newlines you can pop off the first line which then brings you back down to 14 bytes: Try it online!

Vyxal, 16 bytes
L:£(&‹¥\/꘍,)□Ḣ⁋,

Try it Online!

JavaScript ES6, 106 bytes
q=>(q=q.split`
`,n=q[0].length,eval('for(i=0,r="";i<n;i++)r+=" ".repeat(n-i-1)+"/\\n"'),r+q.slice(1).join`
`)

Simple enough: getting the length of the first line, creating a spaced-triangle with trailing /, and adding that to the original, sliced and joined.
Test it out! (ES6 only :()

F=q=>(q=q.split`
`,n=q[0].length,eval('for(i=0,r="";i<n;i++)r+=" ".repeat(n-i-1)+"/\\n"'),r+q.slice(1).join`
`)
function n(){q.innerHTML=F(o.value)}
o.onkeydown=o.onkeyup=o.onchange=o.onkeypress=n;
n();
*{font-family:Consolas,monospace;}textarea{width:100%;height:50%;}#q{white-space:pre;}
<textarea id=o>----
|  |
|__|</textarea>

I see you solved the XKCD problem using formatting. Clever.

.repeat(n-i-1) => .repeat(n+~i)

PHP, 127 characters
$s=$argv[1];$l=strlen(strtok($s,"\n"));for($i=0;$i<$l;$i++)$s=preg_replace("/-/","\n".str_repeat(" ",$l-$i-1)."/",$s,1);echo$s;

Ungolfed version :
$s=$argv[1];
$l=strlen(strtok($s,"\n"));

for($i=0;$i<$l;$i++){
    $v="\n".str_repeat(" ",$l-$i-1)."/";
    $s=preg_replace("/-/",$v,$s,1);
}
echo $s;

There is a typo in your code: you missed the sigil of $argv. There are a couple of minor tricks you could apply: $l=strlen(strtok($s=$argv[1],"↵"));while($l)$s=preg_replace("/-/","↵".str_repeat(" ",--$l-$i)."/",$s,1);echo$s; (Use a literal newline in your code where is “↵”: http://pastebin.com/36t2fb0P )

Python 2.7, 120 122 chars
Needs a file f with the original/closed box, output is the opened one. Cheers to @Monster for the idea... will try to figure out multi-line input later and see if it's shorter.
for l in open('f').readlines():
 if l[1]==('-'):
  for x in range(1,len(l)):print(' '*(len(l)-x+1)+'/')
 else:print l[:-1]

Edit

just noticed that the leftmost / has a space in front; +2 bytes

Ruby, 59 characters
(57 characters code + 2 characters command line options.)
s=""
$_=$_.chars.map{(s<<" ")[1..-1]+?/}.reverse*$/if$.<2

Sample run:
bash-4.3$ ruby -ple 's="";$_=$_.chars.map{(s<<" ")[1..-1]+?/}.reverse*$/if$.<2' <<< $'-------\n|     |\n|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|

Gema, 51 49 31 characters
-\P/-+/=@subst{-=\\ ;$1}/\n
-=/

Sample run:
bash-4.3$ gema -e '-\P/-+/=@subst{-=\\ ;$1}/\n;-=/' <<< $'-------\n|     |\n|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|

Bash, 129 characters
Requires a file called a with the closed box, outputs to stdout.
for i in $(seq `cat a|awk 'NR==1{print length($1)-1}'` -1 1);{ for j in `seq 1 $i`;{ printf " ";};echo "/";};echo "/";tail -n2 a

It might be possible to make it shorter by using sed and using stdin and piping.

Nice first golf answer. Some simple syntax change suggestions: for i in $(seq \awk 'NR<2&&$0=length-1' a` -1 1);{ for j in `seq 1 $i`;{ printf \ ;};echo /;};echo /;tail -n2 a`

Awk, 47 46 characters
(44 characters code + 2 characters command line option.)
/-/{OFS=RS;for(i=NF;i;i--){$i=s"/";s=s" "}}1

Sample run:
bash-4.3$ awk -F '' '/-/{OFS=RS;for(i=NF;i;i--){$i=s"/";s=s" "}}1' <<< $'-------\n|     |\n|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|

Python, 125 bytes (110 without box)
i="\n---\n| |\n|_|"
l,b,r=i.count("-"),i.split('\n'),range
for x in r(1,l):print" "*(l-x)+"/"
for x in r(2,len(b)):print b[x]

If anyone has any idea how to shorten it, please let me know!

K (ngn/k), 18 bytes
{(" /"@|=#*x),1_x}

Try it online!

05AB1E (legacy), 12 bytes
€ðƶ€¦'/«R|«»

Try it online!

brainfuck, 118 bytes
-->+[<+>,----------]>>>++++[<++++++++>-]>-[<+>-----]++++++++++<----<<<<[[>+>+<<-]>[<+>-]>[>.<-]>>.>.[<]<<-]>>>>.>.[,.]

Try it online!
(You will have to check the "!" box to allow for everything after the ! to be considered input)
It is the same length as the Java answer, so I'm happy. Any help golfing it to be shorter than the Java answer would be greatly appreciated.
Explanation
-->+[<+>,----------]                                 Counts the number of characters until a linefeed
>>>++++[<++++++++>-]>-[<+>-----]++++++++++<----<<<<  Initialises the next 3 cells to 32 (space), 47 (/) and 10 (linefeed)
[                                                    Starts a loop on the length of the first line
[>+>+<<-]>[<+>-]>[>.<-]>>.>.[<]<<-                   Prints a space for every character and then prints a slash, a linefeed and then takes one from the number of characters, and repeats until that value is equal to zero
]                                                    Ends the loop
>>>>.>.[,.]                                          Prints the last slash, a newline and then the rest of the input

Brain-Flak, 144 bytes
({()<{}({}[((()()){}()){}])>}{}){(({}[()])<>){({}[()]<(((((()()){}){}){}){})>)}{}(((((()()()){}){}){}){}[()])(((()()){}()){})<>}{}<>{({}<>)<>}<>

Try it online!
The longest answer yet.
Explanation
({()<{}({}[((()()){}()){}])>}{}) #count the dashes "n"
{ #while N != 0
  (({}[()])<>) #copy --N to second stack for the next line
  {({}[()]<(((((()()){}){}){}){})>)}{} #indent
  (((((()()()){}){}){}){}[()]) # '/'
  (((()()){}()){}) # newline
  <>
}{}
<>{({}<>)<>}<> #copy output to main stack

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

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


text:
Test if a point is in an Icosahedron
Take as input 3 floating point numbers, which represent the x, y, z coordinates of a point. Return a truthy or falsey value indicating whether the point is inside the regular icosahedron centred at the origin, with top and bottom vertices at (0, 0, 1) and (0, 0, -1), and with one of the upper ring of middle vertices in the +X+Z quarterplane. Input/output formats can be anything reasonable. To allow for rounding error, Your code does not have to give correct answers for points within 10^-6 units of the boundary
Example inputs / outputs:
0, 0, 0 => true
1, 1, 1 => false
0.7, 0.5, -0.4 => true
-0.152053, -0.46797, 0.644105 => false
-0.14609, -0.449618, 0.618846 => true

To be absolutely clear on the orientation of the icosahedron, the coordinates of the vertices are approximately
{{0., 0., -1.},
{0., 0., 1.},
{-0.894427190999916, 0., -0.447213595499958},
{0.894427190999916, 0., 0.447213595499958},
{0.723606797749979, -0.5257311121191336, -0.447213595499958},
{0.723606797749979, 0.5257311121191336, -0.447213595499958},
{-0.723606797749979, -0.5257311121191336, 0.447213595499958},
{-0.723606797749979,  0.5257311121191336, 0.447213595499958},
{-0.27639320225002106, -0.85065080835204, -0.447213595499958},
{-0.27639320225002106,  0.85065080835204, -0.447213595499958},
{0.27639320225002106, -0.85065080835204, 0.447213595499958},
{0.27639320225002106,  0.85065080835204, 0.447213595499958}}

Scoring is standard code-golf; the fewest bytes wins.

Nitpick: Standard code golf is fewest bytes, not fewest characters. The latter option allows compressing code by using all 2^32 Unicode characters.

Ruby,87
->c,z{a=g=3-5**0.5
10.times{x=(c*="i".to_c**0.4).real
z=-z
a&&=z<1+x*g&&x*4>g-4+g*z}
a}

An anonymous function taking the x and y coordinates as a complex number and the z coordinate as a real. (The question says "any reasonable" format which is a bit vague. If the format is not acceptable I can change it.)
Explanation
Below you can see a view looking down the z axis at the icosahedron's vertices. (for simplicity I have just drawn 2 pentagons that are perpendicular to the z axis.)
I have labelled all the points with positive z with their approximate coordinates. I have given the exact coordinates sqrt 0.8, 0, sqrt 0.2 for the point with positive z that lies in the xz plane (y=0), and I have also labelled the opposing point.
It can be seen that there is an edge parallel to the y axis whose equation is approximately z=0.4472, x=-0.7236. This edge is common to two faces of the icosahedron. I will describe these as a polar face and an equatorial face.
The equation of the polar face is z=1+x*g where g=3-sqrt(5) (this value was arrived at by studying Wikipedia and Wolfram Alpha, plus a bit of my own maths.) So z must be less than 1+x*g if the point is inside the icosahedron.
The equation of the equatorial face is x*4=g-4+g*z so x*4 must be greater than
g-4+g*z if the point is inside the icosahedron.
We could rotate these faces through 72 degrees to test if the point is inside the icosahedron, but it is easier to rotate the point about the origin. In order to cover both the top and bottom of the icosahedron, the symmetry operation applied to the point is a rotation of 36 degrees combined with a reflection in the xy plane (flip the z axis.) This operation is applied 10 times to cover all possibilities.

Ungolfed in test program
f=->c,z{
  a=g=3-5**0.5                    #g is slope of polar face. It is truthy, so can also be used to initialize a
  10.times{                       #generate 10 images of the point
    x=(c*="i".to_c**0.4).real     #rotate the point 36 degrees, assign the real value to x
    z=-z                          #flip the z axis
    a &&= z<1+x*g && x*4>g-4+g*z  #check the point is inside the two test planes and update a if necessary
  }
a}                                #return a true or false

p f["0+0i".to_c,0]                     #true
p f["1+i".to_c,1]                      #false
p f["-0.152053-0.46797i".to_c,0.644105]#false
p f["-0.14609-0.449618i".to_c,0.618846]#true

p f["-0.8944+0i".to_c,-0.4472]         #true, just inside vertex
p f["-0.8944+0i".to_c,0.4472]          #false, outside midpoint of an edge
p f["-0.8945+0i".to_c,-0.4473]         #false, just outside vertex

Taking 2 of the coordinates as a complex number strikes me as reasonable, and also very clever :)


text:
Reverse-Engineer the N-Bonacci sequence[s]
EDIT: I will be accepting an answer Monday, 2/15/2016. May the bytes be ever in your favor!
In his "Print the N-Bonacci Sequence" challenge, @DJMcGoathem describes the N-bonacci sequences, wherein the previous N numbers are summed, instead of the traditional 2 of the Fibonacci sequence (said to be the "duonacci sequence"). He then asked to take two inputs, X and N, then output the Xth N-nacci number.
I propose the opposite.
Given a sequence, output which N-nacci sequence it is a subset of. I say "subset of" because:

A) these sequences are infinite
B) if given the start of the sequence, you could just count the number of leading 1s

In the case that it could belong to multiple N-nacci sequences, chose the lowest one.
In the case that it does not belong to any N-nacci sequence, then your program may do anything other than print something that could be mistaken for output. These behaviors include (but are not limited to): infinite loop, error, crash, delete itself (*cough cough* vigil *cough cough*), or create a black hole (as long as this black hole does not produce anything that could be mistaken for valid output).
For the sake of this challenge, these sequences start with 1. This means any N-nacci sequence starts with N ones. Furthermore, N must be a positive integer. So no -1-nacci, etc.
Test cases:
1,1,1 -> 1
49, 97 -> 7
55, 89, 144 -> 2
1 -> 1
6765 -> 2
12, 23, 45, 89 -> 12
100, 199 -> 100

create a black hole (as long as this black hole does not produce anything that could be mistaken for valid output). My, the spirals of the black hole are converging to the golden ratio! It must be valid output for a duoacci sequence!

@CᴏɴᴏʀO'Bʀɪᴇɴ It may be a beautiful golden ratio, but Do NOT go near the black hole! https://www.youtube.com/watch?v=TTUQyEr-sg0

Oh my, this is much harder than I originally thought...

@mbomb007 what's the difference between positive integers and natural numbers?

@NotthatCharles Positive integers is a clearer way to say it if you're excluding zero, because natural numbers includes zero.

@mbomb007 ah.  I thought 1 was the first natural number.  I must have been thinking of counting numbers

@NotthatCharles It's actually somewhat ambiguous, but I include zero. See wikipedia.

Ruby, 94
I'm quite surprised how far I've been able to golf this within the same algorithm!  I started with over 200!
->a{1.step.find{|s|x=[1]*(s+z=a.size)
x<<x[-s,s].inject(:+)while x.max<a.max&&s>1
x[-z,z]==a}}

Ungolfed:
l=->a{
    # ooh! a built-in infinite incrementer!
    1.step.find{|s|
        # if n == 1, z is important, otherwise s.
        x=[1]*(s+z=a.size)
        ## add the next nacci number until we hit or overshot max.
        ## if s == 1, we don't increment, so don't bother
        x<<x[-s,s].inject(:+)while x.max<g&&s>1
        # eval to true if there's a match, false if not
        x[-z,z]==a
    }
}

How does x=[1]*(s+z=a.size) work exactly?

@Cyoce If n == 1, then we will never increment, so we need an array of 1's however long the input is.  If n > 1, then we need at least n 1's for the sequence.  So s+a.size covers n == 1 for any length of a, and it covers the beginning of any other sequence so we can just start adding s digits off the batt.  Does that make sense?

@Cyoce and if you're asking a different question, in Ruby, [1]*number gives an array of 1's with length number.  So x=[1]*(s+z=a.size) assigns a.size to z, then assigns to x an array of 1's length s+z.

APL (Dyalog Unicode), 46 bytes
{∧/0<⍵:⊃⊃⍸A⍷↑{⍵((+/↑),⊢)⍣{</+/¨A⍵}⍵⍴1}¨⍳⊃A←⌽⍵}

Try it online!
Anonymous prefix function, taking a vector of integers.
How?
∧/0<⍵:   ⍝ If the given sequence contains any non-positive integers, then return nothing. Otherwise...
A←⌽⍵     ⍝ Set A to be the reverse of the given sequence
{...}¨⍳⊃ ⍝ For each n in 1 to last element of given sequence, we generate the n-bonacci sequence in reverse order:
 ⍵⍴1       ⍝ Initialize a vector of n 1s (first n terms of the n-bonacci sequence)
 ⍣         ⍝ Do:
 ⍵((+/↑),⊢)  ⍝ Prepend the sum of the most-recent (first) n elements of the vector to the rest of the vector
           ⍝ While
 {</+/¨A⍵}   ⍝ the sum of the n-bonacci sequence generated so far is less than the sum of A
               ⍝ (this doesn't terminate prematurely because:
               ⍝   For n=1, this produces k+2 1s if A consists of k 1s
               ⍝     Otherwise, worst-case is that A has 1 element
               ⍝   For n=2, F_0+F_1+F_2 ... + F_{k-2} = F_k (identity)
               ⍝     F_0 + ... F_{k-1} > F_k, and APL terminates the ⍣-loop in the next step,
               ⍝     after F_k generated
               ⍝   For n>2, F_0+F_1+F_2 ... + F_{k-2} < F_k, so an excess of terms are generated
               ⍝ )
↑        ⍝ Mix to form a matrix, where the n-th row is the n-bonacci sequence
⍸A⍷      ⍝ Find the (row, column) positions of A in the matrix
⊃⊃       ⍝ Take the row of the first one (which would have minimum n)

This really should have gotten a 200-rep bounty, but I made a mistake and only put 100 on it. I'll create a 100-rep bounty for one of your other answers.

Python 2, 176 bytes
def r(n,x):i,f=n,[1]*n;exec"f+=sum(f[i-n:]),;i+=1;"*(x-n);return f
l=input()
m=max(l)+len(l)
for i in range(1,m):
 if any(l==r(i,m)[b:b+len(l)]for b in range(m)):print i;break;

Note that this requires input in this format:
[1, 1, 2, 3...]

rather than
1, 1, 2, 3...

Fairly straightforward solution, just to get things rolling. I'll work more on golfing it down once somebody else answers. This uses a slightly modified version of the N-Bonnaci generator from @Data's answer, so props to him. Then for each N-Bonnaci in range of the input, checks if the input is a subsequence of it.

try the same suggestions I gave to him: change f.append for f+=

@Cyoce oh duh. I'm can't believe I missed something that basic. fp

Is the trailing ; necessary?

Lua, 324 323 Bytes
When I see other submission, I feel like there's something wrong with my code... But then, I remember that's Lua, and there's isn't all these fancy functionnalities :'(
It was a lot of fun, took me some time actually.
Edit: Saved 1 byte with a simple trick: using a ::label::+goto label instead a infinite loop done with while''.
function f(l)c=2 y,z=table.remove,os.exit while(l[1]<2)do y(l,1)if(#l<1)then print(1)z()end end ::q:: a={}for i=1,c do a[i]=1 end b={}for i=1,#l do b[i]=l[i]end while(a[#a]<b[1])do x=0 for i=(#a-c+1>0 and #a-c+1 or 1),#a do x=x+a[i]end a[#a+1]=x if a[#a]==b[1]then y(b,1)end if #b<1 then print(c)z()end end c=c+1 goto q end

Ungolfed and Explanations
Lua has no way to define a set, subset, or even check if an array/table contains a value without using its index/key. That's why i've decided to remove elements from the array I take as a parameter. that's how I keep record of which elements has already been computed, and if it matched.
  function f(l)
  c=2
  y,z=table.remove,os.exit           -- Create pointers on table.remove and os.exit
                                     -- saves a total of 9 bytes
  while(l[1]<2)                      -- loop used to remove leading 1
  do
    y(l,1)
    if(#l<1)                         -- we also check if it was a 1-only array
    then
      print(1)                       -- if so, we print 1 and exit
      z()
    end
  end

  ::q::                              -- label q, start of the infinite loop
    a={}for i=1,c do a[i]=1 end      -- fill an array with c 1s
    b={}for i=1,#l do b[i]=l[i]end   -- copy the sequence array
    while(a[#a]<b[1])                -- while max(a)<min(b)
    do
      x=0 for i=(#a-c+1>0            -- iterate from index a.length-c to
                    and #a-c+1       -- to a.length
                    or 1),#a
      do
        x=x+a[i]                     -- summing a's elements
      end
      a[#a+1]=x                      -- append x to a
      if a[#a]==b[1]then y(b,1)end   -- if x is equal ot a member of the sequence
                                     -- remove it
      if #b<1 then print(c)z()end    -- if b is empty, it means the subset is in a
                                     -- we print c and exit
    end                              -- else we loop again
    c=c+1                            -- with c+1
  goto q                             -- return to the start of this block
end

You can try Lua online, and you can copy/paste the following code sample to run some tests. As this function exit when it founds the answer (infinite loop otherwise), you will have to change the index of test[] used (don't forget lua is 1-indexed :)).
function f(l)c=2 y,z=table.remove,os.exit while(l[1]<2)do y(l,1)if(#l<1)then print(1)z()end end ::q:: a={}for i=1,c do a[i]=1 end b={}for i=1,#l do b[i]=l[i]end while(a[#a]<b[1])do x=0 for i=(#a-c+1>0 and #a-c+1 or 1),#a do x=x+a[i]end a[#a+1]=x if a[#a]==b[1]then y(b,1)end if #b<1 then print(c)z()end end c=c+1 goto q end

test={{1,1,1},
{49, 97},
{55, 89, 144},
{1},
{6765},
{12, 23, 45, 89},
{100, 199}}

print(f(test[1]))

Wolfram Language (Mathematica), 71 bytes
(n=1;While[!SubsetQ[LinearRecurrence[s=1~Table~n,s,Max@l],l=#],n++];n)&

Try it online!


text:
Translate a Glypho program
Given an input of any valid Glypho program,
output its "human-readable" counterpart.
Glypho is an interesting esolang idea:

The instruction reference is given here. For each instruction, the characters
  abcd represent the symbols composing each instruction. a refers to the first
  unique symbol, b refers to the second unique symbol, etc.
aaaa ..... n NOP - no operation; do nothing
aaab ..... i Input - push input onto top of stack
aaba ..... > Rot - pops top stack element and pushes to bottom of stack
aabb ..... \ Swap - swaps top two stack elements
aabc ..... 1 Push - pushes a 1 onto the top of stack (creates new element)
abaa ..... < RRot - pops bottom element and pushes to top of stack
abab ..... d Dup - Duplicates top stack element
abac ..... + Add - pops top two elements and pushes their sum
abba ..... [ L-brace - skip to matching ] if top stack element is 0
abbb ..... o Output - pops and outputs top stack element
abbc ..... * Multiply - pops top two elements and pushes their product
abca ..... e Execute - Pops four elements and interprets them as an instruction
abcb ..... - Negate - pops value from stack, pushes -(value)
abcc ..... ! Pop - pops and discards top stack element
abcd ..... ] R-brace - skip back to matching [

(credit: Brian Thompson aka
  Wildhalcyon)

So, for example, PPCG would represent the Push instruction—PPCG matches
the pattern aabc, where a represents P, b represents C, and c
represents G.
The input will be a single string consisting of only printable ASCII
characters. It will always have a length divisible by four (duh).
The output is each group of four characters in the input string replaced by
which instruction they designate. Use the single-letter instruction names (the
ones right after the five dots in the table quoted above).
Since this is code-golf, the shortest code in bytes will win.
Test cases:
In                                Out
------------------------------------------------
Programming Puzzles & Code Golof  ]!]!]]]+
nananananananana batman!          dddd]]
;;;;;;;:;;:;;;::                  ni>\
llamas sleep                      1-*
8488133190003453                  <[oe
<empty string>                    <empty string>

Ah yes Code Golof. My favorite sporot.

Pyth, 37 35 34 bytes
The code contains unprintable characters, so here is the xxd hexdump:
0000000: 5663 7a34 7040 2e22 216f d78c 40bf d4f0  Vcz4p@."!o..@...
0000010: 38d6 7dfe 7312 3ff8 ea22 6958 4e7b 4e55  8.}.s.?.."iXN{NU
0000020: 5433                                     T3

Here's a printable version at 36 bytes:
Vcz4p@"ni >\\1   <d+[o*e-!]"iXN{NUT3

Try it online. Test suite.
Explanation
Vcz4p@."…"iXN{NUT3       implicit: z = input
  z                      input
 c 4                     split to 4-character blocks
V                        loop over that in N
           X               replace...
            N                in current part
             {N              unique chars in current part, in order
               UT            with numbers 0-9
          i      3         interpret as base 3
     @                     take that item of
      ."…"                   string "ni >\\1   <d+[o*e-!]"
    p                      and print without newline

CJam, 42 39 35 bytes
Saved 4 bytes borrowing user81655's idea of using base 3 instead of base 4.
l4/{__&f#3b"ni >\1   <d+[o*e-!]"=}%

Run all test cases.
There's gotta be a better way to compress the lookup table of commands...

JavaScript (ES6), 97
For each block of 4 characters, I substitute each symbol with its position in the block, getting a base 4 number. For instance 'aabc' -> '0023'. The possibile numbers are in the range 0..0123, that is 0..27 in decimal. I use the number as an index to find the right instruction character from a 28 chars string.
s=>s.replace(/.{4}/g,s=>'n..i....>.\\1....<d.+[o.*e-!]'[[...s].map(c=>n=n*4+s.indexOf(c),n=0),n])

Test

F=s=>s.replace(/.{4}/g,s=>'n..i....>.\\1....<d.+[o.*e-!]'[[...s].map(c=>n=n*4+s.indexOf(c),n=0),n])

function test() { O.textContent=F(I.value) }

test();
#I { width:90% }
<input id=I value="nananananananana batman!" oninput="test()">

MATLAB, 291 bytes
I hesitated for quite a long time if I should commit my answer. I was just playing around with MATLAB. I am aware that it's not really possible to generate dense code (a low number of instructions/bytes; about 3 times larget than your ~100 byte solutions) and that MATLAB might not be too suitable for code golf and I am new to code golf. But I simply wanted to try, and the code works (newline characters kept). Any hints welcome. :P
i=input('','s');
l=reshape(i,4,length(i)/4)';
m=']!- e';m(9)='*';m(12:22)='o[   + d  <';m(33:34)='1\';m(39)='>';m(57)='i';m(64)='n';
s='';
for k = 1:size(l,1)
n=l(k,:);
c=combvec(n,n);
t=triu(reshape(c(1,:)==c(2,:),4,4),1);
t=sum(t([5,9:10,13:15]).*2.^[5:-1:0]);
s=[s,m(t+1)];
end
display(s)

Welcome to Programming Puzzles & Code Golf! All answers are welcome, even if they get outgolfed by a ridiculous amount (has definitely happened to me before). ;) Nice first answer!

JavaScript (ES6), 115 101 bytes
s=>s.replace(/..../g,g=>"ni >\\1   <d+[o*e-!]"[[...g].map(c=>r=r*3+(m[c]=m[c]||++i)-1,i=r=0,m={})|r])

Saved 14 bytes thanks to @edc65!
Explanation
Stores the list of instructions in a string with each character at it's base-3 index. For example, + corresponds to abac which can be represented in base-3 as 0102, or 11 in decimal. The only instruction that cannot be represented in base-3 is ], but with the algorithm used to compute the base-3 number, it conveniently ends up needing to be at position 18 at the end of the string.
s=>
  s.replace(/..../g,g=>    // replace each four-character group with it's instruction
    "ni >\\1   <d+[o*e-!]" // list of instructions at their base-3 index
    [
      [...g].map(c=>       // for each character c
        r=r*3+(m[c]=m[c]   // shift r left and add the number associated with c to r
          ||++i)-1,        // if nothing is associated, associate the next number to c
                           // save i + 1 to m[c] so that it is truthy for 0
        i=                 // i = current number to assign to the next unique character
        r=0,               // r = 4-character group as a base-3 number
        m={}               // m = map of numbers assigned to each character
      )
      |r                   // return r
    ]
  )

Test

var solution = s=>s.replace(/..../g,g=>"ni >\\1   <d+[o*e-!]"[[...g].map(c=>r=r*3+(m[c]=m[c]||++i)-1,i=r=0,m={})|r])
<input type="text" id="input" value="Programming Puzzles & Code Golof" />
<button onclick="result.textContent=solution(input.value)">Go</button>

You can save many bytes not using parseInt and computing the number with repeated sum and multiply. This avoid the problem with '0123' that is invalid in base 3 but gives 19+26+3==18 that is a good position. Result: F=s=>s.replace(/..../g,g=>"ni]>\\1   <d+[o*e-!]"[[...g].map(c=>r=r*3+(m[c]=m[c]||++i)-1,r=i=0,m={})|r])

@edc65 Great suggestion. Thanks!

Python 2, 158 bytes
Takes input like "test". Output is a list of characters.
def b(s,i=0):
    for c in s:i=i*4+s.index(c)
    return"n..i....>.\\1....<d.+[o.*e-!]"[i]
print map(b,(lambda l,n:[l[i:i+n]for i in range(0,len(l),n)])(input(),4))

Try it Online!
Ungolfed:
def chunks(l, n):
    return (l[i:i+n] for i in range(0, len(l), n))

def convert(inst):
    i = 0
    for c in inst:
        i = i*4 + inst.index(c)

    return "n..i....>.\\1....<d.+[o.*e-!]"[i]

print map(convert, chunks(input(), 4))

Zsh, 118 bytes
0="n  i      > \1${(l:11:)}<d + [o * e-!]"
for s (`tr \  £|fold -4`)(eval ';n+=$s[(i)$s['{2..4}]];printf $0[5#$n-30])

Try it online!

0="n  i      > \1${(l:11:)}<d + [o * e-!]" - store this string in the variable $0. ${(l:11:)} generates 11 spaces (literally, left-padding an empty string to a length of 11), and is 1 byte shorter than writing them literally.
tr \  £ - replace spaces (\ ) with £s. This is because spaces in the input will be eaten when word splitting, messing up the 4 character grouping. Word splitting is useful though, because it allows us to loop over each line, which is how fold splits things. I used £ because it's outside the printable ASCII range that we're required to accept and only 2 bytes in UTF-8 (I could probably technically save a byte if I used a different encoding, but that's not worth the effort). Unfortunately I can't use a control character because zsh doesn't like them.
fold -4 - group into 4 characters per line
for s (``) - for each group, $s, of 4 characters:

';n+=$s[(i)$s['{2..4}]]: generate the string ;n+=$s[(i)$s[2]];n+=$s[(i)$s[3]];n+=$s[(i)$s[4]]
evaluate that as zsh code:

$s[X] - the Xth character of $s (1-indexed)
$s[(i)] - find the index of the first appearance of that character within $s
n+= - append that to $n (which implicitly starts out empty)
eval with brace expansion (like {2..4}) is a shorter way to do a simple loop than using for
We only need to use {2..4} as the first index of the first character of the string will obviously always be 1. This lets us save a byte when subtracting later (otherwise it would be -155 rather than -30)
5#$n - interpret n as a base-5 integer (if zsh used 0-based indexing, this could be base 4, we wouldn't need to subtract anything, and the $0 string could be shorter)

-30 - the minimum base-5 value we can get from any combination of characters is 31, and since zsh is 1-indexed, we subtract 30 to get an index into the string $0
$0[] - get that index into the string $0 for the relevant character to print. The spaces in $0 are padding to make the right characters appear in the right places since the possible base-5 values aren't contiguous.
printf - print that with no newline

() - subshell; any changes to variables do not persist outside the brackets. This is used to reset $n to an empty string on each iteration.

J, 37 bytes
'ni >\1   <d+[o*e-!]'{~_4(3#.~.i.])\]

Try it online!


text:
Help me Shut the Box
The inspiration for this challenge should be ridiculously obvious at the time of posting.
The Task
You must create a Shut the Box style program (not function, program). The basics of shut the box are:
Players attempt to shut the box by turning a set of levers labelled 1-9. They must do so by flipping levers. The sequence of events of each turn are as follows:

The current position of the levers are shown.

On a new game, the position of the levers should be displayed as 123456789.
On a game with shut levers, all shut levers are displayed as -. For example, on a game that has 1, 5, and 9 shut, the output would be -234-678-.

The di(c)e (is|are) rolled.

If levers 7, 8, and 9 are all off, only one six-faced die is thrown. Otherwise, 2 six-faced dice are thrown.

The player is prompted to choose how many levers they wish to flip.

If the player chooses a number >9 or <0, the game ends.
If the player chooses an already shut lever, the game ends.

The player selects that many levers.

If the sum of the levers does not equal the value of the di(c)e thrown, the game ends.

If all the levers are shut, congratulations, you win. Otherwise, go back to step 1.

Rules for the Program

On each turn, you should output the current positions of levers.
You must output the value of the roll with the phrase You rolled: (note the space).
You must prompt (and wait) for the number of levers to switch with the phrase How many levers to flip: (note the space).
You must prompt (and wait) for as many levers as the player specified with the phrase Which lever to flip: (note the space).
You must flip the specified levers.
If at any point the game ends, you must output Game Over.
If the player finishes a turn with no levers open, you must output You win!

Example Games
123456789
You rolled: 5
How many levers to flip: 5
Which lever to flip: 1
Which lever to flip: 2
Which lever to flip: 3
Which lever to flip: 4
Which lever to flip: 5
Game Over
123456789
You rolled: 5
How many levers to flip: 3
Which lever to flip: 2
Which lever to flip: 2
Which lever to flip: 1
Game Over
123456789
You rolled: 12
How many levers to flip: 2
Which lever to flip: 3
Which lever to flip: 9
12-45678-
You rolled: 6
How many levers to flip: 2
Which lever to flip: 2
Which lever to flip: 4
1---5678-
You rolled: 11
How many levers to flip: 2
Which lever to flip: 5
Which lever to flip: 6
1-----78-
You rolled: 8
How many levers to flip: 1
Which lever to flip: 8
1-----7--
You rolled: 8
How many levers to flip: 2
Which lever to flip: 1
Which lever to flip: 7
---------
You win!

Oh. I had it on my list to create a challenge involving Shut the Box. Nice!

Python 3, 348
Saved 5 bytes thanks to Mathias Ettinger.
Saved 7 bytes thanks to DSM.
Ooof, this is a long one. I also hate that there's not a good way to do test cases.
from random import*
*l,='123456789'
q=['-']*9
r=randint
p=print
f=' to flip: '
while l!=q:
 p(*l,sep='');t=r(1,6)+r(1,6)*(l[6:]!=q[6:]);p('You rolled: %s'%t);d={int(input('Which lever'+f))for _ in' '*int(input('How many levers'+f))}
 if len(set(d))-len(d)+1-all(str(x)in l for x in d)+t-sum(d):exit('Game Over')
 for x in d:l[x-1]='-'
p('You win!')

C, 405 403 398 392 390 387 bytes
#define R 1+rand()/(2147483647/6+1)
#define G return puts("Game Over");
#define I(s,w)printf(s);scanf("%d",&w);
w,s;main(r,l){char b[]="123456789";for(srand(time(0));w^9;w=strspn(b,"-")){puts(b);printf("You rolled: %d\n",r=R+(strspn(b+6,"-")<3?R:0));I("How many levers to flip: ",l)for(;l--;s+=w,b[w-1]=45){I("Which lever to flip: ",w);if(w>9|w<0|b[w-1]<48)G}if(s^=r)G}puts("You win!");}

Ungolfed
/* Macro to get random integer in range [1,6] */
#define R 1+rand()/(2147483647/6+1)

i; /* Index variable */
main(r,l,w,s)
{
    /* Running game board */
    char b[]="123456789";

    /* Run while still levers not pulled */
    for(srand(time(0));i^9;i=strspn(b,"-"))
    {
        puts(b); /* Print game board */
        r=R+(b[6]^45||b[7]^45||b[8]^45?R:0); /* Get dice roll */
        printf("You rolled: %d\n",r); /* Print dice roll */
        printf("How many levers to flip: ");
        scanf("%d",&l); /* Get # of levers */
        for(i=s=0;i++<l;s+=w)
        {
            printf("Which lever to flip: ");
            scanf("%d",&w); /* Get lever # */
            if(w>9||w<0||b[w-1]==45) /* If invalid lever or lever already pulled, game over man */
                return puts("Game Over");
            b[w-1]=45; /* flip the lever */
        }
        if(s^r) /* If sum does not equal roll, game over */
            return puts("Game Over");
    }
    puts("You win!");
}

Edit: D'oh! Left an unused variable in my golfed answer. I had removed it but pasted the wrong version.

PowerShell v2+, 330 322 bytes
$a=1..9;$r={1+(Random 6)};for($g="Game Over"){($o=-join$a-replace0,'-');if($o-eq'-'*9){"You win!";exit}"You rolled: "+($b=(&$r)+(&$r)*(($a|sort)[8]-ge7));$l=Read-Host "How many levers to flip";if(9-lt$l-or1-gt$l){$g;exit}while($l){$b-=($i=Read-Host "Which lever to flip");$a[$i-1]-=$I;$l-=1}if($b-or($a|sort)[0]){$g;exit}}

Newlines for clarity:
$a=1..9
$r={1+(Random 6)}
for($g="Game Over"){
  ($o=-join$a-replace0,'-')
  if($o-eq'-'*9){"You win!";exit}
  "You rolled: "+($b=(&$r)+(&$r)*(($a|sort)[8]-ge7))
  $l=Read-Host "How many levers to flip"
  if(9-lt$l-or1-gt$l){$g;exit}
  while($l){
    $b-=($i=Read-Host "Which lever to flip")
    $a[$i-1]-=$i
    $l-=1
  }
  if($b-or($a|sort)[0]){$g;exit}
}

(Rrequires version 2 or later since Get-Random didn't exist in PowerShell v1...)
Explanation:
Start with setting the $array of levers by taking the range 1..9, and also set $r equal to a script block that we execute later (described below with $b). The Game Over wording gets set to $g at the start of an infinite loop for(){...}. Each iteration, we set our output $o and immediately output it (thanks to the (...) encapsulation) by -joining together the array and replace each 0 with a -. (The 0 is explained below). If the output is equal to 9 hyphens, output You win! and exit.
Next, we set our dice rolls to $b by calling the stored $r (via &) with some additional parameters. The Get-Random command with a -Maximum of 6 (the -Maximum is implied) will produce an integer from 0 to 5, inclusive. We add 1 on to that to get a six-sided die, and add that to another random die roll multiplied by (($a|sort)[8]-ge7) which checks whether the highest value left on the levers is one of 7,8,9 by first sorting $a and then taking the last element and checking whether it's greater-than-or-equal-to 7. We use implicit typecasting to turn the Boolean value into either 0 (False) or 1 (True) for the multiplication, so the additional "die" is either die*0 or die*1. We then output the result of the die roll.
Next is the Read-Host into $l for how many levers. Note that PowerShell automatically adds the colon-space : after a Read-Host prompt, so we get that for free at least. We then check that the number of levers the user wishes to flip is between 1 to 9, else exit.
Now we enter a while loop. Each iteration of this loop, we Read-Host which lever, store that into $i, and subtract that value from $b. We then also subtract the corresponding lever in the array, and subtract how many additional times to query the user.
The last line (excepting the closing brace) tests two Boolean constructions. The first, just $b, will only be $True if the user didn't properly subtract all numbers from the die roll (in PowerShell, any non-zero number is Truthy). The other condition sorts $a and takes the minimal value. If we subtracted the same lever twice, then the minimal value will be negative (or Truthy), otherwise the minimal value will be 0 (or Falsey).
Example Run:
PS C:\Tools\Scripts\golfing> .\shut-the-box.ps1
123456789
You rolled: 6
How many levers to flip: 1
Which lever to flip: 6
12345-789
You rolled: 6
How many levers to flip: 2
Which lever to flip: 2
Which lever to flip: 4
1-3-5-789
You rolled: 6
How many levers to flip: 2
Which lever to flip: 1
Which lever to flip: 5
--3---789
You rolled: 10
How many levers to flip: 2
Which lever to flip: 3
Which lever to flip: 7
-------89
You rolled: 9
How many levers to flip: 1
Which lever to flip: 9
-------8-
You rolled: 8
How many levers to flip: 1
Which lever to flip: 8
---------
You win!

Excellent explanation! +1


text:
Squares in the Squares
Given input of a positive integer n, write a program that completes the following process.

Find the smallest positive integer greater than n that is a perfect square and is the concatenation of n and some other number. The order of the digits of n may not be changed. The number concatenated onto n to produce a perfect square may be called r_1.
If r_1 is not a perfect square, repeat the above process with r_1 as the new input to the process. Repeat until r_k is a perfect square, denoted s.
Print the value of sqrt(s).

Input can be taken in any format. You can assume that n is a positive integer. If any r_k has a leading zero (and r_k≠0), the zero can be ignored.

Test cases
Here are some test cases. The process demonstrates the above steps.
Input:   23
Process: 23, 2304, 4
Output:  2

Input:   10
Process: 10, 100, 0
Output:  0

Input:   1
Process: 1, 16, 6, 64, 4
Output:  2

Input:   5
Process: 5, 529, 29, 2916, 16
Output:  4

Input:   145
Process: 145, 145161, 161, 16129, 29, 2916, 16
Output:  4

Input:   1337
Process: 1337, 13373649, 3649, 36493681, 3681, 368102596, 2596, 25969216, 9216
Output:  96

This is code golf. Standard rules apply. The shortest answer (in bytes) wins.

MATL, 35 44.0 bytes
XK``x@2^tVKVXf1=a~]VKVnQ0h)UXKX^t1\

Try it online!
XK        % implicit input: n. Copy to clipboard K
`         % do...while. Each iteration applies the algorithm
  `       %   do...while. Each iteration tests a candidate number
    x     %     delete top of stack
    @2^   %     iteration index squared
    t     %     duplicate
    V     %     convert to string
    K     %     paste from clipboard K: n or r_k
    V     %     convert to string
    Xf    %     find one string within another. Gives indices of starting matches, if any
    1=a~  %     test if some of those indices is 1. If not: next iteration
  ]       %   end. We finish with a perfect square that begins with digits of n or r_k
  V       %   convert to string
  K       %   paste from clipboard K: n or r_k
  VnQ0h   %   index of rightmost characters, as determined by r_k
  )       %   keep those figures only
  U       %   convert to number. This is the new r_k
  XK      %   copy to clipboard K, to be used as input to algorithm again, if needed
  X^      %   square root
  1\      %   fractional part. If not zero: apply algorithm again
          % implitic do...while loop end
          % implicit display

Pyth, 26 bytes
LsI@b2 fy=sh.fys+QZ1\0)@Q2

Test suite
Output is as a float. If output as an int is desired, it would be 1 extra byte.
Explanation:
LsI@b2 fy=sh.fys+QZ1\0)s@Q2
                               Q = eval(input())
L                              def y(b): return
   @b2                         Square root of b
 sI                            Is an integer.
       f              )        Find the first positive integer T that satisfies
           h.f     1\0         Find the first digit string Z that satisfies
                +QZ            Concatenation of Q and Z
               s               Converted to an integer
              y                Is a pergect square.
          s                    Convert the string to an integer
         =                     Assign result to the next variable in the code, Q
        y                      Repeat until result is a perfect square
                               (The space) Discard return value
                        @Q2    Take square root of Q and print.

Python 2, 98
i=input();d=o=9
while~-d:
 n=i;d=o+1;o=i=0
 while(n*d+i)**.5%1:i=-~i%d;d+=9*d*0**i
print'%d'%n**.5

Try it online.

Since we're in float abuse territory anyway... while x**.5%1: maybe?

@Sp3000 thanks! I've golfed it down a bit more now.

@Ampora only the ideone link printed the process, but I've changed that now.

Python, 200 198 178 bytes
import math
def r(i):
 j=int(i**.5)+1
 while str(j*j)[:len(str(i))]!=str(i):j+=1
 return int(str(j*j)[len(str(i)):])
q=r(int(input()))
while math.sqrt(q)%1!=0:q=r(q)
print(q**.5)

You could save a good number of bytes by shortening math.sqrt to m.

@Ampora Aww yeah, saved 2 bytes

Brachylog, 26 bytes
{~a₀X√ℕ∧YcX∧Yh?∧Ybcℕ≜!}ⁱ√ℕ

Try it online!
The last test case was omitted in the TIO link because it alone takes more than a minute to execute. I ran it on my laptop and the correct result was achieved in no more than two hours.
{                             The input
 ~a₀                          is a prefix of
    X√                        X, the square root of which
      ℕ                       is a whole number.
       ∧YcX                   Y concatenated is X.
           ∧Yh?               The input is the first element of Y.
               ∧Yb            The rest of Y,
                  c           concatenated,
                      }       is the output
                   ℕ          which is a whole number.
                    ≜         Make sure that it actually has a value,
                     !        and discard all choice points.
{                     }ⁱ      Keep feeding that predicate its own output until
                        √     its output's square root
                         ℕ    is a whole number
                              which is the output.

The second-to-last ℕ is necessary for when the initial input is already a perfect square, so the first perfect square which has it as a prefix is itself, and ! is necessary to make sure that backtracking iterates instead of finding a larger concatenated square, but I don't really know why ≜ is necessary, I just know that 5 produces a wrong answer without it.

(Thanks to a bug in the parser, that horrible mess of named variables and ∧s is actually shorter than using a sandwich.)

Perl 6, 101 bytes
my&q={$^k;$_=({++($||=$k.sqrt.Int)**2}.../^$k/)[*-1];+S/$k//}
put (q(get),&q...!(*.sqrt%1))[*-1].sqrt

my &q = {
  $^k; # declare placeholder parameter
  # set default scalar to:
  $_ = ( # a list
    # code block that generates every perfect square
    # larger than the input
    { ++( $ ||= $k.sqrt.Int )**2 }
    ...   # produce a sequence
    /^$k/ # ending when it finds one starting with the argument
  )[*-1]; # last value in sequence

  # take the last value and remove the argument
  # and turn it into a number to remove leading zeros
  +S/$k//
}

put (     # print the result of:
  q(get),     # find the first candidate
  &q          # find the rest of them
  ...         # produce a sequence
  !(*.sqrt%1) # ending with a perfect square
)[*-1]        # last value in sequence
.sqrt         # find the sqrt

ES7, 116 bytes
n=>{do{for(i=n;!(r=(''+Math.ceil((i*=10)**0.5)**2)).startsWith(+n););n=r.replace(+n,'');r=n**0.5}while(r%1);return r}

Yes, I could probably save a byte by using eval.


text:
It's snowing in my consoles window!
You love watching the snow falling outside, but you know it won't be snowing much longer. You could take a video, but decide to make a snow animation because ... um ... you need to practice your animation skills!
Snow
Snow is simply the * symbol here. Half of the snow moves at 1 char per frame, while the other half moves at 0.5 chars per frame. The program ends when all the snow reaches the bottom of the screen. The viewing area you will be using is 80x25. You will have 100 snow flakes to output, half fast, and half slow.
Every frame you will dispense 4 flakes, 2 fast and 2 slow ones, at random locations at the top of the viewing area, until you have used all 100. The slow flakes can move either move the first frame, stay still the next, or stay still the first frame, and move the next, it doesn't matter. Overlapping flakes don't have anything special, just the * like the rest.
Other notes

You must make a full program, no functions here.
Your program must run close to 10fps (+-1 frame per sec).
You can assume the console is the same size as the viewing area.
Each frame you must remove the previous output, either by pushing all previous output off the top of the console, or by clearing the output completely.

Example
To make this shorter this just outputs 2 flakes per frame (1 fast, 1 slow), only 20 flakes will be outputted, and the viewing area is 20x5.
Frame 1:
    *              *

Frame 2:
    * *            *
    *

Frame 3:
    *  *          *
      *            *
    *

Frame 4:
   *   *      *
    *             **
      *
    *

Frame 5:
   *            *  *
    *  *      *
                  **
      *

Frame 6:
        *      **
   *   *           *
    *         *    *
                  *

Frame 7:
     *  **
   *           **
    *  *           *
              *    *

Frame 8:
    *    **
     *  *       *
   *   *       *
    *              *

Frame 9:
 *  *         *
        ***
   * *          *
    *  *       *

Frame 10:
 *              **
    *    *    *
        * *     *
   * * *

Frame 11:
                *
 *  *            *
        **    *
   *      *     *

Frame 12:

 *              *
    *    *       *
        *     * *

Frame 13:

                *
 *  *
        **       *

Frame 14:

 *              *
    *    *

Frame 15:

                *
 *  *

Frame 16:

 *              *

Frame 17:

                *

If you want some snow/rain confusion and clean code, go here

I think a lot of this(/your) challenges would be better of with actual graphic output. Many languages don't really have any tools for ASCII art output and building strings for this gets tedious very fast. And since that pixel rotating challenge, it is clear that even GO can be golfed very well.

Perhaps, but I don't want to clutter the challenge with a second output format, and even if I did it would be an uneven playing field. Besides, you can say the same thing about graphics for some languages (e.g. java).

Octave, 179 bytes
A=' *';C=D=E=zeros(25,80);B=[i=1,1,(1:78)*0];do if i++>25 B=B&0;end
C=[B(randperm(80));C(1:24,:)];D=[B(randperm(80));D(1:24,:)];F=D;D=E;E=F;pause(.1);disp(A((F|=C|D)+1))
until(~F)

Ungolfed
A=' *';                               % Index with 1,2 to translate to ' ','*'
                                      % A([2 1 2 2 1]) => '* ** '
C=D=E=zeros(25,80);                   % Locations of fast snowflakes,
                                      % slow ones moving on frame 1,3,5...
                                      % and slow ones moving on 2,4,6...
B=[1,1,zeros(1,78)];                  % Line with two snowflakes in it.
                                      % Will be added on top each frame.
i=1;
do
  if i++>25                           % We push 4 snowflakes per iteration.
    B=B&0;                            % Stop new input after 25 iterations.
  end
  C=[B(randperm(80));C(1:24,:)];      % Shift fast snowflakes down
                                      % and add randomly permuted input line.
  D=[B(randperm(80));D(1:24,:)];      % Shift one set of slow snowflakes down
                                      % and add randomly permuted input line.
  F=D;D=E;E=F;                        % Swap the two sets of slow snowflakes.
  pause(.1);
  disp(A((C|D|E)+1))                  % Print '*' where either of the matrices
                                      % is set, ' ' otherwise.
until(~(C|D|E))                       % Loop until the matrices are all zero

JavaScript (ES6), 370 bytes
(S=(n,o,r="")=>{for(i=0;i<w;i++)o[i][0].pop(),o[i][0].unshift(0),Math.abs(n/4%2)&&(o[i][1].pop(),o[i][1].unshift(0));if(n>0)for(i=0;i<4;i++)o[Math.random()*w|0][i%2][0]++;for(j=0;j<h;j++){for(i=0;i<w;i++)r+=o[i][0][j]+o[i][1][j]>0?"*":" ";r+=`
`}console.log(r),n>2*-t&&setTimeout(g=>S(n-4,o),t)})(t=100,[...new Array(w=80)].map(i=>[0,0].map(i=>new Array(h=25).fill(0))))

Simulates with a multidimensional array, then plays it out. Could probably be golfed more.
Here's a slightly less compressed version:
(S=(c,v,o='')=>{
  for(i=0;i<w;i++){
    v[i][0].pop();v[i][0].unshift(0);
    if(Math.abs(c/4%2)){
      v[i][1].pop();v[i][1].unshift(0)
    }
  }
  if(c>0){for(i=0;i<4;i++){v[Math.random()*w|0][i%2][0]++}}
  for(j=0;j<h;j++){
    for(i=0;i<w;i++){
      o+=v[i][0][j]+v[i][1][j]>0?'*':' ';
    }
    o+=`
`}
  console.log(o);
  if(c>-t*2){setTimeout(g=>S(c-4,v),t)}
})(t=100,[...new Array(w=80)].map(a=>[0,0].map(b=>new Array(h=25).fill(0))))

C, 295 282 bytes
#include <stdlib.h>
main(){int z=25,q=100,h=50,w=30,m[q][w],s=0,a[q],b[q],x,y;for(;s<q;s++){memset(m,32,sizeof m);system("cls");a[s]=rand()%w;b[s]=rand()%w;for(x=0,y=s;y&&x<h;)m[y/2][b[x]]=m[--y][a[x++]]=42;for(x=0;x<z;x++){for(y=0;y<w;y++)putchar(m[x][y]);printf("\n");}sleep(1);}}

I've used Dev-C++/Windows to run.
Ungolfed version:
#include <stdlib.h>
main(){
    int z=25,                  // number of rows
        q=100,                 // number of flakes
        h=50,                  // number of flakes/2
        w=30,                  // number of columns
        m[q][w],               // matrix to print
        s=0,                   // counter
        a[q],                  // fast flakes
        b[q],                  // slow flakes
        x,y;                   // aux
    for(;s<q;s++){             // until the last slow flake takes the floor
        memset(m,32,sizeof m);   // clear the matrix (' '==32(ascii))
        system("cls");           // clear windows console
        a[s]=rand()%w;           // random (s*2-1)º fast flake position
        b[s]=rand()%w;           // random (s*2)º slow flake position
        for(x=0,y=s;y&&x<h;){    // set each flake position in matrix:
            m[y/2][b[x]]=94;       // slow flakes ('^'==94(ascii))
            m[--y][a[x++]]=42;     // fast flakes ('*'==42(ascii))
        }                        //
        printf("Frame %i:\n",s); // print frame number (step order)
        for(x=0;x<z;x++){        // for each row in matrix
            printf("%02i:",x);     // print the row index
            for(y=0;y<w;y++)       // for each column in row
                putchar(m[x][y]);    // print slow/fast flake or space
            printf("\n");          // for each row follows a new line
        }                        // then
        sleep(1);                // wait one second till next step
    }
}

Notes:

Maybe you'll need to maximize the console.
In the ungolfed code I did some extra prints for better visualization. Also used ^ for slow flakes.