Ich habe eine ASCII-Art-Box und benötige ein Programm, um sie zu öffnen.

Beispiele

Eingang:

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

Ausgabe:

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

Spezifikation

• Die erste Zeile besteht nur aus -mindestens 3 Zeilen
• Die mittleren Zeilen beginnen mit |Leerzeichen und enden mit|
  • Alle mittleren Reihen sind gleich
• Die letzte Zeile beginnt mit |haben _mit einem und beenden|
• Alle Zeilen sind gleich lang

Öffnen der Box:

• Jedes -sollte durch ein /in aufsteigender Linie und Position ersetzt werden.

CJam, 14 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Gibt eine führende Newline aus. Arbeiten Sie, indem Sie die Reihe von -s nehmen und sie in ein Dreieck umwandeln und dann das -s durch Leerzeichen ersetzen .

Bearbeiten: 5 Bytes dank @ edc65 gespeichert.

pb (NICHT KOMPETIEREND), 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]>^}

Die Version von pbi, die Sie zum Ausführen dieser Antwort benötigen, ist neuer als die Frage. Es hätte in älteren Versionen funktioniert, außer dass ich nie dazu gekommen bin, neue Zeilen in der Eingabe zuzulassen. Naja.

Zunächst wird die Höhe der Box durch Zählen der Zeilenumbrüche in der Eingabe bestimmt. Sobald es das weiß, geht es zur Y-Position auf der rechten Seite des Kastens, geht dort hinunter, wo es sein muss, zeichnet die Wände und den Boden und schließt mit dem Deckel.

Schauen Sie sich diese lustige Animation an!

Die lange Pause ist der Pinsel, der über die Eingabe geht.

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 bis 14 Bytes

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

Erläuterung

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

Danke @FryAmTheEggman für den neuen Algorithmus!

Probieren Sie es hier aus.

Retina, 34 20 Bytes

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

Im ersten Schritt wird jeder -durch die -folgenden /Zeilen ersetzt: a und newline. Die neue Zeile am Ende der ursprünglichen ersten Zeile wird gelöscht. Im zweiten Schritt ändern wir die neuen -in Leerzeichen, was zur gewünschten Ausgabe führt.

Probieren Sie es hier online aus.

MATL , 14 15 Bytes

' /'jnXyPQ)`jt

Die Eingabe sollte einen nachgestellten Zeilenumbruch haben.

Probieren Sie es online!

Erläuterung

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

Online testen!

Gibt einen führenden Zeilenumbruch aus, der laut OP akzeptabel ist.

Wie es funktioniert

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.

Dies wäre 4 Bytes kürzer, wenn sich das Scharnier am rechten Rand der Box befinden darf:

Ur-@"
{SpY}\\

JavaScript (ES6), 66

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

PRÜFUNG

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

Dies ist nur ein Anfang, aber 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);}

Erwartet die Eingabe als Zeichenfolge und gibt die Box zurück.

Python 3, 1̶7̶0̶ 88 Bytes

Hier ist mein kurzer (er) Code: EDIT: Jetzt 82 Bytes kürzer mit @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

Alternativ können Sie zum Spaß auch eines verwenden, das es langsam öffnet:

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

Um eines von beiden zu verwenden, müssen Sie eine Textdatei in demselben Verzeichnis erstellen, die ein ASCII-Feld beliebiger Breite oder Tiefe mit dem Namen "f.txt" enthält. Es wird dann diese Box öffnen.

Schlag, 85 , 84 79 Zeichen

(Pure Bash-Version, keine externen Befehle verwendet.)

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

Gibt eine führende Newline aus.

Probelauf:

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

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

Perl, 61 54 33 + 3 = 36 Zeichen

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

Führen Sie es als

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

Jeder -in erster Linie durch eine Kette ersetzt, ist ein Ergebnis der Verkettung von einer Anzahl von , /und \n. ${chr 39}wertet zu Perls (in) berühmter $'aka $POSTMATCHspezieller Variable aus. Zuletzt entfernt chomp das abschließende Newline-Zeichen, das für das letzte -Zeichen hinzugefügt wurde .

Vielen Dank an @manatwork für das Speichern von mehr als 7 Zeichen.

Bonus - s^-^" "x$i++."\\\n"^ge&&chopöffnet die Box vom rechten Rand in 29 + 3 Zeichen :). Führen Sie es aus als:

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. Kann definitiv kürzer sein; arbeite immer noch daran.

Python3, 76 Bytes

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

1. Liefert die Länge der ersten Eingabezeile.
2. Drucken Sie Zeilen, /denen eine abnehmende Anzahl von Leerzeichen vorangestellt ist.
3. Schieben Sie den Rest stdingerade nach stdout.

BEARBEITEN: Ich habe gerade bemerkt, dass mein Code fast identisch mit @Dennis 'Kommentarbearbeitung von @ Monsters kürzerem Python3-Code ist. Der einzige Unterschied besteht darin, den Rest stdindirekt zu drucken, anstatt ihn in einer Variablen zu speichern. Großartige Köpfe!

Canvas , 6 4 Bytes

ｊＬ／ｏ

Probieren Sie es hier aus!

Erläuterung:

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)

Definiert eine Funktion o, die eine Zeichenfolge als Eingabe verwendet. (Vollständiges Programm wurde in der Frage nicht angegeben).

PowerShell, 55 Byte

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

Übernimmt Eingaben $argsals Zeichenfolge, -splits in Zeilenumbrüchen `n _{( Referenzlink )} , speichert die erste Zeile in $d(als Zeichenfolge) und die verbleibenden in $b(als Array von Zeichenfolgen). Wir durchlaufen dann die Schleife von der lengthersten Zeile (minus 1) bis 0und geben bei jeder Iteration die Anzahl der Leerzeichen plus a aus /. Schließlich wird eine Ausgabe $b(der Rest der Eingabezeichenfolge) ausgegeben, die standardmäßig eine Ausgabe pro Zeile enthält.

Beispiellauf

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

Probieren Sie es online!

Sollte als Kommentar von geschrieben werden @Neil s‘ Antwort , aber ich kann nicht Kommentare erstellen noch

05AB1E (Legacy) , 9 Byte

g'/1.Λ|»»

Probieren Sie es online! (nur Legacy)

Wie es funktioniert

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.

Holzkohle , 14 Bytes

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

Probieren Sie es online (ausführlich) oder online (rein) .

Erläuterung:

Teilen Sie die Eingabe durch Zeilenumbrüche, nehmen Sie die Länge der ersten Zeile und drucken Sie eine Zeile dieser Länge von oben rechts nach unten links:

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

Einmal nach rechts bewegen:

Move(:Right)
Ｍ→

Teilen Sie die Eingabe erneut durch Zeilenumbrüche, entfernen Sie das erste Element und drucken Sie implizit das, was noch übrig ist:

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

(HINWEIS: Das Einfügen der durch Zeilenumbrüche aufgeteilten Eingabe in eine Variable (da ich es oben zweimal mache) ist 1 Byte länger und 14 Byte mit einer etwas anderen Methode (dank @Neil ):
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ Probieren Sie es online (ausführlich) oder versuchen Sie es online (rein) ).

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

Ganz einfach: Ermitteln der Länge der ersten Zeile, Erstellen eines nachgestellten Abstandsdreiecks /und Hinzufügen dieser Länge zum Original, geschnitten und verbunden.

Probieren Sie es aus! (Nur 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 Zeichen

Benötigt eine Datei fmit der Original / geschlossenen Box, die Ausgabe ist die geöffnete. Ein Hoch auf @Monster für die Idee ... wird später versuchen, mehrzeilige Eingaben herauszufinden und festzustellen, ob sie kürzer sind.

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]

Bearbeiten

• Ich /habe gerade bemerkt, dass ganz links ein Leerzeichen vorne ist. +2 Bytes

Ruby, 59 Zeichen

(57 Zeichen Code + 2 Zeichen Befehlszeilenoptionen.)

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

Probelauf:

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

Bash, 129 Zeichen

Benötigt eine Datei, die amit der geschlossenen Box aufgerufen wird und auf stdout ausgegeben wird.

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 könnte möglich sein, es durch Verwendung sedund Verwendung von Standard und Rohrleitungen zu verkürzen.

PHP, 127 Zeichen

$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 ohne 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]

Wenn jemand eine Idee hat, wie man es verkürzt, lass es mich wissen!

Awk, 47 46 Zeichen

(44 Zeichen Code + 2 Zeichen Befehlszeilenoption.)

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

Probelauf:

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

Gema, 51 49 31 Zeichen

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

Probelauf:

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

K (ngn / k) , 18 Bytes

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

Probieren Sie es online!

05AB1E (Legacy) , 12 Byte

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

Probieren Sie es online!