ฉันมีกล่อง ASCII-art และฉันต้องการโปรแกรมเพื่อเปิด

ตัวอย่าง

การป้อนข้อมูล:

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

เอาท์พุท:

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

สเปค

• บรรทัดแรกจะประกอบด้วย-อย่างน้อย 3 บรรทัดเท่านั้น
• แถวกลางจะเริ่มต้นด้วย|ช่องว่างและลงท้ายด้วย|
  • แถวกลางทั้งหมดจะเหมือนกัน
• แถวสุดท้ายจะเริ่มต้นด้วย|have _และลงท้ายด้วย a|
• แถวทั้งหมดจะมีความยาวเท่ากัน

เปิดกล่อง:

• แต่ละรายการ-ควรถูกแทนที่ด้วย 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 ด้วยช่องว่าง

แก้ไข: บันทึก 5 ไบต์ขอบคุณ @ edc65

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 ของด้านขวาของกล่องลงไปที่ตำแหน่งที่ต้องใช้และดึงผนังและพื้นจนจบด้วยฝา

ลองชมแอนิเมชั่นสนุก ๆ นี้!

หยุดชั่วคราวที่ยาวคือแปรงไปที่อินพุต

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

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 / ¶
-
 

ในขั้นตอนแรกทุกคน-จะถูกแทนที่ด้วยการ-ติดตาม/และบรรทัดใหม่ บรรทัดใหม่ที่ท้ายบรรทัดแรกดั้งเดิมจะถูกลบ ในขั้นตอนที่สองเราเปลี่ยนของใหม่-เป็นช่องว่างซึ่งผลลัพธ์ในผลลัพธ์ที่ต้องการ

ลองออนไลน์ได้ที่นี่

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>

Java 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 ไบต์

นี่คือรหัสสั้น ๆ ของฉัน: แก้ไข: ตอนนี้ 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 ตัวอักษร

(เวอร์ชั่น Pure 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

แต่ละคน-ในบรรทัดแรกจะถูกแทนที่ด้วยสตริงที่เป็นผลมาจากการเรียงต่อกันจำนวนของบาง, และ/ หาค่าเป็นตัวแปรพิเศษหรือที่รู้จักกันในชื่อ perl ของ perl สุดท้าย chomp จะกำจัดตัวอักษรขึ้นบรรทัดใหม่ที่ต่อท้ายสำหรับอักขระตัวสุดท้าย\n${chr 39}$'$POSTMATCH-

ขอบคุณ @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

yuck สามารถสั้นกว่านี้ได้อย่างแน่นอน ยังคงทำงานกับมัน

Python3, 76 ไบต์

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

1. รับความยาวของบรรทัดอินพุตแรก
2. พิมพ์บรรทัดที่/นำหน้าด้วยจำนวนช่องว่างที่ลดลง
3. ผลักดันให้ส่วนที่เหลือของการตรงstdinstdout

แก้ไข: ฉันเพิ่งสังเกตเห็นว่ารหัสของฉันเกือบจะเหมือนกับการแก้ไขความคิดเห็นของ @Dennis ของรหัส Python3 ที่สั้นกว่าของ @ Monster ความแตกต่างเพียงอย่างเดียวคือการพิมพ์ส่วนที่เหลือstdinโดยตรงแทนที่จะเก็บไว้ในตัวแปร จิตใจที่ยอดเยี่ยม!

Canvas , 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บนบรรทัดใหม่`n _{( ลิงก์อ้างอิง )} , เก็บบรรทัดแรกลงใน$d(เป็นสตริง) และที่เหลือลงใน$b(เป็นอาร์เรย์ของสตริง) จากนั้นเราจะห่วงจากlengthบรรทัดแรก (ลบ 1) และแต่ละเอาท์พุทย้ำว่าจำนวนของช่องว่างบวก0 /ในที่สุดเอาท์พุท$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 's คำตอบแต่ฉันไม่สามารถสร้างความเห็น

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 ไบต์

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

ลองมันออนไลน์ (verbose)หรือลองออนไลน์ (บริสุทธิ์)

คำอธิบาย:

แยกอินพุตโดยขึ้นบรรทัดใหม่ใช้ความยาวของบรรทัดแรกและพิมพ์บรรทัดที่มีความยาวนั้นจากด้านบนขวาไปซ้ายล่าง:

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

เลื่อนหนึ่งครั้งไปทางขวา:

Move(:Right)
Ｍ→

แยกการป้อนข้อมูลด้วยการขึ้นบรรทัดใหม่อีกครั้งและลบรายการแรกและพิมพ์สิ่งที่เหลือโดยปริยาย:

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

(หมายเหตุ: การใส่อินพุตแยกโดยการขึ้นบรรทัดใหม่ในตัวแปร (เนื่องจากฉันทำสองครั้งข้างบน) คือ1 ไบต์อีกต่อไปและอีก 14 ไบต์โดยใช้วิธีที่แตกต่างกันเล็กน้อย (ขอบคุณ@Neil ):
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ ลองออนไลน์ (verbose)หรือลองออนไลน์ (บริสุทธิ์ )

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, 120 122 ตัวอักษร

ต้องการไฟล์ที่fมีกล่องต้นฉบับ / ปิดเอาท์พุทเป็นไฟล์ที่เปิดอยู่ ไชโย @Monster สำหรับความคิด ... จะพยายามหาอินพุตหลายบรรทัดในภายหลังและดูว่ามันสั้นกว่านี้หรือไม่

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

Bash, 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

อาจเป็นไปได้ที่จะทำให้สั้นลงโดยใช้sedและใช้ stdin และ piping

PHP, 127 ตัวอักษร

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

เวอร์ชันที่ไม่ถูกปรับแต่ง:

$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 ไบต์ (ไม่รวมกล่อง 110)

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]

หากใครมีความคิดวิธีย่อให้สั้นลงโปรดแจ้งให้เราทราบ!

Awk, 47 46 ตัวอักษร

(ตัวเลือกบรรทัดคำสั่งรหัส 44 อักขระ + 2 อักขระ)

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

วิ่งตัวอย่าง:

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

Gema, 51 49 31 ตัวละคร

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

วิ่งตัวอย่าง:

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

K (ngn / k) , 18 ไบต์

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

ลองออนไลน์!

05AB1E (ดั้งเดิม) 12 ไบต์

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

ลองออนไลน์!