Connecter les pixels

40

Étant donné un texte comme celui-ci:

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

Produisez le même texte mais en reliant les pixels aux caractères ─│┌┐└┘├┤┬┴┼. Si un pixel n'a pas de voisins, ne le changez pas.

La sortie du dernier texte est donc:

│ ─┬── ┌─ │
└─ │  ┌┘  │
   └──┘  ─┘
  • Vous pouvez prendre une entrée comme un tableau booléen.
  • L'entrée contiendra toujours au moins 1 pixel.
  • Vous pouvez compter les caractères de dessin de boîte comme 1 octet.
  • Vous pouvez supposer que l'entrée est complétée d'espaces.

Cas de test

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

Puisqu'il s'agit de , le code le plus court l'emporte.

TuxCrafting
la source
2
Dois-je utiliser le caractère de hachage en tant que pixel? Puis-je recevoir des entrées sous forme de tableau booléen?
Rohan Jhunjhunwala le
Peut-il y avoir des espaces de fin ou des nouvelles lignes?
Sanchises
btw: -|r7LJE3TW+est un remplacement approprié d'un caractère sur 1 octet pour les caractères de bloc.
Titus

Réponses:

7

Jelly , 60 52 51 50 49 48 octets

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

Enregistré un octet grâce à @ Dennis.

L'entrée est un tableau booléen de 1 et de 0. Itère sur chaque colonne et chaque ligne en convertissant la tête et la queue de chaque infixe de taille 3 d'une paire de chiffres binaires en une décimale, et les multiplie par le centre de chaque infixe. Ensuite, il résume avec lui-même pour trouver l’index '#───│┌┐┬│└┘┴│├┤┼ '.

Essayez-le en ligne! ( cas 2 ) ( cas 3 ) ( cas 4 )

Explication

Cela repose sur la même idée que ma réponse en J mais au lieu de traiter sur chaque sous-tableau 3x3, je traite chaque ligne et chaque colonne tout en obtenant le même tableau d'indices.

Plus de la moitié des octets sont utilisés pour générer la liste des caractères de la boîte '#───│┌┐┬│└┘┴│├┤┼ '. Les littéraux de chaîne commencent par Jelly et ont différentes significations en fonction de leur terminateur. Ici, le terminateur signifie que la chaîne sera analysée en tant que points de code de chaque caractère conformément à la page de code Jelly et convertie à partir d'une liste de 250 chiffres de base en un nombre décimal.

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

Convertissez ensuite cette décimale en une liste de chiffres de la base bijective 61 et incrémentez-les de 9471 pour les déplacer dans la plage des caractères de la boîte et convertissez-les chacun à l'aide de caractères Python chr. Puis ”#ajoutez-y un caractère littéral et ajoutez un espace .

ṖḤ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
milles
la source
15

J , 82 72 66 octets

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

L'entrée est une table booléenne de 1 et de 0. Les règles indiquent que les caractères de la boîte comptent chacun pour un octet et non pour trois, et cela a été appliqué ici.

Usage

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

Explication

D'abord, l'entrée est complétée par des 0 de tous les côtés.

   ] 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

Ensuite, chaque sous-réseau de taille 3 est sélectionné

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

Alors seulement 5 des valeurs de chaque sous-tableau sont considérées

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

Les valeurs ABCDsont sélectionnées en aplatissant chaque sous-tableau et en sélectionnant des indices 1 7 3 5. Ces valeurs sont multipliées par Ece qui est à l'index 4. Il est ensuite converti à partir d'une liste de chiffres binaires en une décimale et incrémenté de E. Les xvaleurs ne sont pas nécessaires.

   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

Ceci est utilisé comme index pour sélectionner le personnage à dessiner selon le tableau ci-dessous (réorganisé un peu pour jouer au golf). La dernière colonne correspond à la valeur de sortie de chaque sous-tableau à un caractère de zone.

 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

De plus, en J, la chaîne ' #───│┌┐┬│└┘┴│├┤┼'utilise des caractères de 8 bits, ce qui lui donne une longueur de 47 (pour chaque octet) pour les 17 caractères nécessaires. La commande le ucpconvertit en caractères 16 bits, ce qui lui permet d'avoir une longueur de 17.

milles
la source
13

JavaScript (ES6), 155 121 103 102 caractères

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: sauvegardé 18 octets à l’aide de ETHproductions
Edit: sauvegardé 1 octet en utilisant le 1er paramètre de replace () en tant que'#'

Comment ça marche

Nous itérons sur tous les #caractères trouvés dans la chaîne d'entrée. Pour chacun d'eux, nous testons si ses voisins sont aussi des #personnages en utilisant la t()fonction:

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

Le paramètre xde la t()fonction est le décalage du voisin par rapport à la position actuelle p. Nous utilisons -1 / + 1 pour tester les voisins gauche / droit et -w / + w pour les voisins haut / bas (où west la largeur d'une ligne, c'est-à-dire la position du premier saut de ligne + 1).

Chaque voisin se voit attribuer un poids différent (1, 2, 4 ou 8) selon le compas suivant:

  1
2 + 4
  8

Chaque combinaison de poids conduit à une valeur unique dans [0 .. 15]. Par exemple, si le voisin du haut et le voisin de droite sont définis, la somme sera de 1 + 4 = 5, ce qui se traduit par l' utilisation de cette table:

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

Par conséquent, '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum]mène au caractère attendu.

Arnauld
la source
Ha, nous avions fondamentalement la même idée;)
ETHproductions
@ETHproductions - Assez bien. ^^
Arnauld
Vraiment, vraiment belle technique là-bas. Tu m'as vraiment sur-joué :)
ETHproductions
Vous pouvez économiser 2 octets comme s=>(w=s[0].length+1,s=s.join`\n`).replace(/#/g,(_,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]>' ',t(-w)+2*t(-1)+4*t(1)+8*t(w)])
suit
Et il est en fait beaucoup plus court pour revenir à une chaîne multiligne:s=>s.replace(/#/g,(_,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]>' ',t(-w)+2*t(-1)+4*t(1)+8*t(w)],w=s.indexOf`\n`+1)
ETHproductions
8

Python 2.7, 318 315 octets ( 270 267 caractères)

Je suis sûr que cela peut être joué plus loin (en particulier j'aimerais beaucoup me débarrasser de ce commentaire de première ligne ennuyeux), mais voici mon entrée:

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

Voici une explication de la façon dont tout cela fonctionne:

#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: Supprimé quelques espaces avant for ... in ...

Hactar
la source
9
Utiliser Python 3 à la place devrait résoudre votre problème d'encodage Unicode, je pense ...
Byte Commander
6

JavaScript (ES6), 150 139 133 131 caractères

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

Prend l'entrée comme un tableau de chaînes, par exemple f(["###", " # "]).

Extrait de test

ETHproductions
la source
5

ALPACA , 414 + 2 = 416 octets

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

Nécessite les -fIdrapeaux.

Cette solution utilise un très grand nombre d'octets, mais elle est unique en ce qu'elle utilise un automate cellulaire. ALPACA est généralement utilisé comme métalangage, mais ici, je l’utilise comme langage de programmation.

Version non-golfée:

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 "─".
DanTheMan
la source
4

PHP, 203 octets

Cela peut probablement être fait de manière plus courte.

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

lit l'entrée de STDIN. courir avec -r.

Titus
la source
4

Python 3, 149 octets

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

Prend les entrées comme ##\n #\net retourne les sorties comme ['─', '┐', '\n', ' ', '│', '\n'].

Lynn
la source
3

R, 199 212 octets

EDIT: C'est maintenant une fonction, plutôt qu'un extrait de code.

L'entrée est une matrice mde 1 et de 0. C'est assez moche et hacky.

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

Quelques 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")}
┌┬┬┐
├┼┼┤
├┼┼┤
└┴┴┘
tourbull
la source
La soumission doit être soit un programme complet, soit une fonction. La lecture d'une variable existante n'est pas une forme d'entrée autorisée.
TuxCrafting
Comment faire en sorte que certains caractères Unicode fonctionnent correctement avec R? x = "\ U253C" fonctionne mais x = "" ne fonctionne pas.
Vlo
@ TùxCräftîñg: corrigé maintenant!
rturnbull
@Vlo utf-8 est l'encodage natif de mon système d'exploitation. x = "┼"fonctionne très bien pour moi.
rturnbull
3

Perl, 89 88 octets

Comprend +2 pour -0p . Les caractères spéciaux sont comptés pour 1 octet, mais pour les afficher en tant que caractères uniques, il est préférable d’ajouter également l’option -C.

Donnez une entrée sur STDIN avec les lignes espacées de manière à ce qu'elles aient toutes la même longueur:

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
Ton Hospel
la source
1

MATL, 102 caractères

J'attribue une valeur à un voisin (1, 2, 4 ou 8); leur somme correspondra à un caractère d'une chaîne contenant les caractères de dessin. Je pense qu'il y a encore beaucoup de place pour des améliorations, mais pour un brouillon:

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

Améliorations à apporter:

  • Peut-être remplacer toute la partie de sommation par une sorte de boucle travaillant sur des copies pivotées de la matrice
  • Ditch le tout et créer quelque chose basé sur une seule boucle à travers la matrice
  • Utilisez l'indexation modulaire pour travailler sur un vecteur aplati de la matrice d'origine (?)

Essayez-le en ligne! (peut ne pas prendre en charge les caractères de dessin de boîte)

Sanchises
la source