Tôi có một hộp nghệ thuật ASCII và tôi cần một chương trình để mở nó.

Ví dụ

Đầu vào:

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

Đầu ra:

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

Đặc điểm kỹ thuật

• Dòng đầu tiên sẽ chỉ bao gồm -, ít nhất 3 trong số họ
• Các hàng ở giữa sẽ bắt đầu bằng |khoảng trắng và kết thúc bằng|
  • Tất cả các hàng giữa sẽ giống nhau
• Hàng cuối cùng sẽ bắt đầu bằng |có _và kết thúc bằng một|
• Tất cả các hàng sẽ có cùng độ dài

Mở hộp:

• Mỗi cái -nên được thay thế bằng một /dòng tăng dần và vị trí.

CJam, 14 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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,' ')

Đầu ra một dòng mới hàng đầu. Hoạt động bằng cách lấy hàng của -s và chuyển đổi chúng thành một hình tam giác, sau đó thay thế- s bằng dấu cách.

Chỉnh sửa: Đã lưu 5 byte nhờ @ edc65.

pb (KHÔNG GIỚI HẠN), 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]>^}

Phiên bản pbi mà bạn cần để chạy câu trả lời này mới hơn câu hỏi. Nó sẽ hoạt động trong các phiên bản cũ hơn ngoại trừ việc tôi không bao giờ có thể cho phép các dòng mới trong đầu vào. Ồ tốt

Đầu tiên, điều này xác định chiều cao của hộp bằng cách đếm dòng mới trong đầu vào. Một khi nó biết điều đó, nó đi đến vị trí Y của bên phải của hộp, đi xuống nơi cần đến và vẽ các bức tường và sàn nhà, hoàn thiện bằng nắp.

Kiểm tra hoạt hình vui nhộn này!

Tạm dừng dài là bàn chải đi qua đầu vào.

Ung dung:

^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

Bình thường, 16 14 byte

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

Giải trình

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

Cảm ơn @FryAmTheEggman cho thuật toán mới!

Hãy thử nó ở đây.

Võng mạc, 34 20 byte

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

Trong bước đầu tiên, mọi thứ -được thay thế bằng các bước -tiếp theo, a /và một dòng mới. Dòng mới ở cuối dòng đầu tiên bị xóa. Trong bước thứ hai, chúng tôi thay đổi các -không gian mới thành không gian dẫn đến đầu ra mong muốn.

Hãy thử trực tuyến tại đây.

MATL , 14 15 byte

' /'jnXyPQ)`jt

Đầu vào nên có một dòng mới.

Hãy thử trực tuyến!

Giải trình

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

Ur-@"
{SpUa- -Y}/

Kiểm tra nó trực tuyến!

Xuất ra một dòng mới hàng đầu, được chấp nhận theo OP.

Làm thế nào nó hoạt động

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.

Điều này sẽ ngắn hơn 4 byte nếu bản lề được phép ở cạnh phải của hộp:

Ur-@"
{SpY}\\

JavaScript (ES6), 66

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

KIỂM TRA

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

Đây chỉ là một sự khởi đầu, nhưng 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);}

Yêu cầu đầu vào dưới dạng một chuỗi, trả về hộp.

Python 3, 1̶7̶0̶ 88 byte

Đây là mã (er) ngắn của tôi: EDIT: Bây giờ 82 byte ngắn hơn với mã của @Dennis Chỉnh sửa!

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

Python 3, 421 byte

Ngoài ra, chỉ để giải trí, bạn có thể sử dụng một cái mở từ từ:

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

Để sử dụng một trong hai, bạn phải tạo một tệp văn bản trong cùng thư mục chứa hộp ascii có chiều rộng hoặc chiều sâu bất kỳ được gọi là 'f.txt'. Sau đó nó sẽ mở hộp đó.

Bash, 85 84 79 ký tự

(Phiên bản Pure Bash, không sử dụng lệnh bên ngoài.)

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

Đầu ra một dòng mới hàng đầu.

Chạy mẫu:

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

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

Perl, 61 54 33 + 3 = 36 ký tự

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

Chạy nó như

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

Mỗi -dòng đầu tiên được thay thế bằng một chuỗi là kết quả của việc ghép một số số , /và \n. ${chr 39}đánh giá biến perl's (in) nổi tiếng $'hay còn gọi là $POSTMATCHbiến đặc biệt. Cuối cùng, chomp thoát khỏi ký tự dòng mới được thêm vào cho -ký tự cuối cùng .

Cảm ơn @manatwork vì đã tiết kiệm được hơn 7 ký tự.

Phần thưởng - s^-^" "x$i++."\\\n"^ge&&chopmở hộp từ cạnh phải trong 29 + 3 ký tự :). Chạy nó như:

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

Bình thường, 26 23 byte

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

Kinh quá. Chắc chắn có thể ngắn hơn; vẫn đang làm việc trên nó

Python3, 76 byte

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

1. Lấy chiều dài của dòng đầu vào đầu tiên.
2. Các dòng in /trước số lượng không gian giảm dần.
3. Đẩy phần còn lại stdinthẳng đến stdout.

EDIT: Tôi vừa nhận thấy rằng mã của tôi gần giống với chỉnh sửa nhận xét của @Dennis về mã Python3 ngắn hơn của @ Monster, sự khác biệt duy nhất là in stdintrực tiếp phần còn lại thay vì lưu trữ trong một biến. Những đầu óc vĩ đại!

Canvas , 6 4 byte

ｊＬ／ｏ

Hãy thử nó ở đây!

Giải trình:

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 byte

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

Xác định hàm olấy một chuỗi làm đầu vào của nó. (Chương trình đầy đủ không được chỉ định trong câu hỏi).

PowerShell, 55 byte

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

Đưa đầu vào $argsdưới dạng một chuỗi, -splits trên dòng mới `n _{( liên kết tham chiếu )} , lưu trữ dòng đầu tiên vào $d(dưới dạng chuỗi) và còn lại vào $b(dưới dạng một chuỗi các chuỗi). Sau đó, chúng tôi lặp từ lengthdòng đầu tiên (trừ 1) đến 0và mỗi lần lặp đầu ra số lượng khoảng trắng cộng với a /. Cuối cùng, đầu ra $b(phần còn lại của chuỗi đầu vào) theo mặc định sẽ xuất một đầu ra trên mỗi dòng.

Chạy ví dụ

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

JavaScript (Node.js) , 56 byte

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

Hãy thử trực tuyến!

Nên được viết như một lời nhận xét của @Neil 's câu trả lời nhưng tôi không thể tạo bình luận nào

05AB1E (di sản) , 9 byte

g'/1.Λ|»»

Hãy thử trực tuyến! (chỉ kế thừa)

Làm thế nào nó hoạt động

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.

Than , 14 byte

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

Dùng thử trực tuyến (dài dòng) hoặc thử trực tuyến (thuần túy) .

Giải trình:

Tách đầu vào theo dòng mới, lấy độ dài của dòng đầu tiên và in một dòng có độ dài đó từ trên cùng bên phải xuống dưới bên trái:

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

Di chuyển một lần sang phải:

Move(:Right)
Ｍ→

Tách đầu vào theo dòng mới một lần nữa và xóa mục đầu tiên và in những gì còn lại ngầm:

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

(LƯU Ý: Đặt phân tách đầu vào theo dòng mới trong một biến (vì tôi thực hiện hai lần ở trên) dài hơn 1 byte cũng bằng 14 byte bằng cách sử dụng một phương thức hơi khác (nhờ @Neil ):
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ Thử trực tuyến (dài dòng) hoặc thử trực tuyến (nguyên chất) ).

JavaScript ES6, 106 byte

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

Đủ đơn giản: lấy chiều dài của dòng đầu tiên, tạo ra một hình tam giác cách đều có dấu / và thêm nó vào bản gốc, được cắt và nối.

Kiểm tra nó ra! (Chỉ 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>

Con trăn 2.7, 120 122 ký tự

Cần một tệp fvới hộp ban đầu / đóng, đầu ra là tệp đã mở. Chúc mừng ý tưởng @Monster cho ý tưởng ... sẽ cố gắng tìm ra đầu vào đa dòng sau và xem nó có ngắn hơn không.

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]

Chỉnh sửa

• chỉ cần lưu ý rằng ngoài cùng bên trái /có một không gian phía trước; +2 byte

Ruby, 59 ký tự

(Mã 57 ký tự + 2 ký tự tùy chọn dòng lệnh.)

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

Chạy mẫu:

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

Bash, 129 ký tự

Yêu cầu một tệp được gọi avới hộp kín, xuất ra thiết bị xuất chuẩn.

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

Có thể làm cho nó ngắn hơn bằng cách sử dụng sedvà sử dụng stdin và đường ống.

PHP, 127 ký tự

$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;

Phiên bản bị đánh cắp:

$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 byte (110 không có hộp)

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]

Nếu bất cứ ai có ý tưởng làm thế nào để rút ngắn nó, xin vui lòng cho tôi biết!

Awk, 47 46 ký tự

(Tùy chọn dòng lệnh 44 ký tự + 2 ký tự.)

/-/{OFS=RS;for(i=NF;i;i--){$i=s"/";s=s" "}}1

Chạy mẫu:

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

Gema, 51 49 31 ký tự

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

Chạy mẫu:

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

K (ngn / k) , 18 byte

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

Hãy thử trực tuyến!

05AB1E (di sản) , 12 byte

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

Hãy thử trực tuyến!