Tengo una caja de arte ASCII y necesito un programa para abrirla.

Ejemplos

Entrada:

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

Salida:

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

Especificación

• La primera línea solo consistirá en -, al menos 3 de ellos
• Las filas del medio comenzarán con |espacios, y terminarán con|
  • Todas las filas del medio serán iguales
• La última fila comenzará con |have _y terminará con un|
• Todas las filas tendrán la misma longitud.

Abriendo la caja:

• Cada uno -debe ser reemplazado por un /en líneas ascendentes y posición.

CJam, 14 bytes

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

Pruébalo en línea!

Cómo funciona

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 bytes

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

Produce una nueva línea líder. Funciona tomando la fila de -sy convirtiéndolas en un triángulo, luego reemplazando la -s con espacios.

Editar: Guardado 5 bytes gracias a @ edc65.

pb (NO COMPETENTE), 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]>^}

La versión de pbi que necesita para ejecutar esta respuesta es más nueva que la pregunta. Hubiera funcionado en versiones anteriores, excepto que nunca pude permitir nuevas líneas en la entrada. Oh bien.

Primero, esto determina la altura del cuadro contando nuevas líneas en la entrada. Una vez que sabe eso, va a la ubicación Y del lado derecho de la caja, baja a donde debe estar y dibuja las paredes y el piso, terminando con la tapa.

¡Mira esta divertida animación!

La pausa larga es el pincel que pasa sobre la entrada.

Sin golf:

^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 bytes

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

Explicación

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

¡Gracias @FryAmTheEggman por el nuevo algoritmo!

Pruébalo aquí.

Retina, 34 20 bytes

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

En el primer paso, cada uno -se sustituye por los -siguientes, a /y una nueva línea. La nueva línea al final de la primera línea original se elimina. En el segundo paso cambiamos los nuevos -a espacios que resultan en la salida deseada.

Pruébelo en línea aquí.

MATL , 14 15 bytes

' /'jnXyPQ)`jt

La entrada debe tener una nueva línea final.

Pruébalo en línea!

Explicación

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

¡Pruébelo en línea!

Emite una nueva línea principal, que es aceptable según el OP.

Cómo funciona

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.

Esto sería 4 bytes más corto si se permite que la bisagra esté en el borde derecho de la caja:

Ur-@"
{SpY}\\

JavaScript (ES6), 66

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

PRUEBA

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 bytes

Esto es solo un comienzo, pero bueno, 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);}

Espera la entrada como una cadena, devuelve el cuadro.

Python 3, 1̶7̶0̶ 88 bytes

Aquí está mi código corto (er): EDITAR: ahora 82 bytes más corto con @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

Alternativamente, solo por diversión, puede usar uno que lo abra lentamente:

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

Para usar cualquiera de los dos, debe crear un archivo de texto en el mismo directorio que contenga un cuadro ASCII de cualquier ancho o profundidad llamado 'f.txt'. Luego abrirá esa caja.

Bash, 85 84 79 caracteres

(Versión Pure Bash, no se utilizan comandos externos).

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

Produce una nueva línea líder.

Ejecución de muestra:

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

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

Perl, 61 54 33 + 3 = 36 caracteres

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

Ejecútalo como

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

Cada uno -en la primera línea se reemplaza por una cadena que es el resultado de la concatenación de algún número de , /y \n. ${chr 39}se evalúa $'como $POSTMATCHla variable especial famosa de aka (in) famosa de perl . Por último, chomp se deshace del carácter de nueva línea que se agregó para el último -personaje.

Gracias a @manatwork por guardar más de 7 caracteres.

Bonificación : s^-^" "x$i++."\\\n"^ge&&chopabre el cuadro desde el borde derecho en 29 + 3 caracteres :). Ejecútalo como:

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 Definitivamente puede ser más corto; sigo trabajando en eso.

Python3, 76 bytes

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

1. Obtenga la longitud de la primera línea de entrada.
2. Imprima líneas /precedidas por un número decreciente de espacios.
3. Empuje el resto de stdindirectamente a stdout.

EDITAR: Acabo de notar que mi código es casi idéntico a la edición de comentarios de @Dennis del código Python3 más corto de @ Monster, la única diferencia es imprimir el resto stdindirectamente en lugar de almacenarlo en una variable. ¡Grandes mentes!

Lienzo , 6 4 bytes

ｊＬ／ｏ

Pruébalo aquí!

Explicación:

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)

Define una función oque toma una cadena como entrada. (El programa completo no se especificó en la pregunta).

PowerShell, 55 bytes

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

Toma la entrada $argscomo una cadena, -splits en líneas nuevas `n _{( enlace de referencia )} , almacena la primera línea en $d(como una cadena) y el resto en $b(como una matriz de cadenas). Luego hacemos un bucle desde la lengthprimera línea (menos 1) 0y cada iteración genera ese número de espacios más a /. Finalmente, la salida $b(el resto de la cadena de entrada) que, por defecto, generará una por línea.

Ejecución de ejemplo

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

Pruébalo en línea!

Debe ser escrito como un comentario de @Neil 's respuesta , pero no puedo crear aún comentarios

05AB1E (heredado) , 9 bytes

g'/1.Λ|»»

Pruébalo en línea! (solo legado)

Cómo funciona

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.

Carbón , 14 bytes

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

Pruébelo en línea (detallado) o pruébelo en línea (puro) .

Explicación:

Divida la entrada por nuevas líneas, tome la longitud de la primera línea e imprima una línea de esa longitud desde la parte superior derecha hasta la parte inferior izquierda:

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

Muévete una vez a la derecha:

Move(:Right)
Ｍ→

Divida la entrada por nuevas líneas nuevamente, y elimine el primer elemento, e imprima lo que queda implícitamente:

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

(NOTA: Poner la entrada dividida por nuevas líneas en una variable (ya que lo hago dos veces arriba) es 1 byte más largo y 14 bytes usando un método ligeramente diferente (gracias a @Neil ):
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ Pruébelo en línea (detallado) o inténtelo en línea (puro) ).

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

Bastante simple: obtener la longitud de la primera línea, crear un triángulo espaciado con el final /y agregarlo al original, cortado y unido.

¡Pruébalo! (Solo 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 caracteres

Necesita un archivo fcon el cuadro original / cerrado, el resultado es el abierto. Saludos a @Monster por la idea ... intentaré averiguar la entrada de varias líneas más adelante y ver si es más corta.

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]

Editar

• acabo de notar que el extremo izquierdo /tiene un espacio en frente; +2 bytes

Ruby, 59 caracteres

(Código de 57 caracteres + opciones de línea de comando de 2 caracteres).

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

Ejecución de muestra:

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

Bash, 129 caracteres

Requiere un archivo llamado acon el cuadro cerrado, salidas 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

Es posible que sea más corto usando sedy usando stdin y tuberías.

PHP, 127 caracteres

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

Versión sin golf:

$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 sin caja)

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]

Si alguien tiene alguna idea de cómo acortarlo, ¡hágamelo saber!

Awk, 47 46 caracteres

(Código de 44 caracteres + opción de línea de comando de 2 caracteres).

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

Ejecución de muestra:

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

Gema, 51 49 31 caracteres

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

Ejecución de muestra:

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

K (ngn / k) , 18 bytes

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

Pruébalo en línea!

05AB1E (heredado) , 12 bytes

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

Pruébalo en línea!