इस अच्छे ASCII- आर्ट को फ्रेम करें

Question

परिचय

मुझे लगता है कि सभी सहमत हैं कि अच्छी तस्वीरों के लिए एक अच्छा फ्रेम होना चाहिए। लेकिन ASCII-Art के बारे में इस साइट पर ज्यादातर चुनौतियां सिर्फ कच्ची तस्वीर चाहती हैं और इसके संरक्षण की परवाह नहीं करती हैं।
क्या यह अच्छा नहीं होगा अगर हमारे पास एक ऐसा कार्यक्रम हो जो कुछ ASCII-Art को ले और इसे एक अच्छे फ्रेम के साथ घेरे?

चुनौती

एक प्रोग्राम लिखें जो कुछ ASCII-Art को इनपुट के रूप में लेता है और इसे एक अच्छे फ्रेम से घिरा हुआ आउटपुट देता है।

उदाहरण:

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

हो जाता है

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

• आपको उदाहरण के लिए फ़्रेम के समान सटीक वर्णों का उपयोग करना होगा: ═ ║ ╔ ╗ ╚ ╝
• फ्रेम के ऊपर और नीचे इनपुट की आखिरी पंक्ति के पहले और बाद में डाला जाता है।
• फ्रेम के बाएं और अधिकार वाले हिस्से में इनपुट की सबसे चौड़ी लाइन के लिए सटीक एक स्पेस पैडिंग होनी चाहिए।
• आउटपुट में कोई अग्रणी या अनुगामी व्हाट्सएप नहीं हो सकता है। केवल एक अनुगामी न्यूलाइन की अनुमति है।
• आप मान सकते हैं कि इनपुट में कोई अनावश्यक प्रमुख व्हाट्सएप नहीं है।
• आप मान सकते हैं कि इनपुट में किसी भी लाइन पर कोई अनुगामी व्हाट्सएप नहीं है।
• आपको खाली इनपुट को संभालने की आवश्यकता नहीं है।
• इस इनपुट में केवल मुद्रण योग्य ASCII-वर्ण और नए अंक होंगे।

नियम

• कार्य या पूर्ण कार्यक्रम की अनुमति है।
• इनपुट / आउटपुट के लिए डिफ़ॉल्ट नियम ।
• मानक खामियां लागू होती हैं।
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट-काउंट जीतता है। टाईब्रेकर पहले जमा करना है।

हैप्पी कोडिंग!

कुछ महान ASCII- कला का उपयोग करना, जो कि इस साइट पर किसी भी चुनौती में उत्पन्न हुआ था, आपके कार्यक्रम के इनपुट के रूप में और इसे एक अच्छे फ्रेम के साथ दिखाना अत्यधिक प्रोत्साहित किया गया है!

Comments

ASCII कला के लिए एक गैर- ASCII फ्रेम? विधर्म!

— डेनिस

बहुत बारीकी से संबंधित। एक ही चुनौती है, लेकिन केवल फ्रेम के लिए एकल (ASCII) चरित्र का उपयोग कर रहा है।

— मार्टिन एंडर

(मुझे स्पष्ट करना चाहिए कि मुझे नहीं लगता कि यह एक धोखा है। 6 अलग-अलग पात्रों का उपयोग करने से यह बहुत #मुश्किल हो जाता है । दूसरी चुनौती को ग्रिड को घुमाकर और चार बार जोड़कर हल किया जा सकता है । यहां इस तरह के दृष्टिकोण को अपनाना सबसे अच्छा होगा। , और सबसे खराब व्यवहार्य नहीं है।)

— मार्टिन एंडर

@IsmaelMiguel मैंने पिछली प्रतियोगिता जीती है और यह नहीं देखता कि मैं अपने पुराने उत्तर को बिल्कुल कैसे अनुकूलित कर सकता हूं।

— मार्टिन एंडर

मुझे संदेह है कि DenkerAffe CP437 या ऐसा कुछ मान रहा है जहाँ फ्रेम चार भी एक बाइट हैं।

— यहोशू

Answer 1

CJam, 45 chars / 52 बाइट्स

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

उन महंगी 3-बाइट वर्ण से बचने की कोशिश कर रहा था ... दिलचस्प।

इसे ऑनलाइन आज़माएं

व्याख्या

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

Answer 2

हास्केल, 139 बाइट्स

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

एक उदाहरण के रूप में मैं स्नोमैन "12333321" तैयार कर रहा हूं ।

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

यह काम किस प्रकार करता है:

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.

Answer 3

जावास्क्रिप्ट (ईएस 6), 138 बाइट्स

यह IBM866 एन्कोडिंग में 138 बाइट्स है, जो कि लेखन के समय अभी भी फ़ायरफ़ॉक्स में समर्थित है, लेकिन UTF-8 में 152 है।

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}╝`

Comments

क्या आप वास्तव में CP437 का उपयोग करके जावास्क्रिप्ट को एन्कोड कर सकते हैं और फिर भी इसे चला सकते हैं? यदि नहीं, तो यह वास्तव में 138 बाइट्स नहीं है।

— मामा फन रोल

@ 4П37 हालांकि मुझे CP437 का समर्थन करने वाला कुछ भी नहीं मिला, फ़ायरफ़ॉक्स वर्तमान में IBM866 का समर्थन करता है जिसमें ये बॉक्स ड्राइंग वर्ण भी हैं, इसलिए मैंने अपना उत्तर अपडेट कर दिया है।

— नील

ठीक है। एक उत्थान है!

— मामा फन रोल

Answer 4

बैश, ^{_{173 171 150 148}} 147 बाइट्स, ^{_{157 136 134}} 133 अक्षर

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╝

बहुपंक्ति:

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╝

उदाहरण निष्पादन:

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

स्क्रिप्ट से नमूना चलाना:

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

Comments

आपके उदाहरण में नीचे फ्रेम और इनपुट के बीच एक एमटीपी लाइन है जो अमान्य है। ऊपर और नीचे के तख्ते को इनपुट से पहले और बाद में सीधे डाला जाना है (आपका पिछला संस्करण ठीक btw था)।

— डेनकर

अच्छा !, लेकिन अगर आप ...?${#2}+2:n))इसके बजाय लगभग 5 char बचा सकते हैं +1, तो 2 रिक्त स्थान छोड़ें और printf -v z %${n}s;इसके बजाय printf -v z " %*.s" $n।

— एफ। हौरी

@Sukminder ओके, पहले से ही असेम्बलिग था, लेकिन यह सुनिश्चित करना चाहता था कि आपके द्वारा दिखाए गए इनपुट में एक खाली लाइन न हो। मैंने यह मांग नहीं की कि आप खाली लाइनों को लीड करने या ट्राली करने का इनपुट क्लियर करें, इसलिए आप प्रोग्राम पूरी तरह से ठीक है।

— डेनकर

Answer 5

AWK, 159 बाइट्स

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

जाहिर है awkयूनिकोड प्रिंट अगर आप पता लगा सकते हैं कि कैसे कोड में इसे पाने के लिए कर सकते हैं।

Comments

मैं अब भयानक पाइपों के लिए बहुत सारे विचार कर रहा हूँ ...

— सेब

@Sebb यह मजेदार लगता है। :)

— रॉबर्ट बेन्सन

Answer 6

पर्ल, 111 अक्षर

(स्कोर में इंटरप्रेटर झंडे के लिए 5 शामिल हैं)

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

सबसे पहले, हम $nसभी लाइनों की लंबाई को क्रमबद्ध करके, सबसे लंबी रेखा की लंबाई पाते हैं।

हम $lशीर्षलेख / पाद लेख पट्टी को $nक्षैतिज फ़्रेम वर्ण की पुनरावृत्ति होने के लिए सेट करते हैं ।

फिर हम चौड़ाई के क्षेत्र में बाईं ओर संरेखित करने के लिए स्वरूपित प्रत्येक पंक्ति को मुद्रित करते हैं $n, जो फ्रेम वर्णों के बीच में विभाजित है।

परिणाम:

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

Answer 7

पायथ, 44 वर्ण (58 बाइट)

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

व्याख्या

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

इसे यहाँ आज़माएँ।

Answer 8

PHP 5.3, 209 बाइट्स

यह केवल एन्कोडिंग OEM 860 का उपयोग करके काम करता है । यह एक विस्तारित ASCII सुपरसेट है, जिसका उपयोग पुर्तगाली डॉस संस्करणों में किया जाता है। चूंकि मैं पुर्तगाली हूं (और पास्कल में ये "फ्रेम" करना मुझे पसंद था) और यह एक मानक एन्कोडिंग है, मैं इसके साथ आगे बढ़ा:

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

यहाँ आधार 64 है:

PD9mb3JlYWNoKCRXPWV4cGxvZGUoJwonLCRhcmd2WzFdKWFzJHYpJE09bWF4KCRNLHN0cmxlbigkdikrMik7cHJpbnRmKCLilZQlJ+KVkHskTX1z4pWXCuKVkSUxXCR7JE19c+KVkQolMlwkcwrilZElMVwkeyRNfXPilZEK4pWaJTFcJCfilZB7JE19c+KVnSIsJycsam9pbignCicsYXJyYXlfbWFwKGZ1bmN0aW9uKCR2KXVzZSgkTSl7cmV0dXJuIHN0cl9wYWQoIiAkdiAiLCRNKTt9LCRXKSkpOw==

यह उत्तर मेरे जवाब पर आधारित था: https://codegolf.stackexchange.com/a/57883/14732 (भारी उठाव सब वहाँ बनाया गया था, बस थोड़ा सा हिलाना था)।

Comments

कम से कम कहने के लिए प्रभावशाली :)

— मंकीज़ेउस

कोड 209 बाइट्स / वर्ण हैं। 22+58+11+5+11+24+66+12=209अंतिम 12 newlines है और जैसा कि यह डॉस है जिसका अर्थ है CRLF, या दो बाइट्स प्रति न्यूलाइन। Charactercountonline साइट नई-पंक्तियों में नहीं गिना जाता। गैर- ASCII ग्लिफ़ में से प्रत्येक OEM 860 में 1 बाइट है।

— रनियम

@Sukminder मत भूलना कि (कम से कम) Windows ASCII / पाठ मोड में फ़ाइल खोलने पर परिवर्तित हो \nजाता \r\nहै।

— इस्माइल मिगुएल

Answer 9

पायथन 3, 119 बाइट्स

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 बाइट्स

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

इनपुट:

hello
there
  !  

आउटपुट:

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

Comments

पहेलियों और कोड गोल्फ में आपका स्वागत है! अच्छा पहला जवाब! आप हमेशा पूर्ण कार्यक्रमों के बजाय फ़ंक्शंस लिख सकते हैं (जब तक कि चुनौती में स्पष्ट रूप से मना नहीं किया जाता है) जो आपको इनपुट के रूप में तर्क देकर कुछ बाइट्स को बचाने की अनुमति दे सकता है। इसके अलावा आप पाइथन 2 का उपयोग करना चाह सकते हैं, ताकि आप साथ जाकर 2 बाइट्स बचा सकें print"╔"+h+"╗\n"+"".join(o)+"╚"+h+"╝"।

— डेनकर

धन्यवाद। मैं यह पता नहीं लगा सका कि पायथन 2 में काम करने वाले हाई-बाइट्स कैसे प्राप्त किए जा सकते हैं (शायद कोडेक वातावरण चर सेट करना काम करेगा लेकिन मुझे यकीन नहीं है कि गोल्फ बाइट काउंट्स में कैसे खेलता है)। फ़ंक्शन दृष्टिकोण python2 / 3 के अंतर को समाप्त करता है, लेकिन मेरे सबसे अच्छे दृष्टिकोण में एक बाइट जोड़ता है।

— सुमनेरहेय्स

ठीक है, मैं इसे एक समारोह के रूप में 119 वर्णों तक ले गया; एक स्ट्रिंग के रूप में इनपुट लेता है। मेरा मिनी-मार्कडाउन स्पष्ट रूप से सूंघने के लिए नहीं है; लाइन 1 एक प्रमुख स्थान के साथ, बाकी (बृहदान्त्र के बाद) लाइन 2 है। 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+"╝"

— सुमेरहाइसेस

बस नए संस्करण और नए स्कोर के साथ अपनी पोस्ट को अपडेट करें (पुराने स्कोर को बाहर निकालें <s>...</s>)। इसके अलावा आप <!-- language-all: lang-python -->अपने कोड-ब्लॉक से पहले जोड़ सकते हैं अपने कोड में हाइलाइटिंग सिंटैक्स जोड़ें।

— डेनकर

यदि इनपुट गैर-आयताकार है तो यह काम नहीं करता है, जबकि सवाल यह कहता है कि किसी भी लाइन में व्हाट्सएप नहीं होगा।

— डेनिस

Answer 10

पायथन 2, 115 बाइट्स

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

यहां 115 से कम दिखता है, लेकिन काम करने वाली फ़ाइल में 3-बाइट UTF-8 BOM मार्क हस्ताक्षर शामिल हैं, यह 115 बाइट्स तक टकरा रहा है। यदि आप इसे पायथन 3 में चला रहे थे, तो आपको BOM की आवश्यकता नहीं थी और यह 112 बाइट्स तक नीचे पहुंच जाएगा।

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! दुर्भाग्य से, आपका कोड यह मानता है कि इनपुट आयताकार है, जबकि सवाल कहता है कि किसी भी लाइन में अनुगामी व्हॉट्सएप नहीं होगा।

— डेनिस

मैं 107 बाइट्स गिनता हूं। मुझे नहीं लगता कि आपको "UTF-8 BOM चिह्न हस्ताक्षर" शामिल करने की आवश्यकता है।

— कैलक्यूलेटरफलाइन

@CatsAreFluffy आप पायथन 2 का उपयोग कर रहे हैं? Python3 में सभी स्ट्रिंग्स यूनिकोड हैं, लेकिन यह Python2 के साथ ट्रिक है।

— जेनी मिलर

उफ़, मैंने पाइपों को 2 बाइट्स के रूप में गिना, लेकिन एक वास्तविक बाइटकाउंटर का उपयोग करने के बाद भी, केवल 111 बाइट्स। मुझे बताएं कि वे 5 बाइट्स कहां से आए।

— कैलकुलेटर

UTF-8 BOM 3 बाइट्स ( en.wikipedia.org/wiki/Byte_order_mark ) है। मेरी गिनती एक अधिक थी क्योंकि मेरा टेक्स्ट एडिटर एक अनुगामी न्यूलाइन जोड़ रहा था, इसलिए मेरा समाधान केवल 115 बाइट्स है। यदि आप पायथन 3 (जो यूनिकोड के रूप में सभी तारों को गिनते हैं) का उपयोग कर रहे थे, तो आप प्रमुख बीओएम बाइट्स को छोड़ सकते हैं और इसे 112 तक नीचे ला सकते हैं। लेकिन मुझे नहीं पता कि आप केवल 111 बाइट्स कैसे देख रहे हैं। btw, यहाँ मैं कैसे बीओएम जोड़ा: sed -i '1s/^\(\xef\xbb\xbf\)\?/\xef\xbb\xbf/' codeGolf.py

— जेनी मिलर

Answer 11

सी, 290 बाइट्स

Bनिर्भरता के साथ गोल्फ समारोह ; null-termized char * के रूप में इनपुट लेता है

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

पूर्ण कार्यक्रम में कुछ-कुछ अनगढ़

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

इनपुट

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

उत्पादन

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

सी गोल्फ युक्तियाँ की सराहना की!