Saya punya kotak ASCII-art dan saya butuh program untuk membukanya.

Contohnya

Memasukkan:

-------
|     |
|_____|

Keluaran:

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

Spesifikasi

• Baris pertama hanya akan terdiri dari -, setidaknya 3 dari mereka
• Baris tengah akan mulai dengan |memiliki spasi, dan diakhiri dengan|
  • Semua baris tengah akan sama
• Baris terakhir akan mulai dengan |memiliki _dan diakhiri dengan a|
• Semua baris akan memiliki panjang yang sama

Membuka kotak:

• Masing -- masing harus diganti dengan /garis dan posisi naik.

CJam, 14 byte

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

Cobalah online!

Bagaimana itu bekerja

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 byte

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

Menghasilkan baris baru terkemuka. Bekerja dengan mengambil deretan -s dan mengonversinya menjadi segitiga, lalu mengganti -s dengan spasi.

Sunting: Disimpan 5 byte berkat @ edc65.

pb (NONCOMPETING), 125 byte

^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]>^}

Versi pbi yang perlu Anda jalankan jawaban ini lebih baru dari pertanyaan. Itu akan bekerja di versi yang lebih lama kecuali bahwa saya tidak pernah sempat membiarkan baris baru dalam input. Baiklah.

Pertama, ini menentukan ketinggian kotak dengan menghitung baris baru di input. Setelah mengetahui hal itu, ia pergi ke lokasi Y di sisi kanan kotak, turun ke tempat yang seharusnya dan menggambar dinding dan lantai, diakhiri dengan tutupnya.

Lihat animasi yang asyik ini!

Jeda panjang adalah sikat memeriksa input.

Tidak Disatukan:

^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

Pyth, 16 14 byte

j+_m+*;d\/Uz.z

Penjelasan

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

Terima kasih @FryAmTheEggman untuk algoritma baru!

Coba di sini.

Retina, 34 20 byte

- (? = (- *)) ¶?
$ 1 / ¶
-
 

Pada langkah pertama setiap -diganti dengan yang -mengikutinya, a /dan baris baru. Baris baru di akhir baris pertama asli dihapus. Pada langkah kedua kami mengubah yang baru -ke spasi yang menghasilkan output yang diinginkan.

Cobalah online di sini.

MATL , 14 15 byte

' /'jnXyPQ)`jt

Input harus memiliki baris tambahan tambahan.

Cobalah online!

Penjelasan

' /'       % 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}/

Uji secara online!

Menghasilkan baris baru terkemuka, yang dapat diterima menurut OP.

Bagaimana itu bekerja

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.

Ini akan menjadi 4 byte lebih pendek jika engsel dibiarkan berada di tepi kanan kotak:

Ur-@"
{SpY}\\

JavaScript (ES6), 66

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

UJI

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>

Java 8, 158 118 byte

Ini baru permulaan, tapi hei, 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);}

Mengharapkan input sebagai string, mengembalikan kotak.

Python 3, 1̶7̶0̶ 88 byte

Berikut ini adalah kode pendek saya: EDIT: Sekarang 82 byte Lebih Pendek Dengan @Dennis's Edit Kode!

f=open('f.txt')
d=len(f.readline())-1
a=f.read()
while d:d-=1;print(' '*d+'/')
print(a)

Python 3, 421 byte

Atau, hanya untuk bersenang-senang, Anda bisa menggunakan yang membukanya perlahan:

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()

Untuk menggunakan salah satu, Anda harus membuat file teks dalam direktori yang sama berisi kotak ascii dengan lebar atau kedalaman apa pun yang disebut 'f.txt'. Ini kemudian akan membuka kotak itu.

Bash, 85 84 79 karakter

(Versi Pure Bash, tidak ada perintah eksternal yang digunakan.)

r(){
a="${a/-
/
$s/
}"
s+=\ 
[[ $a = -* ]]&&r
}
mapfile a
r
IFS=
echo "${a[*]}"

Menghasilkan baris baru terkemuka.

Contoh dijalankan:

bash-4.3$ bash open-the-box.sh <<< $'-------\n|     |\n|_____|'

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

Perl, 61 54 33 + 3 = 36 karakter

s^-^" "x(length$')."/\n"^ge&chomp

Jalankan sebagai

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

Setiap -baris pertama digantikan oleh string yang merupakan hasil penggabungan beberapa angka , /dan \n. ${chr 39}mengevaluasi untuk perl's (in) terkenal $'alias $POSTMATCHvariabel khusus. Terakhir, chomp menghilangkan karakter baris baru yang ditambahkan untuk yang terakhir- karakter .

Terima kasih kepada @manatwork karena telah menyimpan 7+ lebih banyak karakter.

Bonus - s^-^" "x$i++."\\\n"^ge&&chopmembuka kotak dari tepi kanan dalam 29 + 3 karakter :). Jalankan sebagai:

gowtham@ubuntu:~$ cat a
----
|  |
|__|
gowtham@ubuntu:~$ perl -plE 's^-^" "x$i++."\\\n"^ge&&chop' closed_box_file
\
 \
  \
   \
|  |
|__|

Pyth, 26 23 bytes

jXK.z0jm+*\ t-lhKd\/lhK

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

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!

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|__|"
   /
  /
 /
/
|  |
|__|

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

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.

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)).

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>

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|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|

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.

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;

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!

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|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|

Gema, 51 49 31 characters

-\P/-+/=@subst{-=\\ ;$1}/\n
-=/

Sample run:

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

K (ngn/k), 18 bytes

{(" /"@|=#*x),1_x}

Try it online!

05AB1E (legacy), 12 bytes

€ðƶ€¦'/«R|«»

Try it online!