我有一个ASCII艺术框，需要一个程序来打开它。

例子

输入：

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

输出：

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

规格

• 第一行仅包含-，其中至少3个
• 中间的行将以|空格开头，以|
  • 所有中间行将相同
• 最后一行将以|have 开头，_以a结束|
• 所有行的长度将相同

打开盒子：

• 每一个-都应由/升序和位置替换。

CJam，14个字节

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

在线尝试！

怎么运行的

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个字节

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

输出前导换行符。通过取-s 的行并将其转换为三角形，然后将-s 替换为空格来工作。

编辑：由于@ edc65，节省了5个字节。

pb（NONCOMPETING），125个字节

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

您需要运行此答案的pbi版本比问题新。本来可以在较旧的版本中使用，除非我从来没有允许输入换行符。那好吧。

首先，这通过计算输入中的换行符来确定框的高度。一旦知道了这一点，它就会到达盒子右侧的Y位置，然后下降到需要的位置，然后绘制墙壁和地板，最后盖上盖子。

看看这个有趣的动画！

长时间的停顿是画笔越过输入。

取消高尔夫：

^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字节

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

说明

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

感谢@FryAmTheEggman提供的新算法！

在这里尝试。

视网膜，34 20字节

-（？=（-*））¶？
$ 1 /¶
--
 

在第一步中，每个-变量都用-其后的，a /和换行符代替。原始第一行末尾的换行符将被删除。在第二步中，我们将new更改-为空格，以产生所需的输出。

在这里在线尝试。

MATL，14 15字节

' /'jnXyPQ)`jt

输入应包含尾随换行符。

在线尝试！

说明

' /'       % 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字节

Ur-@"
{SpUa- -Y}/

在线测试！

输出前导换行符，OP可以接受。

怎么运行的

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.

如果允许铰链位于框的右边缘，则该长度将缩短4个字节：

Ur-@"
{SpY}\\

JavaScript（ES6），66

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

测试

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>

爪哇8，158个 118字节

这只是一个开始，但是，嘿，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);}

期望输入为字符串，返回框。

Python 3，1̶7̶0̶88字节

这是我的简短代码：编辑：现在，使用@Dennis的代码编辑可以缩短82个字节！

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

Python 3，421个字节

另外，只是为了好玩，您可以使用一种缓慢打开它的方法：

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

要使用两者之一，您必须在同一目录中创建一个文本文件，其中包含任意宽度或深度的ascii框，称为“ f.txt”。然后它将打开该框。

Bash，85 84 79个字符

（纯Bash版本，不使用任何外部命令。）

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

输出前导换行符。

样品运行：

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

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

Perl，61 54 33 + 3 = 36个字符

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

运行为

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

每个-在第一行是由一个字符串，它是一些数目的级联的结果代替，/和\n。${chr 39}评估为perl（$'又名）$POSTMATCH特殊变量值。最后，chomp摆脱了为最后一个-字符添加的尾随换行符。

感谢@manatwork节省了7个以上的字符。

奖金 - s^-^" "x$i++."\\\n"^ge&&chop从右边缘以29 + 3个字符打开框：)。运行为：

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

Pyth，26 23字节

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

uck 绝对可以短一些；仍在努力。

Python3，76个字节

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

1. 获取第一条输入线的长度。
2. 打印行/前带有减少的空格。
3. 将其余stdin直线推到stdout。

编辑：我刚刚注意到我的代码与@Dennis对@Monster较短的Python3代码的注释编辑几乎相同，唯一的区别是stdin直接打印其余部分而不是将其存储在变量中。伟大的思想！

画布，6 4 字节

ｊＬ／ｏ

在这里尝试！

说明：

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字节

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

定义一个o将字符串作为输入的函数。（问题中未指定完整程序）。

PowerShell，55个字节

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

将输入$args作为字符串，-split在换行符s上`n _{（参考链接）}，将第一行存储为$d（作为字符串），其余存储为$b（作为字符串数组）。然后，我们从length第一行的负号（负1）0循环到，每次迭代输出该数量的空格加a/。最后，输出$b（输入字符串的其余部分），默认情况下，每行输出一个。

示例运行

PS C:\Tools\Scripts\golfing> .\help-me-open-the-box.ps1 "----`n|  |`n|__|"
   /
  /
 /
/
|  |
|__|

JavaScript（Node.js），56字节

a=>a[b="replace"](/-+/,c=>c[b](d=/-/g,`
$'/`))[b](d,' ')

在线尝试！

应该写成的评论@Neil的答案，但我无法创建评论

05AB1E（旧版），9个字节

g'/1.Λ|»»

在线尝试！（仅旧版）

怎么运行的

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.

木炭，14字节

↙Ｌ§⪪θ¶⁰Ｍ→✂⪪θ¶¹

在线尝试（详细）或在线尝试（纯）。

说明：

用换行符分隔输入，获取第一行的长度，并打印从上右至下左的该行：

Print(:DownLeft,Length(AtIndex(Split(q,"\n"),0)))
↙Ｌ§⪪θ¶⁰

向右移动一次：

Move(:Right)
Ｍ→

再次用换行符分隔输入，并删除第一项，然后隐式打印剩下的内容：

Slice(Split(q,"\n"),1)
✂⪪θ¶¹

（注意：通过换行将输入放入变量中（因为我在上面做了两次），通过使用稍微不同的方法（由于@Neil），长度增加了1个字节，也增加了14个字节：在线（详细）或在线尝试（纯））。
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ

JavaScript ES6，106个字节

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

足够简单：获取第一行的长度，创建带有尾随的间隔三角形 /，并将其添加到原始的，切片和。

测试一下！（仅限ES6 :(）

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、120122 个字符

需要一个f带有原始/关闭框的文件，输出是打开的文件。为这个想法加油打气...稍后将尝试找出多行输入，看它是否更短。

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]

编辑

• 只是注意到最左边/有一个前面的空间；+2个字节

Ruby，59个字符

（57个字符的代码+ 2个字符的命令行选项。）

s=""
$_=$_.chars.map{(s<<" ")[1..-1]+?/}.reverse*$/if$.<2

样品运行：

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

重击，129个字符

需要一个a带有闭合框的文件，输出到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!