एंटी-एलियासिंग ASCII कला

33

पृष्ठभूमि

ASCII कला आकृतियाँ बनाने के लिए ASCII पाठ का उपयोग करके चित्र बनाने का अभ्यास है।

एलियासिंग ASCII कला के बड़े "पिक्सल" द्वारा बनाया गया प्रभाव है, जो वर्णों का आकार है। छवि देखने में अवरुद्ध और कठिन हो जाती है। एंटी-अलियासिंग एक ढाल बनाकर और ASCII कला के कठिन किनारों को नरम करके इस प्रभाव को हटा देता है।

चुनौती

आपकी चुनौती सबसे छोटे कार्यक्रम को लिखना संभव है जो एएससीआईआई कला का एक टुकड़ा लेगा और एक ऐसे संस्करण का उत्पादन करेगा जो अल्टरनेटिव किया गया है।

किस तरह का विरोधी अलियासिंग?

सभी ASCII कला में दो प्रकार के प्रतीक शामिल होंगे: रिक्त स्थान और गैर-व्हाट्सएप। प्रत्येक गैर-व्हाट्सएप चरित्र के लिए, आपके कार्यक्रम को यह निर्धारित करना चाहिए कि क्या यह उस स्थिति में है, जहां उसे अलियास होने की आवश्यकता है। यदि यह है, तो आपको इसे सही चरित्र के साथ बदलने की आवश्यकता है। यदि ऐसा नहीं है, तो चरित्र वही रहता है।

आपको कैसे पता चलेगा कि किसी किरदार को अलियास होने की जरूरत है? इसका उत्तर वर्णों पर निर्भर करता है जो वर्ण के ठीक ऊपर, नीचे, बाएँ और दाएँ होते हैं ( विकर्ण नहीं )। यहाँ जब विरोधी aliasing की आवश्यकता है, का एक चार्ट जहां है ?और xकिसी भी गैर-सफ़ेद चरित्र के लिए खड़े हो सकते हैं।

 x? ->  d?
 ?      ? 


?x  -> ?b 
 ?      ? 

 ?      ? 
?x  -> ?F 


 ?      ? 
 x? ->  Y?



 x  ->  ;   Note: This character has been changed from _ to ;
 ?      ? 

 ?      ? 
 x  ->  V 



?x  -> ?> 



 x? ->  <?



 x  ->  @

इनपुट (और उदाहरण पूर्व विरोधी एलिसिंग ASCII कला)

सबसे पहले, इनपुट की दो लाइनें होंगी (STDIN के लिए), एक नंबर H के बाद एक नंबर W होगा। उसके बाद प्रत्येक W अक्षर के H अक्षर होंगे (प्रत्येक नई लाइन को छोड़कर)। ये निम्नलिखित पंक्तियाँ ASCII कला होंगी जिन्हें अलियास-विरोधी होने की आवश्यकता है। यहाँ एक उदाहरण इनपुट है (सुंदर नहीं, लेकिन एक परीक्षण):

7
9
  888888 
 888888  
999 98  7
 666666  
  666666 
   6666  
    6

आउटपुट (और विरोधी अलियास कला का उदाहरण)

आपका कार्यक्रम ASCII कला (समान आयामों) के STDOUT में आउटपुट होना चाहिए, जो कि एंटी-अलियास किया गया है। यहाँ उपरोक्त इनपुट के लिए आउटपुट है। ध्यान दें कि बॉर्डर कैरेक्टर्स को बॉर्डरिंग व्हाट्सएप कैसे माना जाता है।

  d8888> 
 d8888F  
<99 98  @
 Y6666b  
  Y6666> 
   Y66F  
    V

यह अच्छा नहीं लग सकता है (कोड ब्लॉक में लाइनों के बीच की जगह के कारण), यह बड़े ASCII कला के साथ बेहतर दिखता है, और उपयोग किए गए सटीक फ़ॉन्ट पर गुणवत्ता निर्भर करती है।

एक और उदाहरण

इनपुट

12
18
   xx  xxx  xxx   
  xxxx  xxx  xxx  
 xxxxxx  xxx  xxx 
xxx  xxx  xxx  xxx
xxxx xxx  xxx  xxx
 xxxxxx  xxx  xxx 
  xxxx  xxx  xxx  
x  xx  xxx  xxx  x
xx    xxx  xxx  xx
xxx  xxx  xxx  xxx
xxxx  xxx  xxx  xx
xxxxx  xxx  xxx  x

उत्पादन

   db  <xb  <xb   
  dxxb  Yxb  Yxb  
 dxxxxb  Yxb  Yxb 
dxx  xxb  xxb  xxb
Yxxb xxF  xxF  xxF
 YxxxxF  dxF  dxF 
  YxxF  dxF  dxF  
;  YF  dxF  dxF  ;
xb    dxF  dxF  dx
xxb  <xF  <xF  <xx
xxxb  Yxb  Yxb  Yx
Yxxx>  Yx>  Yx>  V

नियम, प्रतिबंध और नोट्स

आपका प्रोग्राम केवल मुद्रण योग्य ASCII वर्णों में लिखा जाना चाहिए, ताकि हम कार्यक्रमों से कला बना सकें। इसके अलावा, मानक कोड-गोल्फ नियम लागू होते हैं।

code-golf  ascii-art  printable-ascii 
— PhiNotPi
स्रोत
चूंकि अभी तक कोई जवाब नहीं है, इसलिए मैंने एंटी-अलियासिंग चार्ट में एक चरित्र को बदल दिया है। _बन गया है ;क्योंकि यह बेहतर काम करता है।
— फीनोटपी
यह मेरा पसंदीदा कोड गोल्फ प्रश्न हो सकता है। 4 अलग-अलग भयानक समाधानों की तरह काम करना।
— १२:१२ पर captncraig
हालांकि मैं भ्रमित हूं। आप कहते हैं कि विकर्णों की गणना नहीं होती है, लेकिन आपके आरेख सभी विकर्णों को भरने वाले प्रश्न चिह्न दिखाते हैं। उदाहरणों में मैं जो देखता हूं, वह केवल पक्षों को देखने के लिए सुरक्षित हो सकता है, लेकिन मैं भ्रमित हो सकता हूं? क्या विकर्ण कभी मायने रखते हैं?
— captncraig
नहीं, विकर्ण कभी मायने नहीं रखते। यह शायद अधिक स्पष्ट होगा यदि मैंने चार्ट से विकर्णों को हटा दिया।
— PhiNotPi
मुझे लगता है कि आपके उदाहरण में एक टाइपो हो सकता है; मेरा मानना ​​है कि दाएं हाथ के कॉलम में अंदर की तरफ Ys होना चाहिए। हालांकि, इस सवाल का जवाब देने में मज़ा आया, अच्छा सवाल: D
— एड जेम्स

जवाबों:

8

रूबी, 180 168 वर्ण

gets
w=1+gets.to_i
f=*(readlines*"").chars
f.zip(f[1..-1]+s=[" "],s+f,s*w+f,f[w..-1]+s*w){|a,*b|$><<"@;V#{a}>bF#{a}<dY#{a*5}"[a>" "?(b.map{|y|y>" "?1:0}*"").to_i(2):3]}

एक और रूबी कार्यान्वयन जो एक ज़िप दृष्टिकोण लेता है। आप दूसरा उदाहरण ऑनलाइन देख सकते हैं ।

संपादित करें:readlines 12 वर्णों का उपयोग करना सहेजता है।

— हावर्ड
स्रोत
6

रूबी 275 265 263 261 258 254 244 243 214 212 207

H=0...gets.to_i
W=0...gets.to_i
G=readlines
z=->x,y{(H===y&&W===x&&' '!=G[y][x])?1:0}
H.map{|j|W.map{|i|l=G[j][i]
G[j][i]="@V;#{l}>Fb#{l}<Yd#{l*5}"[z[i+1,j]*8+z[i-1,j]*4+z[i,j+1]*2+z[i,j-1]]if' '!=l}}
puts G

नमूना 1: http://ideone.com/PfNMA

नमूना २: http://ideone.com/sWijD

— क्रिस्टियन लुपस्कू
स्रोत
1) रेंज परिभाषा के आसपास कोष्ठक आवश्यक नहीं है। 2) के 0..h-1रूप में लिखा जा सकता है 0...h। 3) के रूप में G=[];h.times{G<<gets}लिखा जा सकता है G=readlines, इसी तरह अपने सी # कोड में। 4) चरण 3 के बाद। चर एच बेकार हो जाता है, एच और डब्ल्यू के मूल्यों का उपयोग केवल एक बार किया जाता है, इसलिए h=gets.to_i;w=gets.to_i;H=(0..h-1);W=(0..w-1)इसे लिखा जा सकता है H=0...gets.to_i;W=0...gets.to_i। 5) इस मामले में andलिखा जा सकता है &&, जिसे आसपास के रिक्त स्थान की आवश्यकता नहीं है। 6) आपके पास एक अतिरिक्त है; और आपने फ़ाइल के अंत में नई पंक्ति को गिना, जो आवश्यक नहीं है। इसका मतलब 214 वर्ण: ideone.com/CiW0l
— मैनटवर्क
वाह धन्यवाद! मुझे पता था कि सुधार किए जाने हैं, लेकिन कभी नहीं सोचा था कि कई थे । मैंने कोशिश की थी H=0..gets.to_iजब मैंने कोड लिखा था, लेकिन यह काम नहीं कर रहा था (जाहिर है कि यह अन्य कारणों से होना चाहिए)।
— क्रिस्टियन लुपस्कू
1
फिर भी दो बिंदु जहां आप कम से कम 7 वर्णों को कम कर सकते हैं: 1) आप 2 के mapबजाय उपयोग कर सकते हैं each) के z=->...बजाय def z...end।
— हॉवर्ड
@ हावर्ड धन्यवाद, मैंने बदलाव के mapबजाय आवेदन किया है each। हालांकि, लैम्ब्डा सिंटैक्स के लिए, मुझे लगता है कि इसके बजाय zफॉर्म के होने की आवश्यकता होगी , इस प्रकार वर्ण गणना में थोड़ा सा जोड़ दिया जाएगा। कृपया मुझे बताएं कि क्या मुझे कुछ याद आ रहा है। z.call(args)z(args)
— क्रिस्टियन लुपस्कू
@ हॉवर्ड नेवरमाइंड, मुझे अभी पता चला कि मैं क्या याद कर रहा था। मैं लैम्बडा []उपयोग करने के लिए अपडेट करूंगा ।
— क्रिस्टियन लुपस्कू
4

जावास्क्रिप्ट, 410 वर्ण:

function(t){m={"10110":"b","11100":"d","01101":"Y","00111":"F","10100":";","00101":"V","00110":">","01100":"<","00100":"@"},d="join",l="length",t=t.split('\n').splice(2),t=t.map(function(x)x.split('')),f=function(i,j)t[i]?(t[i][j]||' ')==' '?0:1:0;for(o=t[l];o--;){for(p=t[o][l];p--;){y=[f(o+1,p),f(o,p+1),f(o,p),f(o,p-1),f(o-1,p)],t[o][p]=m[y[d]('')]||t[o][p]}}t=t.map(function(x)x[d](''))[d]('\n');return t;}

ungolfed:

function(t){
    m={
        "10110":"b",
        "11100":"d",
        "01101":"Y",
        "00111":"F",
        "10100":";",
        "00101":"V",
        "00110":">",
        "01100":"<",
        "00100":"@"
    },
    d="join",
    l="length",
    t=t.split('\n').splice(2),
    t=t.map(function(x) x.split('')),
    f=function(i,j) t[i]?(t[i][j]||' ')==' '?0:1:0;

    for(o=t[l];o--;){
        for(p=t[o][l];p--;){
            y=[f(o+1,p),f(o,p+1),f(o,p),f(o,p-1),f(o-1,p)],

            t[o][p]=m[y[d]('')]||t[o][p]
        }
    }
    t=t.map(function(x)x[d](''))[d]('\n');
    return t;
}

मूल, 440 अक्षर:

function (t){m={"10110":"b","11100":"d","01101":"Y","00111":"F","10100":";","00101":"V","00110":">","01100":"<","00100":"@"},s="split",d="join",l="length",t=t[s]('\n').splice(2),t=t.map(function(x) x[s]('')),f=function(i,j)i<0||i>=t[l]?0:(j<0||j>=t[i][l]?0:t[i][j]==' '?0:1);for(o=t[l];o--;){for(p=t[o][l];p--;){y=[f(o+1,p),f(o,p+1),f(o,p),f(o,p-1),f(o-1,p)],h=m[y[d]('')];if(h){t[o][p]=h}}}t=t.map(function(x) x[d](''))[d]('\n');return t;}

एनबी मैंने माना है कि पहले दो इनपुट लाइनें वास्तव में अप्रासंगिक हैं और निम्नलिखित पंक्तियों का आकार एक सही है। मैं यह भी कह रहा हूँ कि जब मुझे मौका मिले तो मैं इस पर कुछ और अंक काट सकता हूँ!

— एड जेम्स
स्रोत
1
मीटर की घोषणा की जगह m={22:"b",28:"d",13:"Y",7:"F",20:";",5:"V",6:">",12:"<",4:"@"}के साथ तो परिवर्तित मीटर के सबस्क्रिप्ट parseInt(): m[parseInt(y[d](''),2)]। यह आकार को 373 वर्णों तक कम करता है।
— मैनटवर्क
3

अजगर, 259 चरस

H=input()
W=input()+1
I=' '.join(raw_input()for i in' '*H)
for i in range(H):print''.join(map(lambda(s,a,b,c,d):(s*5+'dY<'+s+'bF>'+s+';V@'+' '*16)[16*(s==' ')+8*(a==' ')+4*(b==' ')+2*(c==' ')+(d==' ')],zip(I,I[1:]+' ',' '+I,I[W:]+' '*W,' '*W+I))[i*W:i*W+W-1])

कार्यक्रम इनपुट को एक स्ट्रिंग I(लाइनों को अलग करने वाली रिक्त स्थान के साथ) में पढ़ता है , 5-ट्यूपल्स की एक सूची को सम्मिलित करता है जिसमें चरित्र और उसके चार आस-पास के अक्षर होते हैं, फिर स्ट्रिंग इंडेक्सिंग का उपयोग करके परिणाम चरित्र को देखता है।

— कीथ रान्डेल
स्रोत
3

PHP - 359 330 282 268 257 वर्ण

<?php
$i=fgets(STDIN)+0;$w=fgets(STDIN)+1;$s='';$m='@<;d>0b0VY00F000';
for(;$i--;)$s.=fgets(STDIN);
for(;++$i<strlen($s);){
$b=trim($s[$i])?0:15;
foreach(array($i+1,$i+$w,$i-1,$i-$w)as$k=>$x)
$b|=pow(2,$k)*(isset($s[$x])&&trim($s[$x]));
echo $m[$b]?$m[$b]:$s[$i];}
— रस्टी फॉकस
स्रोत
@PhiNotPi यह काम नहीं कर रहा था क्योंकि मेरी स्थानीय रूप से सहेजी गई परीक्षण फ़ाइलों में विंडोज़-स्टाइल ईओएल था \r\n। मैंने यूनिक्स स्टाइल ईओएल के साथ काम करने के लिए अपना कोड अपडेट किया \n।
— रस्टी फॉसक
ठीक है, यह अब काम करने लगता है।
— PhiNotPi
2

अजगर, 246 241

H=input();W=1+input()
S=' '
o=W*S
F=o+'\n'.join((raw_input()+o)[:W-1]for k in range(H))+o
print ''.join((16*x+'@;<d>b'+2*x+'V'+x+'Y'+x+'F'+3*x)[
16*(x>S)|8*(a>S)|4*(l>S)|2*(r>S)|(b>S)]for
x,a,l,r,b in zip(F[W:-W],F,F[W-1:],F[W+1:],F[2*W:]))

WC और नमूना 2 पर परीक्षण, शीर्ष पर रूबी समाधान के उत्पादन के साथ अलग: 

t:~$ wc trans.py && python trans.py < lala2 > o && diff -q o ruby_out2_sample
  2 11 241 trans.py
t:~$
— edwkar
स्रोत
1

सी # 591 563

string A(string t){var s=new StringReader(t);var h=int.Parse(s.ReadLine());var w=int.Parse(s.ReadLine());var lines=s.ReadToEnd().Split(new[]{"\r\n"},StringSplitOptions.None).Select(x=>x.ToCharArray()).ToArray();for(var i=0;i<h;i++)for(var j=0;j<w;j++){var c=lines[i][j];if(c==' ')continue;var n=(i>0?(lines[i-1][j]!=' '?1:0):0)+(i<h-1?(lines[i+1][j]!=' '?2:0):0)+(j>0?(lines[i][j-1]!=' '?4:0):0)+(j<w-1?(lines[i][j+1]!=' '?8:0):0);lines[i][j]=new[]{'@','V',';',c,'>','F','b',c,'<','Y','d',c,c,c,c,c}[n];}return string.Join("\r\n",lines.Select(l=>new string(l)));}
— क्रिस्टियन लुपस्कू
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.