Wprowadzenie

Myślę, że wszyscy zgadzają się, że ładne zdjęcia muszą mieć ładną ramkę. Ale większość wyzwań na tej stronie dotyczących ASCII-Art chce tylko surowego obrazu i nie dba o jego zachowanie.
Czy nie byłoby miło, gdybyśmy mieli program, który pobiera trochę ASCII-Art i otacza go ładną ramką?

Wyzwanie

Napisz program, który pobiera trochę ASCII-Art jako dane wejściowe i generuje go w ładnej ramce.

Przykład:

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

staje się

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

• Musisz użyć dokładnie takich samych znaków dla ramki jak w przykładzie: ═ ║ ╔ ╗ ╚ ╝
• Góra i dół ramki są wstawiane przed pierwszym i po ostatnim wierszu danych wejściowych.
• Lewa i prawa część ramki muszą mieć dokładnie jedną dopełnienie spacji do najszerszej linii wejścia.
• Na wydruku mogą nie znajdować się początkowe ani końcowe białe spacje. Dozwolony jest tylko końcowy znak nowej linii.
• Możesz założyć, że dane wejściowe nie zawierają niepotrzebnych początkowych białych znaków.
• Możesz założyć, że wejście nie ma końcowych białych znaków w żadnym wierszu.
• Nie musisz obsługiwać pustych danych wejściowych.
• Dane wejściowe będą zawierać tylko drukowalne znaki ASCII i znaki nowej linii.

Zasady

• Dozwolona funkcja lub pełny program.
• Domyślne reguły wejścia / wyjścia.
• Obowiązują standardowe luki .
• To jest golf golfowy , więc wygrywa najmniej bajtów. Tiebreaker to wcześniejsze zgłoszenie.

Happy Coding!

Korzystając ze wspaniałej grafiki ASCII, która została stworzona w dowolnym wyzwaniu na tej stronie, zachęca się do wprowadzania danych do programu i wyświetlania go w ładnej ramce!

CJam, 45 znaków / 52 bajty

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

Próba uniknięcia tych drogich 3-bajtowych znaków była ... interesująca.

Wypróbuj online

Wyjaśnienie

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 bajtów

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

Jako przykład wrabiam bałwana „12333321” .

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

Jak to działa:

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 bajtów

Jest to 138 bajtów w kodowaniu IBM866, które w chwili pisania jest nadal obsługiwane w Firefox, ale 152 w 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 bajtów, ^{_{157 136 134}} 133 znaków

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╝

Multiline:

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╝

Przykładowe wykonanie:

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

Przykład uruchomienia ze skryptu:

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

AWK, 159 bajtów

{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"╝"}

Najwyraźniej awkmoże wydrukować Unicode, jeśli możesz dowiedzieć się, jak go wprowadzić do kodu.

Perl, 111 znaków

(wynik obejmuje +5 za flagi tłumacza)

#!/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═╝";

Najpierw znajdujemy najdłuższą długość linii $n, sortując numerycznie długości wszystkich linii.

Ustawiamy $lsię jako pasek nagłówka / stopki, który będzie $npowtórzeniem znaku poziomej ramki.

Następnie drukujemy każdą linię sformatowaną do wyrównania do lewej w polu szerokości $n, umieszczonym pomiędzy znakami ramki.

Wynik:

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

Pyth, 44 znaki (58 bajtów)

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

Wyjaśnienie

++\╔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+"╝")

Wypróbuj tutaj.

PHP 5.3, 209 bajtów

Działa to tylko przy użyciu kodowania OEM 860 . Jest to rozszerzony nadzbiór ASCII, używany w portugalskich wersjach DOS. Ponieważ jestem Portugalczykiem (i lubiłem robić te „ramki” w Pascalu), a to jest standardowe kodowanie, zacząłem z tym:

<?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)));

Oto base64:

PD9mb3JlYWNoKCRXPWV4cGxvZGUoJwonLCRhcmd2WzFdKWFzJHYpJE09bWF4KCRNLHN0cmxlbigkdikrMik7cHJpbnRmKCLilZQlJ+KVkHskTX1z4pWXCuKVkSUxXCR7JE19c+KVkQolMlwkcwrilZElMVwkeyRNfXPilZEK4pWaJTFcJCfilZB7JE19c+KVnSIsJycsam9pbignCicsYXJyYXlfbWFwKGZ1bmN0aW9uKCR2KXVzZSgkTSl7cmV0dXJuIHN0cl9wYWQoIiAkdiAiLCRNKTt9LCRXKSkpOw==

Ta odpowiedź była oparta na mojej odpowiedzi na: https://codegolf.stackexchange.com/a/57883/14732 (ciężkie podnoszenie zostało tam wykonane, wystarczyło trochę drgnąć).

Python 3, 119 bajtów

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 bajtów

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

Wkład:

hello
there
  !  

Wydajność:

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

Python 2, 115 bajtów

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

Wygląda tutaj na mniej niż 115, ale plik roboczy zawiera 3-bajtową sygnaturę BOM UTF-8, co powoduje wzrost do 115 bajtów. Jeśli miałbyś uruchomić go w Pythonie 3, nie potrzebowałbyś BOM i spadłby do 112 bajtów.

C, 290 bajtów

Funkcja gry w golfa B, z zależnościami; przyjmuje dane jako znak zakończony znakiem 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);}

Nieco niepoznana funkcja w pełnym programie

#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;
}

wkład

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

wydajność

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

Doceniamy wskazówki C do gry w golfa!