Giới thiệu

Tôi nghĩ rằng tất cả mọi người đồng ý rằng hình ảnh đẹp phải có một khung hình đẹp. Nhưng hầu hết các thách thức trên trang web này về ASCII-Art chỉ muốn bức tranh thô và không quan tâm đến việc bảo tồn nó.
Sẽ không hay nếu chúng ta có một chương trình lấy một số ASCII-Art và bao quanh nó với một khung hình đẹp?

Các thách thức

Viết chương trình lấy một số ASCII-Art làm đầu vào và đầu ra nó được bao quanh bởi một khung đẹp.

Thí dụ:

*****
 ***
  *
 ***
*****

trở thành

╔═══════╗
║ ***** ║
║ ***
║ *
║ ***
║ ***** ║
╚═══════╝

• Bạn phải sử dụng chính xác các ký tự cho khung như trong ví dụ: ═ ║ ╔ ╗ ╚ ╝
• Trên cùng và dưới cùng của khung được chèn trước dòng đầu tiên và sau dòng cuối cùng của đầu vào.
• Các phần bên trái và quyền của khung phải có chính xác một phần đệm không gian cho dòng rộng nhất của đầu vào.
• Có thể không có khoảng trắng đầu hoặc cuối trong đầu ra. Chỉ có một dòng mới được cho phép.
• Bạn có thể cho rằng đầu vào không có khoảng trắng hàng đầu không cần thiết.
• Bạn có thể cho rằng đầu vào không có khoảng trắng ở bất kỳ dòng nào.
• Bạn không phải xử lý đầu vào trống.
• Đầu vào sẽ chỉ chứa các ký tự ASCII có thể in và các dòng mới.

Quy tắc

• Chức năng hoặc chương trình đầy đủ cho phép.
• Quy tắc mặc định cho đầu vào / đầu ra.
• Tiêu chuẩn áp dụng.
• Đây là môn đánh gôn , vì vậy, số byte thấp nhất sẽ thắng. Tiebreaker là trình trước đó.

Chúc mừng mã hóa!

Sử dụng một số ASCII-Art tuyệt vời, được tạo ra trong bất kỳ thử thách nào trên trang web này, làm đầu vào cho chương trình của bạn và hiển thị nó với một khung hình đẹp rất được khuyến khích!

CJam, 45 ký tự / 52 byte

qN/_z,)[_)'═*N]2*C,3%'╔f+.\4/@@f{Se]'║S@2$N}*

Cố gắng tránh những ký tự 3 byte đắt tiền đó là ... thú vị.

Dùng thử trực tuyến

Giải trình

qN/                   Split input by newline
_z,                   Zip and get length L, i.e. length of longest line
)                     Increment -> L+1
[_)'═*N]              Make two-element array of "═"*(L+2) and newline
2*                    Double the array, giving ["═"*(L+2) "\n" "═"*(L+2) "\n"]

C,                    range(12), i.e. [0 1 2 ... 11]
3%                    Every third element, i.e. [0 3 6 9]
'╔f+                  Add "╔" to each, giving "╔╗╚╝"
.\                    Vectorised swap with the previous array, giving
                      ["╔" "═"*(L+2) "╗" "\n" "╚" "═"*(L+2) "╝" "\n"]
4/                    Split into chunks of length 4

@@                    Move split input and L+1 to top
f{...}                Map with L+1 as extra parameter...
  Se]                   Pad line to length L+1, with spaces
  '║S                   Put "║" and space before it
  2$N                   Put "║" and newline after it

*                     Join, putting the formatted lines between the top and bottom rows

Haskell, 139 byte

q=length
g x|l<-lines x,m<-maximum$q<$>l,s<-[-1..m]>>"═"='╔':s++"╗\n"++(l>>= \z->"║ "++z++([q z..m]>>" ")++"║\n")++'╚':s++"╝"

Ví dụ như tôi đang đóng khung người tuyết "12333321" .

*Main> putStrLn $ g " _===_\n (O.O)\n/(] [)\\\n ( : )"
╔═════════╗
║  _===_  ║
║  (O.O)  ║
║ /(] [)\ ║
║  ( : )  ║
╚═════════╝

Làm thế nào nó hoạt động:

bind
  l: input split into lines
  m: maximum line length
  s: m+2 times ═

build top line
prepend left frame to each line, pad with spaces, append right frame
build bottom line.

JavaScript (ES6), 138 byte

Đây là 138 byte trong mã hóa IBM866, tại thời điểm viết vẫn được hỗ trợ trong Firefox, nhưng 152 ở UTF-8.

s=>`╔${t='═'.repeat(w=2+Math.max(...(a=s.split`
`).map(s=>s.length)))}╗
${a.map(s=>('║ '+s+' '.repeat(w)).slice(0,w+1)).join`║
`}║
╚${t}╝`

Bash, ^{_{173 171 150 148}} 147 byte, ^{_{157 136 134}} 133 ký tự

q(){((n=${#2}>n?${#2}:n));};mapfile -tc1 -C q v;for((p=++n+1;p;--p));do z+=═;done;echo ╔$z╗;printf "║ %-${n}s║\n" "${v[@]}";echo ╚$z╝

Đa dòng:

q() {
    (( n = ${#2} > n ? ${#2} : n))
}
mapfile -tc1 -C q v

for((p=++n+1;p;--p))
do 
    z+=═
done

echo ╔$z╗
printf "║ %-${n}s║\n" "${v[@]}"
echo ╚$z╝

Ví dụ thực hiện:

bash -c 'q(){((n=${#2}>n?${#2}:n));};mapfile -tc1 -C q v;for((p=++n+1;p;--p));do z+=═;done;echo ╔$z╗;printf "║ %-${n}s║\n" "${v[@]}";echo ╚$z╝'< bear.txt

Mẫu chạy từ tập lệnh:

$ cat bear2.txt 
     (()__(()
     /       \
    ( /    \  \
     \ o o    /
     (_()_)__/ \
    / _,==.____ \
   (   |--|      )
   /\_.|__|'-.__/\_
  / (        /     \
  \  \      (      /
   )  '._____)    /
(((____.--(((____/mrf
$ ./frame< bear2.txt 
╔═══════════════════════╗
║      (()__(()         ║
║      /       \        ║
║     ( /    \  \       ║
║      \ o o    /       ║
║      (_()_)__/ \      ║
║     / _,==.____ \     ║
║    (   |--|      )    ║
║    /\_.|__|'-.__/\_   ║
║   / (        /     \  ║
║   \  \      (      /  ║
║    )  '._____)    /   ║
║ (((____.--(((____/mrf ║
╚═══════════════════════╝

AWK, 159 byte

{a[NR]=$0
x=length($0)
m=m<x?x:m
a[NR,1]=x}
END{for(;i<m+2;i++)t=t"═"
print"╔"t"╗"
for(j=1;j<NR;j++){f="║ %-"m"s ║\n"
printf f,a[j]}print"╚"t"╝"}

Rõ ràng awkcó thể in Unicode nếu bạn có thể tìm ra cách lấy nó trong mã.

Perl, 111 ký tự

(điểm bao gồm +5 cho các cờ phiên dịch)

#!/usr/bin/perl -n0 -aF\n
$n=(sort{$b<=>$a}map length,@F)[0];$l="═"x$n;
print"╔═$l═╗\n",(map{sprintf"║ %-${n}s ║\n",$_}@F),"╚═$l═╝";

Đầu tiên, chúng tôi tìm thấy chiều dài dòng dài nhất $n , bằng cách sắp xếp số lượng độ dài của tất cả các dòng.

Chúng tôi đặt $llà thanh tiêu đề / chân trang thành$n sự lặp lại của ký tự khung ngang.

Sau đó, chúng tôi in từng dòng được định dạng sang trái trong một trường chiều rộng $n , được kẹp ở giữa các ký tự khung.

Kết quả:

╔═══════════╗
║   |\_/|   ║
║  / @ @ \  ║
║ ( > * < ) ║
║  `>>x<<'  ║
║  /  O  \  ║
╚═══════════╝

Pyth, 44 ký tự (58 byte)

++\╔K*JhheSlR.z\═\╗jbm+\║+.[+;d;J\║.z++\╚K\╝

Giải trình

++\╔K*JhheSlR.z\═\╗                          - print out the first line
           lR.z                              -        map(len, all_input())
          S                                  -       sorted(^)
         e                                   -      ^[-1]
       hh                                    -     ^+2
      J                                      -    autoassign J = ^
     *         \═                            -   ^*"═"
    K                                        -  autoassign K = ^
++\╔             \╗                          - imp_print("╔"+^+"╗")

                   jbm+\║+.[+;d;J\║.z        - print out the middle
                   jb                        - "\n".join(V)
                     m             .z        -  [V for d in all_input()]
                      +\║+       \║          -   "║"+V+"║"
                          .[   ;J            -    pad(V, " ", J)
                            +;d              -     " "+d

                                     ++\╚K\╝ - print out the end
                                     ++\╚K\╝ - imp_print("╚"+K+"╝")

Hãy thử nó ở đây.

PHP 5.3, 209 byte

Điều này chỉ hoạt động bằng cách sử dụng OEM 860 mã hóa . Nó là một superset mở rộng ASCII, được sử dụng trong các phiên bản DOS của Bồ Đào Nha. Vì tôi là người Bồ Đào Nha (và tôi đã từng thích thực hiện các "khung" này trong Pascal) và đây là một mã hóa tiêu chuẩn, tôi đã tiếp tục với điều này:

<?foreach($W=explode('
',$argv[1])as$v)$M=max($M,strlen($v)+2);printf("É%'Í{$M}s»
º%1\${$M}sº
%2\$s
º%1\${$M}sº
È%1\$'Í{$M}s¼",'',join('
',array_map(function($v)use($M){return str_pad(" $v ",$M);},$W)));

Đây là cơ sở64:

PD9mb3JlYWNoKCRXPWV4cGxvZGUoJwonLCRhcmd2WzFdKWFzJHYpJE09bWF4KCRNLHN0cmxlbigkdikrMik7cHJpbnRmKCLilZQlJ+KVkHskTX1z4pWXCuKVkSUxXCR7JE19c+KVkQolMlwkcwrilZElMVwkeyRNfXPilZEK4pWaJTFcJCfilZB7JE19c+KVnSIsJycsam9pbignCicsYXJyYXlfbWFwKGZ1bmN0aW9uKCR2KXVzZSgkTSl7cmV0dXJuIHN0cl9wYWQoIiAkdiAiLCRNKTt9LCRXKSkpOw==

Câu trả lời này dựa trên câu trả lời của tôi trên: https://codegolf.stackexchange.com/a/57883/14732 (việc nâng vật nặng đã được thực hiện ở đó, chỉ cần co giật một chút).

Python 3, 119 byte

def f(x): 
 n='\n';s="║ ";e=" ║";h=(x.find(n)+2)*"═";return"╔"+h+"╗"+n+s+x.replace(n,e+n+s)+e+n+"╚"+h+"╝"

126 byte

import sys
o=["║ %s ║\n"%j[:-1] for j in sys.stdin]
h="═"*(len(o[0])-3)
print("╔"+h+"╗\n"+"".join(o)+"╚"+h+"╝")

Đầu vào:

hello
there
  !  

Đầu ra:

╔═══════╗
║ hello ║
║ there ║
║   !   ║
╚═══════╝

Python 2, 115 byte

def f(i):w='═'*(i.find('\n')+2);return'╔%s╗\n║ %s ║\n╚%s╝'%(w,' ║\n║ '.join(i.split('\n')),w)

Có vẻ ngắn hơn 115 ở đây, nhưng tệp làm việc bao gồm chữ ký đánh dấu BOM UTF-8 3 byte, tăng tối đa 115 byte. Nếu bạn chạy nó trong Python 3, bạn sẽ không cần BOM và nó sẽ xuống tới 112 byte.

C, 290 byte

Chức năng đánh gôn B, với sự phụ thuộc; nhận đầu vào là char kết thúc null *

#define l(s) strlen(s)
p(char*s,int n){while(n--)printf(s);}
B(char*s){char*t=strtok(s,"\n");int x=l(t),z=1;while(t=strtok(0,"\n"))z++,x=l(t)>x?l(t):x;p("╔",1);p("=",x+2);p("╗\n",1);while(z--)printf("║ %s", s),p(" ",x-l(s)),p(" ║\n",1),s+=l(s)+1;p("╚",1);p("=",x+2);p("╝\n",1);}

Chức năng hơi vô dụng trong chương trình đầy đủ

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1024

// GOLF-BEGIN =>
#define l(s) strlen(s)
// since multibyte chars don't fit in char: use char* instead
void p (char*s,int n){ while(n--)printf(s); } 
void B (char *s){
    char *t = strtok(s,"\n");
    int x=l(t), z=1;
    while(t=strtok(0,"\n"))z++,x=l(t)>x?l(t):x;  
    // x is l(longest line), z is #lines
    p("╔",1);p("=",x+2);p("╗\n",1);
    while(z--)printf("║ %s", s),p(" ",x-l(s)),p(" ║\n",1),s+=l(s)+1;
    p("╚",1);p("=",x+2);p("╝\n",1);       
}
// <= GOLF-END

int main(int argc, char **argv) {
    char buffer[MAX];
    memset(buffer, 0, MAX);
    FILE *f = fopen(argv[1], "rb");
    fread(buffer, 1, MAX, f); 
    B(buffer);
    return 0;
}

đầu vào

     _.,----,._
   .:'        `:.
 .'              `.
.'                `.
:                  :
`    .'`':'`'`/    '
 `.   \  |   /   ,'
   \   \ |  /   /
    `\_..,,.._/'
     {`'-,_`'-}
     {`'-,_`'-}
     {`'-,_`'-}
      `YXXXXY'
        ~^^~

đầu ra

╔======================╗
║      _.,----,._      ║
║    .:'        `:.    ║
║  .'              `.  ║
║ .'                `. ║
║ :                  : ║
║ `    .'`':'`'`/    ' ║
║  `.   \  |   /   ,'  ║
║    \   \ |  /   /    ║
║     `\_..,,.._/'     ║
║      {`'-,_`'-}      ║
║      {`'-,_`'-}      ║
║      {`'-,_`'-}      ║
║       `YXXXXY'       ║
║         ~^^~         ║
╚======================╝

C đánh golf lời khuyên đánh giá cao!