ASCII 아트 상자가 있으며이를 열려면 프로그램이 필요합니다.

예

입력:

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

산출:

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

사양

• 첫 번째 줄은 -3 개 이상으로 만 구성 됩니다.
• 가운데 행은 |공백으로 시작 하고 끝으로 끝납니다|
  • 모든 가운데 행은 동일합니다
• 마지막 행은 |have로 시작 _하고 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.

자바 스크립트 ES6, 57 바이트

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

선행 줄 바꿈을 출력합니다. -s 행을 가져와 삼각형으로 변환 한 다음 -s를 공백으로 바꿉니다 .

편집 : @ edc65 덕분에 5 바이트가 절약되었습니다.

pb (비경쟁), 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 위치로 이동하고 필요한 곳으로 내려가 벽과 바닥을 그려 뚜껑으로 마무리합니다.

이 재미있는 애니메이션을 확인하십시오!

긴 일시 정지는 브러시가 입력을 통과하는 것입니다.

언 골프 드 :

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

첫 번째 단계에서 모든 항목 -은 -다음에 있는 ' /및 줄 바꾸기 로 대체됩니다 . 원래 첫 번째 줄의 끝에있는 줄 바꿈이 삭제됩니다. 두 번째 단계에서는 new -를 공백으로 변경 하여 원하는 결과를 얻습니다.

여기에서 온라인으로 사용해보십시오.

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

apt, 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}\\

자바 스크립트 (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>

자바 8, 158118 바이트

이것은 시작에 불과하지만 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);}

입력을 문자열로 예상하고 상자를 반환합니다.

파이썬 3, 1̶7̶0̶ 88 바이트

여기 내 짧은 코드가 있습니다 : 편집 : 이제 82 바이트 더 짧습니다 @Dennis의 코드 편집!

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

파이썬 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()

둘 중 하나를 사용하려면 너비 나 깊이가 'f.txt'인 ASCII 상자가 포함 된 동일한 디렉토리에 텍스트 파일을 작성해야합니다. 그런 다음 해당 상자를 엽니 다.

배쉬, 85 84 79 자

(순수한 Bash 버전은 외부 명령을 사용하지 않습니다.)

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

선행 줄 바꿈을 출력합니다.

샘플 실행 :

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

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

펄, 61 54 33 + 3 = 36 자

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

다음과 같이 실행하십시오.

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

각각의 -첫 번째 라인은 몇개의 연결의 결과 인 문자열로 치환 , /및 \n. ${chr 39}Perl의 유명한 $'일명 $POSTMATCH특수 변수로 평가됩니다 . 마지막으로 chomp는 마지막 -문자 에 추가 된 후행 줄 바꿈 문자를 제거 합니다.

7 개 이상의 문자를 저장 한 @manatwork 덕분에.

보너스 - 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

왝. 확실히 더 짧을 수 있습니다. 여전히 작업 중입니다.

Python3, 76 바이트

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

1. 첫 번째 입력 줄의 길이를 가져옵니다.
2. 라인 인쇄 / 줄이려면 하십시오.
3. 나머지 부분을으로 stdin똑바로 밉니다 stdout.

편집 : 내 코드가 @Monster의 짧은 Python3 코드의 @Dennis의 주석 편집과 거의 동일하다는 것을 알았습니다. 단, 차이점은 stdin변수에 저장하는 대신 나머지를 직접 인쇄하는 것입니다. 좋은 마음!

캔버스 , 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

파이썬 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 _{( 참조 링크 )} 에 s를 입력 하고 첫 번째 행을 $d문자열 로 저장 하고 나머지 행을 $b문자열 배열로 저장합니다. 그런 다음 length첫 번째 줄의 (빼기 1)에서 0각 반복 출력에 해당 수의 공백에 a를 더한 루프를 반복합니다 /. 마지막으로 출력$b (입력 문자열의 나머지 부분)은 기본적으로 한 줄에 하나씩 출력합니다.

예제 실행

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

자바 스크립트 (Node.js) , 56 바이트

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

온라인으로 사용해보십시오!

@Neil 의 답변 으로 의견을 작성해야 하지만 아직 의견을 작성할 수 없습니다

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 바이트

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

온라인 (자세한 내용) 또는 온라인 (순수한 방법)으로 시도하십시오 .

설명:

줄 바꿈으로 입력을 나누고 첫 번째 줄의 길이를 가져 와서 오른쪽에서 아래쪽으로 해당 길이의 줄을 인쇄하십시오.

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

한 번 오른쪽으로 이동 :

Move(:Right)
Ｍ→

입력을 개행으로 다시 나누고 첫 번째 항목을 제거하고 남은 내용을 암시 적으로 인쇄하십시오.

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

(참고 : 변수에 줄 바꿈으로 입력 분할을 넣으면 (위의 두 번 수행하므로) 약간 다른 방법을 사용하여 1 바이트 더 길고 14 바이트입니다 ( @Neil 덕분에 ) :
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ 온라인으로 시도 하거나 (verbose) 온라인으로 시도하십시오 (순수) ).

자바 스크립트 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>

파이썬 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 바이트

루비, 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|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|

배쉬, 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

sedstdin 및 배관 을 사용 하고 사용 하면 더 짧아 질 수 있습니다 .

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|«»

온라인으로 사용해보십시오!