Einführung

Ich denke, alle sind sich einig, dass schöne Bilder einen schönen Rahmen haben müssen. Aber die meisten Herausforderungen auf dieser Seite über ASCII-Kunst wollen nur das Rohbild und kümmern sich nicht um dessen Erhaltung.
Wäre es nicht schön, wenn wir ein Programm hätten, das etwas ASCII-Art enthält und es mit einem schönen Rahmen umgibt?

Die Herausforderung

Schreiben Sie ein Programm, das ASCII-Art als Eingabe und Ausgabe verwendet und von einem schönen Rahmen umgeben ist.

Beispiel:

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

wird

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

• Sie müssen genau die gleichen Zeichen für den Rahmen verwenden wie im Beispiel: ═ ║ ╔ ╗ ╚ ╝
• Der obere und der untere Rand des Frames werden vor der ersten und nach der letzten Zeile der Eingabe eingefügt.
• Der linke und der rechte Teil des Frames müssen genau einen Abstand zur breitesten Zeile der Eingabe haben.
• Die Ausgabe enthält möglicherweise keine führenden oder nachfolgenden Leerzeichen. Es ist nur eine abschließende Zeile zulässig.
• Sie können davon ausgehen, dass die Eingabe keine unnötigen führenden Leerzeichen enthält.
• Sie können davon ausgehen, dass die Eingabe in keiner Zeile nachgestellte Leerzeichen enthält.
• Sie müssen keine leeren Eingaben verarbeiten.
• Die Eingabe enthält nur druckbare ASCII-Zeichen und Zeilenumbrüche.

Regeln

• Funktion oder Vollprogramm erlaubt.
• Standardregeln für die Eingabe / Ausgabe.
• Es gelten Standardlücken .
• Dies ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl. Tiebreaker ist eine frühere Vorlage.

Viel Spaß beim Codieren!

Es wird dringend empfohlen, einige großartige ASCII-Grafiken zu verwenden, die in jeder Herausforderung auf dieser Website erstellt wurden, da die Eingabe in Ihr Programm und die Darstellung mit einem schönen Rahmen sehr empfehlenswert sind!

CJam, 45 Zeichen / 52 Bytes

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

Der Versuch, diese teuren 3-Byte-Zeichen zu vermeiden, war ... interessant.

Probieren Sie es online aus

Erläuterung

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 Bytes

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

Als Beispiel rahm ich den Schneemann "12333321" .

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

Wie es funktioniert:

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

Dies sind 138 Byte in der IBM866-Codierung, die zum Zeitpunkt des Schreibens in Firefox noch unterstützt wird, in UTF-8 jedoch 152 Byte.

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 Bytes, ^{_{157 136 134}} 133 Zeichen

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╝

Mehrzeilig:

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╝

Beispielausführung:

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

Beispiellauf vom Skript:

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

AWK, 159 Bytes

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

awkKann anscheinend Unicode drucken, wenn Sie herausfinden können, wie man es in den Code bekommt.

Perl, 111 Zeichen

(Punktzahl beinhaltet +5 für die Interpreter-Flags)

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

Zuerst ermitteln wir die längste Zeilenlänge $n, indem wir die Längen aller Zeilen numerisch sortieren.

Wir setzen $ldie Kopf- / Fußzeile als $nWiederholung des horizontalen Rahmenzeichens.

Dann drucken wir jede Zeile, die so formatiert ist, dass sie linksbündig in einem Feld mit einer Breite $nzwischen den Rahmenzeichen liegt.

Ergebnis:

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

Pyth, 44 Zeichen (58 Bytes)

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

Erläuterung

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

Probieren Sie es hier aus.

PHP 5.3, 209 Bytes

Dies funktioniert nur mit der Codierung OEM 860 . Es ist eine erweiterte ASCII-Obermenge, die in portugiesischen DOS-Versionen verwendet wird. Da ich Portugiese bin (und es liebte, diese "Frames" in Pascal zu machen) und dies eine Standardkodierung ist, habe ich Folgendes ausgeführt:

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

Hier ist die base64:

PD9mb3JlYWNoKCRXPWV4cGxvZGUoJwonLCRhcmd2WzFdKWFzJHYpJE09bWF4KCRNLHN0cmxlbigkdikrMik7cHJpbnRmKCLilZQlJ+KVkHskTX1z4pWXCuKVkSUxXCR7JE19c+KVkQolMlwkcwrilZElMVwkeyRNfXPilZEK4pWaJTFcJCfilZB7JE19c+KVnSIsJycsam9pbignCicsYXJyYXlfbWFwKGZ1bmN0aW9uKCR2KXVzZSgkTSl7cmV0dXJuIHN0cl9wYWQoIiAkdiAiLCRNKTt9LCRXKSkpOw==

Diese Antwort basierte auf meiner Antwort auf: https://codegolf.stackexchange.com/a/57883/14732 (das schwere Heben wurde alles dort gemacht, musste nur ein bisschen zucken).

Python 3, 119 Bytes

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 Bytes

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

Eingang:

hello
there
  !  

Ausgabe:

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

Python 2, 115 Bytes

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

Sieht hier kürzer aus als 115, aber die Arbeitsdatei enthält eine 3-Byte-UTF-8-Stücklistensignatur, die auf 115 Byte erhöht wird. Wenn Sie es in Python 3 ausführen würden, würden Sie die Stückliste nicht benötigen und es würde auf 112 Bytes herunterkommen.

C 290 Bytes

Golf-Funktion Bmit Abhängigkeiten; Nimmt Eingaben als nullterminiertes Zeichen *

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

Etwas ungolfed Funktion im vollen Programm

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

Eingang

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

Ausgabe

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

C Golftipps erwünscht!