[Question]
  [
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.
  
[Answer]
## 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.
[Answer]
# 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](https://codegolf.stackexchange.com/users/31625/fryamtheeggman) for new algorithm!
[Try it here.](http://pyth.herokuapp.com/?code=j%2B_m%2B*%3Bd%5C%2FUz.z&input=-------%0A|+++++|%0A|_____|&debug=0)
[Answer]
# [pb](https://esolangs.org/wiki/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!
![](https://i.stack.imgur.com/VkaWF.gif)
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
```
[Answer]
# 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.](http://retina.tryitonline.net/#code=LSg_PSgtKikpwrY_CiQxL8K2Ci0KIA&input=LS0tLS0tLQp8ICAgICB8CnxfX19fX3w)
[Answer]
# CJam, 14 bytes
```
l,{N'/@S*}%W%q
```
[Try it online!](http://cjam.tryitonline.net/#code=bCx7TicvQFMqfSVXJXE&input=LS0tLS0tLQp8ICAgICB8CnxfX19fX3w)
### 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.
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 14 ~~15~~ bytes
```
' /'jnXyPQ)`jt
```
Input should have a trailing newline.
[**Try it online!**](http://matl.tryitonline.net/#code=JyAvJ2puWHlQUSlganQ&input=LS0tLS0tLQp8ICAgICB8CnxfX19fX3wKCgo)
### 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
```
[Answer]
# Japt, ~~28~~ ~~26~~ ~~25~~ ~~22~~ ~~18~~ 17 bytes
```
Ur-@"
{SpUa- -Y}/
```
[Test it online!](http://ethproductions.github.io/japt?v=master&code=VXItQFIrU3BVYS0gLVkgKycv&input=Ii0tLS0tLS0KfCAgICAgfAp8X19fX198Ig==)
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}\\
```
[Answer]
# 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))
```
```
<pre id=O></pre>
```
[Answer]
# 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.
[Answer]
# 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|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|
```
[Answer]
## **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
\
 \
  \
   \
|  |
|__|
```
[Answer]
## Pyth, ~~26~~ 23 bytes
```
jXK.z0jm+*\ t-lhKd\/lhK
```
Yuck. Can definitely be shorter; still working on it.
[Answer]
# 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.
[Answer]
# Python3, 76 bytes
```
f=open(0)
w=len(f.readline())
while w:w-=1;print(' '*w+'/')
print(f.read())
```
1. Get the length of the first input line.
2. Print lines of `/` preceded by a decreasing number of spaces.
3. 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!
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~6~~ 4 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
ｊＬ／ｏ
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjRBJXVGRjJDJXVGRjBGJXVGRjRG,i=JTYwJTYwJTYwJTBBLS0tLS0tLSUwQSU3QyUyMCUyMCUyMCUyMCUyMCU3QyUwQSU3QyUyMCUyMCUyMCUyMCUyMCU3QyUwQSU3Q19fX19fJTdDJTBBJTYwJTYwJTYw,v=6)
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
```
[Answer]
# 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).
[Answer]
## PowerShell, 55 bytes
```
$d,$b=$args-split"`n";($d.length-1)..0|%{" "*$_+"/"};$b
```
Takes input `$args` as a string, `-split`s on newlines  ``n` ([reference link](https://technet.microsoft.com/en-us/library/hh847835.aspx)), 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|__|"
   /
  /
 /
/
|  |
|__|
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 56 bytes
```
a=>a[b="replace"](/-+/,c=>c[b](d=/-/g,`
$'/`))[b](d,' ')
```
[Try it online!](https://tio.run/##JctBCoMwEEDRfU4RpJCEJs4JxouINOMYpSUYiaWr3D1qfcsP/0M/2jm/t69b0xTqjJWwo37EJoctEodm0OCeYBk77sdBTwgOFuvFQ4E35p@skspUTuueYmhjWvSsvbuJIi9FlNelnE89AA "JavaScript (Node.js) – Try It Online")
Should be written as a comment of **@Neil**'s [answer](https://codegolf.stackexchange.com/a/70655/82328) but I can't create comments yet
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 9 bytes
```
g'/1.Λ|»»
```
[Try it online! (legacy-only)](https://tio.run/##MzBNTDJM/f8/XV3fUO/c7JpDuw/t/v9fFwK4ahRAoIarJh4EagA "05AB1E (legacy) – Try It Online")
### 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.
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal/wiki), 14 [bytes](https://github.com/somebody1234/Charcoal/wiki/Code-page)
```
↙Ｌ§⪪θ¶⁰Ｍ→✂⪪θ¶¹
```
[Try it online (verbose)](https://tio.run/##S85ILErOT8z5/z@gKDOvRMPKJb88zyc1rUTHJzUvvSRDw7HEMy8ltUIjuCAns0SjUEcpJk9JU8dAU1OTyze/LFXDKigzPaNEkys4JzM5FU2Voeb//9FKSkq6EMBVowACNVw18SBQA5SJ/a9blgMA) or [try it online (pure)](https://tio.run/##S85ILErOT8z5//9R28z3e9YcWv5o1apzOw5te9S44f2etY/aJj2a0wQVOrTz//9oJSUlXQjgqlEAgRqumngQqAHKxAIA).
**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)](https://tio.run/##Pcy9CsMgGIXh3asQp08wN5BMhY4phHRsQwnhqwqi8Qe7eO/GUNpnPS9nU2vY3GpqvcSopYUZM4aIcN@NTuAFZU/LOBfU84FMQdsE/dV97IjvJOiIViYFk9vBc96Km8sI/aylSv/@d9mKodYHY6z7IoWeCimvU2nLUrtsDg) or [try it online (pure)](https://tio.run/##S85ILErOT8z5//9R55RH63oerVp1bsehbed2PGqb@X7Pmkdd88/teL9n7aO2SUDJczv@/49WUlLShQCuGgUQqOGqiQeBGqBMLAA)).
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 16 bytes
```
L:£(&‹¥\/꘍,)□Ḣ⁋,
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=L%3A%C2%A3%28%26%E2%80%B9%C2%A5%5C%2F%EA%98%8D%2C%29%E2%96%A1%E1%B8%A2%E2%81%8B%2C&inputs=----%0A%7C%20%20%7C%0A%7C__%7C&header=&footer=)
[Answer]
# 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><div id=q>
```
[Answer]
## 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
[Answer]
# 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|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|
```
[Answer]
## 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.
[Answer]
# 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;
```
[Answer]
# 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!
[Answer]
# 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|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|
```
[Answer]
# Gema, ~~51~~ ~~49~~ 31 characters
```
-\P/-+/=@subst{-=\\ ;$1}/\n
-=/
```
Sample run:
```
bash-4.3$ gema -e '-\P/-+/=@subst{-=\\ ;$1}/\n;-=/' <<< $'-------\n|     |\n|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|
```
[Answer]
# [K (ngn/k)](https://github.com/ngn/k), 18 bytes
```
{(" /"@|=#*x),1_x}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqlpDSUFfyaHGVlmrQlPHML6i9n@ahpIuBChxKSgo1SiAQA2EHQ8CNUqa/wE "K (ngn/k) – Try It Online")
]