Contexte

L'art ASCII est la pratique de créer des images en utilisant du texte ASCII pour former des formes.

L'aliasing est l'effet créé par les grands "pixels" de l'art ASCII, qui correspondent à la taille des caractères. L'image devient bouchée et difficile à voir. L'anti-aliasing supprime cet effet en créant un dégradé et en adoucissant les contours de l'art ASCII.

Le défi

Votre défi est d’écrire le programme le plus court possible qui prendra un morceau d’art ASCII et produira une version anti-aliasée.

Quelle sorte d'anti-aliasing?

Tout l'art ASCII se composera de deux types de symboles: Espaces et non-blancs. Pour chaque caractère non-blanc, votre programme doit déterminer s'il est dans une position où il doit être anti-aliasé. Si c'est le cas, vous devez le remplacer par le caractère correct. Si ce n'est pas le cas, le personnage reste le même.

Comment savoir si un personnage doit être anti-aliasé? La réponse dépend des caractères qui se trouvent immédiatement au-dessus, en dessous, à gauche et à droite du caractère ( pas les diagonales ). Voici un tableau indiquant les cas où l’anti-aliasing est requis, où ?et xpeut signifier tout caractère non-blanc.

 x? ->  d?
 ?      ? 


?x  -> ?b 
 ?      ? 

 ?      ? 
?x  -> ?F 


 ?      ? 
 x? ->  Y?



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

 ?      ? 
 x  ->  V 



?x  -> ?> 



 x? ->  <?



 x  ->  @ 

Entrée (et exemple d'art ASCII pré-anti-aliasing)

Tout d'abord, il y aura deux lignes d'entrée (à STDIN), un nombre H suivi d'un nombre W. Il y aura ensuite des lignes H de caractères exactement W (à l'exception de la nouvelle ligne). Les lignes suivantes constitueront l’art ASCII qui doit être anti-aliasé. Voici un exemple d'entrée (pas beau, mais un test):

7
9
  888888 
 888888  
999 98  7
 666666  
  666666 
   6666  
    6    

Sortie (et exemple d'art anti-aliasé)

Votre programme doit sortir vers STDOUT l’art ASCII (de mêmes dimensions), qui a été anti-aliasé. Voici la sortie pour l'entrée ci-dessus. Notez que les caractères de bordure sont traités comme des espaces blancs.

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

Cela peut ne pas sembler très bon (en raison de l'espace entre les lignes du bloc de code), il est plus esthétique avec les illustrations ASCII plus volumineuses et la qualité dépend de la police utilisée.

Un autre exemple

Contribution

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

Sortie

   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

Règles, restrictions et notes

Votre programme doit être écrit en caractères ASCII imprimables uniquement, afin que nous puissions en faire des oeuvres. Autre que cela, les règles standard de code-golf s'appliquent.

Ruby, 180 168 caractères

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]}

Une autre implémentation de Ruby qui adopte une approche zip. Vous pouvez voir le deuxième exemple en cours d'exécution en ligne .

Edit: Utiliser readlinesenregistre 12 caractères.

Ruby 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

Exemple 1: http://ideone.com/PfNMA

Exemple 2: http://ideone.com/sWijD

Javascript, 410 caractères:

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

Original, 440 caractères:

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

NB J'ai supposé que les deux premières lignes d'entrée étaient en réalité sans importance et que la taille des lignes suivantes était correcte. Je pense aussi que je pourrais peut-être couper quelques caractères de plus quand j'en aurai l'occasion!

Python, 259 caractères

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])

Le programme lit l'entrée dans une chaîne unique I(avec des espaces séparant les lignes), compresse une liste de 5 tuples contenant le caractère et ses quatre caractères environnants, puis recherche le caractère obtenu à l'aide de l'indexation de chaîne.

PHP - 359 330 282 268 257 caractères

<?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];}

Python, 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 et test sur l'échantillon 2, avec la sortie de la solution de Ruby au sommet:

t:~$ wc trans.py && python trans.py < lala2 > o && diff -q o ruby_out2_sample
  2 11 241 trans.py
t:~$

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