Eu tenho uma caixa de arte ASCII e preciso de um programa para abri-la.

Exemplos

Entrada:

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

Saída:

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

Especificação

• A primeira linha consistirá apenas em -pelo menos três delas
• As linhas do meio começarão com |espaços e terminarão com|
  • Todas as linhas do meio serão iguais
• A última linha começará com |have _e terminará com um|
• Todas as linhas terão o mesmo comprimento

Abrindo a caixa:

• Cada um -deve ser substituído por um /em linhas e posições ascendentes.

CJam, 14 bytes

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

Experimente online!

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

Gera uma nova linha líder. Funciona pegando a linha de se -convertendo-os em um triângulo e substituindo os -por espaços.

Editar: salvou 5 bytes graças a @ edc65.

pb (NÃO COMPROMISSO), 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]>^}

A versão do pbi que você precisa para executar esta resposta é mais recente que a pergunta. Teria funcionado em versões mais antigas, exceto que eu nunca consegui permitir novas linhas de entrada. Ah bem.

Primeiro, isso determina a altura da caixa contando novas linhas na entrada. Uma vez que ele sabe disso, vai para o local Y do lado direito da caixa, desce até onde precisa estar e desenha as paredes e o chão, terminando com a tampa.

Confira esta animação divertida!

A pausa longa é o pincel passando por cima da entrada.

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

Pitão, 16 14 bytes

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

Explicação

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

Obrigado @FryAmTheEggman pelo novo algoritmo!

Experimente aqui.

Retina, 34 20 bytes

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

Na primeira etapa, todos -são substituídos pelos -seguintes, a /e uma nova linha. A nova linha no final da primeira linha original é excluída. Na segunda etapa, alteramos os novos -para espaços que resultam na saída desejada.

Experimente online aqui.

MATL , 14 15 bytes

' /'jnXyPQ)`jt

A entrada deve ter uma nova linha à direita.

Experimente online!

Explicação

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

Teste online!

Gera uma nova linha principal, aceitável de acordo com o OP.

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

Isso seria 4 bytes mais curto se a dobradiça estiver na borda direita da caixa:

Ur-@"
{SpY}\\

JavaScript (ES6), 66

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

TESTE

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

Este é apenas um começo, mas ei, 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 a entrada como uma sequência, retorna a caixa.

Python 3, 1̶7̶0̶ 88 bytes

Aqui está o meu código (er) curto: EDIT: agora 82 bytes mais curto com o Edit Edit do @Dennis!

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

Python 3, 421 bytes

Como alternativa, apenas por diversão, você pode usar um que o 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 qualquer um, você deve criar um arquivo de texto no mesmo diretório que contenha uma caixa ascii de qualquer largura ou profundidade chamada 'f.txt'. Ele abrirá essa caixa.

Bash, 85 84 79 caracteres

(Versão do Pure Bash, nenhum comando externo usado.)

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

Gera uma nova linha líder.

Exemplo de execução:

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

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

Perl, 61 54 33 + 3 = 36 caracteres

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

Execute-o como

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

Cada um -na primeira linha é substituído por uma sequência resultante da concatenação de algum número de , /e \n. ${chr 39}é avaliada $'como $POSTMATCHvariável especial do perl (in) famosa aka . Por fim, o chomp se livra do caractere de nova linha à direita que foi adicionado para o último -caractere.

Obrigado a @manatwork por salvar mais de 7 caracteres.

Bônus - s^-^" "x$i++."\\\n"^ge&&chopabre a caixa da borda direita em 29 + 3 caracteres :). Execute-o como:

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

Pitão, 26 23 bytes

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

Que nojo. Definitivamente pode ser mais curto; ainda trabalhando nisso.

Python3, 76 bytes

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

1. Obtenha o comprimento da primeira linha de entrada.
2. Imprima linhas /precedidas por um número decrescente de espaços.
3. Empurre o resto da stdinlinha reta parastdout .

EDIT: Acabei de notar que meu código é quase idêntico à edição de comentários de @Dennis do código Python3 mais curto do @ Monster, a única diferença é imprimir o restante stdindiretamente, em vez de armazená-lo em uma variável. Grandes mentes!

Tela , 6 4 bytes

ｊＬ／ｏ

Experimente aqui!

Explicação:

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 uma função oque recebe uma string como entrada. (O programa completo não foi especificado na pergunta).

PowerShell, 55 bytes

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

Pega a entrada $argscomo uma string, -splits em novas linhas `n _{( link de referência )} , armazena a primeira linha em $d(como uma string) e a restante em $b(como uma matriz de strings). Em seguida, fazemos um loop a partir lengthda primeira linha (menos 1) 0e cada iteração gera esse número de espaços mais a /. Finalmente, produza $b(o restante da sequência de entrada) que, por padrão, gera uma por linha.

Exemplo de execução

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

Experimente online!

Deve ser escrito como um comentário de @Neil 's resposta , mas eu não posso criar comentários ainda

05AB1E (herdado) , 9 bytes

g'/1.Λ|»»

Experimente online! (somente legado)

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

Carvão , 14 bytes

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

Experimente online (detalhado) ou online (puro) .

Explicação:

Divida a entrada por novas linhas, pegue o comprimento da primeira linha e imprima uma linha desse comprimento da parte superior direita para a esquerda inferior:

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

Mova uma vez para a direita:

Move(:Right)
Ｍ→

Divida a entrada por novas linhas novamente e remova o primeiro item e imprima o que resta implicitamente:

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

(OBSERVAÇÃO: Colocar a entrada dividida por novas linhas em uma variável (uma vez que eu faço isso duas vezes acima) tem 1 byte a mais e 14 bytes usando um método ligeiramente diferente (graças ao @Neil ):
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ Experimente on-line (detalhado) ou on-line (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`
`)

Simples o suficiente: obter o comprimento da primeira linha, criar um triângulo com espaçamento à direita /e adicioná-lo ao original, fatiado e unido.

Teste! (Somente 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

Precisa de um arquivo fcom a caixa original / fechada, a saída é a aberta. Um brinde a @Monster pela idéia ... tentará descobrir a entrada de várias linhas mais tarde e ver se é mais curta.

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

• apenas notei que a extremidade esquerda /tem um espaço à frente; +2 bytes

Ruby, 59 caracteres

(Código de 57 caracteres + opções de linha de comando de 2 caracteres.)

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

Exemplo de execução:

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

Bash, 129 caracteres

Requer um arquivo chamado acom a caixa fechada, com saída para 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

Pode ser possível reduzi-lo usando sede usando stdin e tubulação.

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;

Versão não destruída:

$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 sem caixa)

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]

Se alguém tiver alguma idéia de como reduzi-lo, entre em contato!

Awk, 47 46 caracteres

(Código de 44 caracteres + opção de linha de comando de 2 caracteres.)

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

Exemplo de execução:

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

Exemplo de execução:

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

K (ngn / k) , 18 bytes

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

Experimente online!

05AB1E (herdado) , 12 bytes

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

Experimente online!