Gegeben ein Text wie dieser:

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

Geben Sie denselben Text aus, indem Sie die Pixel mit den Zeichen verbinden ─│┌┐└┘├┤┬┴┼. Wenn ein Pixel keine Nachbarn hat, ändern Sie es nicht.

Die Ausgabe des letzten Textes ist also:

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

• Sie können Eingaben als boolesches Array annehmen.
• Die Eingabe enthält immer mindestens 1 Pixel.
• Sie können Box-Drawing-Zeichen als 1 Byte zählen.
• Sie können davon ausgehen, dass die Eingabe mit Leerzeichen aufgefüllt ist.

Testfälle

## #
=>
── #

###
 #
=>
─┬─
 │

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

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

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

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

Da dies Codegolf ist , gewinnt der kürzeste Code.

Jelly , 60 52 51 50 49 48 Bytes

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

Ein Byte dank @ Dennis gespeichert .

Die Eingabe ist ein boolesches Array aus Einsen und Nullen. Iteriert über jede Spalte und jede Zeile und konvertiert den Kopf und den Schwanz jedes Infixes der Größe 3 von einem Paar binärer Ziffern in eine Dezimalzahl und multipliziert diese mit der Mitte jedes Infixes. Dann summiert es es mit sich selbst, um den Index darin zu finden '#───│┌┐┬│└┘┴│├┤┼ '.

Probieren Sie es online! ( Fall 2 ) ( Fall 3 ) ( Fall 4 )

Erläuterung

Dies basiert auf der gleichen Idee wie meine Antwort in J, aber anstatt in jedem 3x3-Subarray zu verarbeiten, verarbeite ich jede Zeile und jede Spalte, während ich immer noch dieselbe Indextabelle erhalte.

Über die Hälfte der Bytes wird für die Erstellung der Liste der Box-Zeichen aufgewendet '#───│┌┐┬│└┘┴│├┤┼ '. String-Literale beginnen mit “in Jelly und haben je nach Terminator unterschiedliche Bedeutungen. Hier ’bedeutet das Abschlusszeichen , dass die Zeichenfolge als die Codepunkte jedes Zeichens gemäß der Jelly- Codepage analysiert und aus einer Liste von 250-stelligen Basisziffern in eine Dezimalzahl konvertiert wird.

“µ³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) => '───│┌┐┬│└┘┴│├┤┼'

Konvertieren Sie dann diese Dezimalstelle in eine Liste von Ziffern in der bijektiven Basis 61 und erhöhen Sie jede um 9471, um sie in den Bereich der Box-Zeichen zu verschieben, und konvertieren Sie jede mit Pythons chr. Stellen Sie dann ein Zeichen-Literal ”#voran und fügen Sie ein Leerzeichen hinzu ⁶.

ṖḤ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 Bytes

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

Die Eingabe ist eine boolesche Tabelle mit Einsen und Nullen. Die Regeln besagen, dass die Box-Zeichen jeweils ein Byte und nicht drei zählen und dass dies hier angewendet wurde.

Verwendungszweck

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

Erläuterung

Zunächst wird der Eingang allseitig mit 0en aufgefüllt.

   ] 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

Dann wird jedes Subarray der Größe 3 ausgewählt

   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│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Dann werden nur 5 der Werte in jedem Subarray berücksichtigt

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

Die Werte ABCDwerden ausgewählt, indem jedes Subarray abgeflacht und bei Indizes ausgewählt wird 1 7 3 5. Diese Werte werden mit Edem Index 4 multipliziert. Sie werden dann aus einer Liste von Binärziffern in eine Dezimalzahl konvertiert und um inkrementiert E. Die xWerte werden nicht benötigt.

   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

Dies wird als Index verwendet, um den zu zeichnenden Charakter gemäß der folgenden Tabelle auszuwählen (zum Golfen etwas neu angeordnet). Die letzte Spalte ordnet den Ausgabewert jedes Unterfelds einem Kästchen zu.

 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

Außerdem ' #───│┌┐┬│└┘┴│├┤┼'verwendet die Zeichenfolge in J 8-Bit-Zeichen, sodass sie für die 17 benötigten Zeichen eine Länge von 47 (für jedes Byte) aufweist. Der Befehl ucpkonvertiert es in 16-Bit-Zeichen, was eine Länge von 17 ermöglicht.

JavaScript (ES6), 155 121 103 102 Zeichen

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' +
  '   ####  ##'
));

Edit: 18 Byte mit Hilfe von ETHproductions gespeichert
Edit: 1 Byte mit dem 1. Parameter von replace () as gespeichert'#'

Wie es funktioniert

Wir iterieren alle #Zeichen, die in der Eingabezeichenfolge enthalten sind. Für jeden von ihnen testen wir #mit der t()Funktion, ob seine Nachbarn auch Zeichen sind :

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

Der Parameter xder t()Funktion ist der Offset des Nachbarn zur aktuellen Position p. Wir verwenden -1 / + 1, um die linken / rechten Nachbarn und -w / + w für die oberen / unteren Nachbarn zu testen (wobei wdie Breite einer Zeile ist, dh die Position des ersten Zeilenumbruchs + 1).

Jedem Nachbarn wird ein anderes Gewicht (1, 2, 4 oder 8) gemäß dem folgenden Kompass zugewiesen:

  1
2 + 4
  8

Jede Gewichtskombination führt zu einem eindeutigen Wert in [0 .. 15]. Wenn zum Beispiel sowohl der obere als auch der rechte Nachbar festgelegt sind, ist die Summe 1 + 4 = 5, was sich in der folgenden └Tabelle niederschlägt:

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

Führt '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum]daher zum erwarteten Charakter.

Python 2.7, 318 315 Bytes ( 270 267 Zeichen)

Ich bin mir sicher, dass dies weiter verbessert werden kann (insbesondere würde ich diesen nervigen ersten Kommentar gerne loswerden), aber hier ist mein Beitrag:

#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')],' ')

Hier ist eine Erklärung, wie das Ganze funktioniert:

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

BEARBEITEN: Einige Leerzeichen zuvor entfernt for ... in ...

JavaScript (ES6), 150 139 133 131 Zeichen

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

Nimmt Eingaben als Array von Zeichenfolgen, z f(["###", " # "]).

Testschnipsel

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 Bytes

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"─".

Benötigt die -fIFahnen.

Diese Lösung verwendet eine sehr große Anzahl von Bytes, ist jedoch insofern einzigartig, als sie einen zellularen Automaten verwendet. ALPACA wird normalerweise als Metasprache verwendet, aber hier verwende ich es als Programmiersprache.

Ungolfed-Version:

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 Bytes

Dies kann wahrscheinlich auf kürzere Weise erfolgen.

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

Liest die Eingabe von STDIN. renn mit -r.

Python 3, 149 Bytes

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

Nimmt Eingaben wie ##\n #\nund gibt Ausgaben wie zurück ['─', '┐', '\n', ' ', '│', '\n'].

R, 199.212 Bytes

EDIT: Es ist jetzt eine Funktion und kein Code-Snippet.

Die Eingabe ist eine Matrix maus 1 und 0. Das ist ziemlich hässlich und abgedreht.

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")}
}

Ein paar Tests:

> 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 Bytes

Beinhaltet +2 für -0p. Die Sonderzeichen werden als 1 Byte gezählt. Um sie jedoch als einzelne Zeichen anzuzeigen, sollten Sie auch die Option -C hinzufügen.

Geben Sie in STDIN den Zeilenabstand ein, damit alle Zeilen die gleiche Länge haben:

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 Zeichen

Ich weise einem Nachbarn einen Wert zu (1, 2, 4 oder 8). Ihre Summe stimmt mit einem Zeichen in einer Zeichenfolge überein, die die Zeichnungszeichen enthält. Ich denke, es gibt noch viel Raum für Verbesserungen, aber für einen groben Entwurf:

' #│││─┌└├─┐┘┤─┬┴┼' % 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 ).

Verbesserungen vorgenommen werden:

• Ersetzen Sie möglicherweise den gesamten Summierungsteil durch eine Art Schleife, die an gedrehten Kopien der Matrix arbeitet
• Lassen Sie das Ganze fallen und erstellen Sie etwas, das auf einer einzelnen Schleife basiert, die durch die Matrix arbeitet
• Verwenden Sie die modulare Indizierung, um einen abgeflachten Vektor aus dem ursprünglichen Array zu bearbeiten (?)

Probieren Sie es online! (Möglicherweise wird keine Unterstützung für Box-Zeichen unterstützt.)