Bunun gibi bir metin verildiğinde:

# #### ## #
## #  ##  #
   ####  ##

Aynı metni çıktı, ancak pikselleri karakterlerle birleştirerek ─│┌┐└┘├┤┬┴┼. Bir pikselin komşuları yoksa, değiştirmeyin.

Yani son metnin çıktısı:

│ ─┬── ┌─ │
└─ │  ┌┘  │
   └──┘  ─┘

• Bir boolean dizisi olarak girişi alabilirsiniz.
• Giriş her zaman en az 1 piksel içerecektir.
• Kutu çizim karakterlerini 1 bayt olarak sayabilirsiniz.
• Girişin boşluklarla doldurulduğunu varsayabilirsiniz.

Test durumları

## #
=>
── #

###
 #
=>
─┬─
 │

##### ##
 # #  #
########
=>
─┬─┬─ ┌─
 │ │  │
─┴─┴──┴─

 # #
#####
 # #
=>
 │ │
─┼─┼─
 │ │

# # # # #
 # # # #
# # # # #
 # # # #
# # # # #
=>
# # # # #
 # # # #
# # # # #
 # # # #
# # # # #

#####
#####
#####
#####
#####
=>
┌┬┬┬┐
├┼┼┼┤
├┼┼┼┤
├┼┼┼┤
└┴┴┴┘

Bu kod-golf olduğundan , en kısa kod kazanır.

Jöle , 60 52 51 50 49 48 bayt

ṖḤ0;+Ḋ×
“µ³Q~E!G⁸ṗṫ\’ḃ61+9471Ọ⁾# j
ZÑ€4×Z++Ñ€ị¢Y

@ Dennis sayesinde bir bayt kaydedildi .

Giriş 1 ve 0'lı bir boolean dizisidir. Her sütun üzerinde ve her boyuttaki her bir ekin başını ve kuyruğunu bir çift ikili basamağa ondalık basamağa dönüştüren her bir satır boyunca yinelenir ve bunu, her bir ekin merkezi ile çarpar. Sonra endeksi bulmak için kendisi ile toplar '#───│┌┐┬│└┘┴│├┤┼ '.

Çevrimiçi deneyin! ( dava 2 ) ( dava 3 ) ( dava 4 )

açıklama

Bu benim aynı fikre dayanıyor cevap J ama bunun yerine her 3x3 altdizilim üzerine işleme, ben her satır ve hala endekslerinin aynı tabloyu elde ederken her sütun üzerinde işlem.

Baytların yarısından fazlası, kutu karakterlerinin listesini oluşturmak için harcanır '#───│┌┐┬│└┘┴│├┤┼ '. String değişmezleri “Jelly ile başlıyor ve terminatörlerine bağlı olarak farklı anlamlara sahip. Burada terminatör ’, dizginin Jelly kod sayfasına göre her karakterin kod noktaları olarak ayrıştırılacağı ve taban 250 basamaklık bir listeden ondalık basamağa dönüştürüleceği anlamına gelir.

“µ³Q~E!G⁸ṗṫ\’ => 10041542192416299030874093
(bijective base 61) => [1, 1, 1, 3, 13, 17, 45, 3, 21, 25, 53, 3, 29, 37, 61]
(add 9471 and convert to char) => '───│┌┐┬│└┘┴│├┤┼'

Sonra, bu ondalık sayıyı, 61 numaralı temel kaidedeki bir sayı listesine dönüştürün ve kutu karakterlerinin aralığına taşımak ve her birini Python'ları kullanarak dönüştürmek için her birini 9471 artırın chr. Sonra hazır bir karakterle hazırlayın ”#ve bir boşluk ekleyin ⁶.

ṖḤ0;+Ḋ×  Helper link - Input: 1d list A
Ṗ        Get all of A except the last value
 Ḥ       Double each value in it
  0;     Prepend a 0
    +    Add elementwise with
     Ḋ     All of A except the first value
      ×  Multiply elementwise by A

“µ³Q~E!G⁸ṗṫ\’ḃ61+9471Ọ⁾# j  Nilad. Represents '#───│┌┐┬│└┘┴│├┤┼ '
“µ³Q~E!G⁸ṗṫ\’               Get the code points of each char in the string and
                            convert from a list of base 250 digits to decimal
             ḃ61            Convert that to a list of digits in bijective base 61
                +9471       Add 9400 to each
                     Ọ      Convert from ordinals to chars, gets '───│┌┐┬│└┘┴│├┤┼'
                      ⁾#    A pair of chars ['#', ' ']
                         j  Join the pair using the box characters

ZÑ€4×Z++Ñ€ị¢Y  Input: 2d list M
Z              Transpose
 р            Apply the helper link to each row of the transpose (each column of M)
   4×          Multiply each by 4
     Z         Transpose
      +        Add elementwise with M
       +       Add elementwise with
        р       The helper link applied to each row of M
          ị¢   Use each result as an index to select into the nilad
            Y  Join using newlines
               Return and print implicitly

J , 82 72 66 bayt

(ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]

Giriş 1 ve 0'lı bir boolean tablodur. Kurallar, kutu karakterlerinin her birinin üç değil bir bayt olarak sayıldığını ve burada uygulandığını belirtir.

kullanım

   f =: (ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]
   m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
   m { ' #'
# #### ## #
## #  ##  #
   ####  ##
   f m
│ ─┬── ┌─ │
└─ │  ┌┘  │
   └──┘  ─┘
   ' #' {~ m =: 5 5 $ 1
   f m
┌┬┬┬┐
├┼┼┼┤
├┼┼┼┤
├┼┼┼┤
└┴┴┴┘
   ' #' {~ m =: 5 9 $ 1 0
# # # # #
 # # # # 
# # # # #
 # # # # 
# # # # #
   f m
# # # # #
 # # # # 
# # # # #
 # # # # 
# # # # #

açıklama

İlk önce giriş her tarafta 0 ile doldurulur.

   ] m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
1 0 1 1 1 1 0 1 1 0 1
1 1 0 1 0 0 1 1 0 0 1
0 0 0 1 1 1 1 0 0 1 1
   (0,.~0,.0,~0,]) m
0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 1 1 1 1 0 1 1 0 1 0
0 1 1 0 1 0 0 1 1 0 0 1 0
0 0 0 0 1 1 1 1 0 0 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0

Daha sonra 3 büyüklüğündeki her bir alt dizi seçilir

   3 3 <;._3 (0,.~0,.0,~0,]) m
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Ardından, her alt dizideki değerlerin yalnızca 5'i göz önünde bulundurulur

┌───┐
│xAx│
│CED│
│xBx│
└───┘

Değerler ABCDher alt diziyi düzleştirerek ve endekslerde seçerek seçilir 1 7 3 5. Bu değerler E4. indekste olanla çarpılır . Daha sonra bir ikili basamaklar listesinden ondalık basamağa dönüştürülür ve arttırılır E. xDeğerleri gerekli değildir.

   3 3 (4&{([+2#.*)1 7 3 5&{)@,;._3 (0,.~0,.0,~0,]) m
 5 0 2  8 4 3  0  6 3 0  5
10 3 0 13 0 0  6 11 0 0 13
 0 0 0 10 4 4 11  0 0 2 11

Bu, aşağıdaki tabloya göre hangi karakterin çizileceğini seçmek için bir indeks olarak kullanılır (golf oynamak için biraz yeniden sıralandı). Son sütun, her alt dizinin çıktı değeri ile bir kutu karakterine eşleşir.

 0  (space)  0
 1  #        1
 2  ┌        6
 3  ┬        8
 4  ┐        7
 5  ├        14
 6  ┼        16
 7  ┤        15
 8  └        10
 9  ┴        12
10  ┘        11
11  │        5, 9, 13
12  ─        2, 3, 4

Ayrıca, J'de, dize ' #───│┌┐┬│└┘┴│├┤┼'gereken 17 karakter için uzunluğu 47 (her bayt için) olacak şekilde 8 bit karakter kullanır. Komut ucp, uzunluğu 17 olmasına izin veren 16 bit karakterlere dönüştürür.

JavaScript (ES6), 155 121 103 102 karakter

let f =
    
s=>s.replace(/#/g,(c,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]==c,8*t(w=s.search`
`+1)+4*t(1)+2*t(-1)+t(-w)])

console.log(f(
  '# #### ## #\n' +
  '## #  ##  #\n' +
  '   ####  ##'
));

Düzenleme: ETHproductions yardımı ile 18 bayt kaydedildi
Düzenleme: olarak değiştirilen (1) parametresini kullanarak 1 bayt kaydedildi'#'

Nasıl çalışır

#Giriş dizesinde bulunan tüm karakterleri yineleriz . Her biri için, komşusunun da işlevi #kullanan karakterler olup olmadığını test ediyoruz t():

t = x => s[p + x] == c  // where c = '#'

Parametre xbir t()fonksiyonu mevcut konumuna göre komşu dengelenir p. Sol / sağ komşuları test etmek için -1 / + 1 ve üst / alt komşular için -w / + w kullanıyoruz w(bir satırın genişliği, yani ilk satır sonu + 1'in konumu).

Her komşuya, aşağıdaki pusulaya göre farklı bir ağırlık (1, 2, 4 veya 8) atanır:

  1
2 + 4
  8

Her ağırlık kombinasyonu [0 .. 15] 'te benzersiz değere yol açar. Örneğin, üstteki komşu ve sağdaki komşu ayarlanmışsa, toplam 1 + 4 = 5 olacaktır, └bu tablo kullanılarak çevrilir :

00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
#  │  ─  ┘  ─  └  ─  ┴  │  │  ┐  ┤  ┌  ├  ┬  ┼

Bu nedenle, '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum]beklenen karaktere yol açar.

Python 2.7, 318 315 bayt ( 270 267 karakter)

Bunun daha fazla golf oynayabileceğinden eminim (özellikle can sıkıcı ilk satır yorumundan kurtulmak isterdim) ama işte girişim:

#encoding:utf-8
f=lambda t:(lambda l,s:'\n'.join(''.join((u'┼├┤│┬┌┐│┴└┘│───#'[(s==l[i][j-1])+2*(s==l[i][j+1])+4*(i<1 or s==l[i-1][j])+8*(i>len(l)-2 or s==l[i+1][j])],s)[s==l[i][j]]for j in range(len(l[i])-1))for i in range(len(l))))([l+' 'for l in t.split('\n')],' ')

İşte her şeyin nasıl çalıştığının bir açıklaması:

#encoding:utf-8 # Dammit, Python. This adds an extra 16 bytes!
f=lambda t:( # main lambda function
    lambda l,s: # inner lambda so we can pass it "local constants" (see last line)
        '\n'.join( # join each line
            ''.join( # join each char within the line
                (u'┼├┤│┬┌┐│┴└┘│───#'[ # string of all possible characters, indexed by binary 0-15 based on adjacent chars
                    (s==l[i][j-1])+ # left
                    2*(s==l[i][j+1])+ # right
                    4*(i<1 or s==l[i-1][j])+ # up ('i<1' just yields zero in case this is the first line, so that we don't get index problems)
                    8*(i>len(l)-2 or s==l[i+1][j])], # down ('i>len(l)-2' is same as above)
                s)[s==l[i][j]] # if original is space, choose space, else choose the previously chosen box-drawing char
                for j in range(len(l[i])-1)) # do this process for each char (excluding last, which is a space)
            for i in range(len(l))) # do this for each line
    )([l+' ' for l in t.split('\n')],' ') # call the inner lambda with two parameters: first, the text split into lines; second, a space char (actually makes code shorter)

EDIT: önce bazı boşluklar kaldırıldı for ... in ...

JavaScript (ES6), 150 139 133 131 karakter

a=>a.map((q,y)=>q.replace(/#/g,(c,x)=>"#│─┘─└─┴││┐┤┌├┬┼"[g=(X,Y=0)=>(a[Y+y]||[])[X+x]==c,g(0,1)*8+g(1)*4+g(-1)*2+g(0,-1)])).join`
`

Girdiyi bir dizi dizisi olarak alır, örn f(["###", " # "]).

Test pasajı

f=a=>a.map((q,y)=>q.replace(/#/g,(c,x)=>"#│─┘─└─┴││┐┤┌├┬┼"[g=(X,Y=0)=>(a[Y+y]||[])[X+x]==c,g(0,1)*8+g(1)*4+g(-1)*2+g(0,-1)])).join`
`

<textarea id=I rows=6># #### ## #
## #  ##  #
   ####  ##</textarea>
<br>
<button onclick="O.innerHTML=f(I.value.split('\n')).replace(/\n/g,'<br>')">Run</button>
<pre id=O></pre>

ALPACA , 414 + 2 = 416 bayt

neighbourhoodV(^ v < >);states" ";statep"#"toA when4inV p,toB when3inV p andvs,toC when3inV p and^s,toD when3inV p and>s,toE when3inV p and<s,toF when2inV p and>s andvs,toG when2inV p andvs and<s,toH when2inV p and<s and^s,toI when2inV p and^s and>s,toJ when^p orvp,toK when<p or>p;stateA"┼";stateB"┴";stateC"┬";stateD"┤";stateE"├";stateF"┘";stateG"└";stateH"┌";stateI"┐";stateJ"│";stateK"─".

-fIBayrakları gerektirir .

Bu çözüm çok fazla sayıda bayt kullanır, ancak hücresel bir otomat kullanması benzersizdir. ALPACA genellikle bir meta-dil olarak kullanılır, ancak burada bir programlama dili olarak kullanıyorum.

Ungolfed versiyonu:

neighbourhood V (^ v < >);
state s " ";
state p "#" to A when 4 in V p,
to B when 3 in V p and v s,
to C when 3 in V p and ^ s,
to D when 3 in V p and > s,
to E when 3 in V p and < s,
to F when 2 in V p and > s and v s,
to G when 2 in V p and v s and < s,
to H when 2 in V p and < s and ^ s,
to I when 2 in V p and ^ s and > s,
to J when ^ p or v p,
to K when < p or > p;
state A "┼";
state B "┴";
state C "┬";
state D "┤";
state E "├";
state F "┘";
state G "└";
state H "┌";
state I "┐";
state J "│";
state K "─".

PHP, 203 bayt

Bu muhtemelen daha kısa bir şekilde yapılabilir.

while($s=fgets(STDIN))$f[]=$s;foreach($f as$y=>&$s)for($x=strlen($s);$x--;)if($s[$x]>$b=" ")$s[$x]="#───│┘└┴│┐┌┬│┤├┼"[($s[$x-1]>$b)+2*($s[$x+1]>$b)+4*($f[$y-1][$x]>$b)+8*($f[$y+1][$x]>$b)];echo join($f);

STDIN'den girişi okur. ile koş -r.

Python 3, 149 bayt

def f(s):S=' ';w=s.find('\n')+1;t=lambda i:(s+w*S)[i]>S;return[[c,'#│─┘─└─┴││┐┤┌├┬┼'[t(p-w)+2*t(p-1)+4*t(p+1)+8*t(p+w)]][c>S]for p,c in enumerate(s)]

Gibi girdi alır ##\n #\nve benzeri çıktı döndürür ['─', '┐', '\n', ' ', '│', '\n'].

R, 199 212 bayt

EDIT: Şimdi kod pasajından ziyade bir fonksiyon.

Giriş m1 ve 0 sn matristir . Bu oldukça çirkin ve hack.

function(m){
v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
d=dim(m)+1
n=array(0,dim=d+1)
n[2:d[1],2:d[2]]=m
for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
}

Birkaç test:

> m = matrix(c(1, 1, 1, 0, 1, 0), nrow=2, byrow=TRUE)
> v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
> d=dim(m)+1
> n=array(0,dim=d+1)
> n[2:d[1],2:d[2]]=m
> for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
─┬─
 │ 
> m = matrix(rep(1, 16), ncol=4)
> v=strsplit(" #─│┘│┐│┤──└┴┌┬├┼","")[[1]]
> d=dim(m)+1
> n=array(0,dim=d+1)
> n[2:d[1],2:d[2]]=m
> for(i in 0:(d[1]-2)){for(j in 0:(d[2]-2))cat(v[1+(p<-n[2+i,2+j])*sum(2^(0:3)*n[1:3+i,1:3+j][1:4*2])+p]);cat("\n")}
┌┬┬┐
├┼┼┤
├┼┼┤
└┴┴┘

Perl, 89 88 bayt

İçin +2 içerir -0p. Özel karakterler 1 bayt olarak sayılır, ancak karakterleri tek karakter olarak göstermelerini sağlamak için -C seçeneğini eklemek en iyisidir.

STDIN'e satır boşluklu olarak giriş yapın, böylece hepsi aynı uzunlukta olsun:

perl -C connect.pl
# #### ## #
## #  ##  #
   ####  ##
^D

connect.pl:

#!/usr/bin/perl -0p
/
/;$n=".{@-}";s%#%substr"#───│└┘┴│┌┐┬│├┤┼",/\G##/+2*/#\G/+4*/#$n\G/s+8*/\G#$n#/s,1%eg

MATL, 102 karakter

Bir komşuya değer atarım (1, 2, 4 veya 8); toplamları, çizim karakterlerini içeren bir dizgede bir karakterle eşleşecektir. İyileştirmeler için hala yeterince yer olduğunu düşünüyorum, ancak kaba bir taslak için:

' #│││─┌└├─┐┘┤─┬┴┼' % String to be indexed
wt0J1+t4$(          % Get input, and append zeros at end of matrix (solely to avoid
                    %  indexing a non-existent second row/column for small inputs)
ttttt               % Get a whole load of duplicates to work on
3LXHY)              % Select rows 2:end from original matrix (one of the many dupes)
      w4LXIY)       % Select rows 1:end-1 from the 'destination' summing matrix)
             +HY(   % Add the neighbors below, store in 'destination' matrix
tIY)b3LY)2*+IY(     % +2* the neighbors above    +-------------------------------+
tHZ)b4LZ)4*+HZ(     % +4* the neighbors right    |(note: H and I contain 1:end-1 |
tIZ)b3LZ)8*+IZ(     % +8* the neighbors left     |  and 2:end respectively)      |
HH3$)               % Select the original matrix +-------------------------------+
*                % Make sure only cells that originally had a # get replaced
  1+)            % Add one because the original string is one-indexed. Index using ).

Yapılacak iyileştirmeler:

• Muhtemelen tüm toplama bölümünü, matrisin döndürülmüş kopyaları üzerinde çalışan bir tür ilmek ile değiştiriniz.
• Her şeyi hendekleyin ve matris üzerinde çalışan tek bir döngüye dayanarak bir şeyler yapın
• Orijinal diziden (?) Düzleştirilmiş bir vektör üzerinde çalışmak için modüler indeksleme kullanın

Çevrimiçi Deneyin! (kutu çizim karakterlerini desteklemiyor olabilir)