Letras de conexión

23

Debe escribir un programa o función que reciba un bloque de caracteres representados como una cadena y genere o devuelva una cadena similar en la que las letras adyacentes en el alfabeto estén conectadas.

Un ejemplo visual (en forma de input => output):

b     d               b     d        
                      |\   /|        
                      | \ / |        
             =>       |  X  |        
                      | / \ |        
      e               |/   \e        
c     a               c     a        

Detalles

  • La entrada será una cadena que contiene espacios, líneas nuevas y exactamente una de cada una de las primeras Nletras minúsculas.1 <= N <= 26
  • Las líneas de la entrada se rellenarán con espacios creando un bloque rectangular completo.
  • Cada par de letras adyacentes en el alfabeto estará en la misma fila, columna o línea diagonal y debe conectarse con una línea recta ascii usando \ / | or -. (La línea puede tener una longitud de 0.)
  • Se deben manejar los siguientes tipos de superposiciones de dos líneas:

    / and \ become X
    | and - become +
    / and / become /
    \ and \ become \
    | and | become |
    - and - become -
    [letter] and [anything] become [letter]
    
  • No se producirá ningún otro tipo de superposición de dos líneas.

  • Si se superponen más de dos líneas, se garantizará que cualquiera de ellas sea una de las superposiciones válidas. (por ejemplo, el [letter] / |triplete nunca ocurrirá)
  • Además de cambiar los espacios en \ / | - X and +entrada y salida, debe ser idéntico.
  • La nueva línea final es opcional, pero debe ser la misma para la entrada y la salida.
  • Este es el código de golf, por lo que gana la entrada más corta.

Ejemplos

Entrada:

b     d        


     h   gi    

      e  f     
c     a        

Salida:

b     d        
|\   /|        
| \ / |        
|  X h+--gi    
| / \ |  |     
|/   \e--f     
c     a        

Entrada:

     dk    j   

 b    l        

 c   fg        

     a    m    

   i      h    
     e         

Salida:

     dk----j   
    /||   /    
 b / |l  /     
 |X  | \/      
 c \ fg/\      
    \|/\ \     
     a  \ m    
    /|   \     
   i-+----h    
     e         

Entrada:

   eti  sqjh k  p  u  cfm vb owgzyx rnd la  

Salida:

   eti--sqjh-k--p--u--cfm-vb-owgzyx-rnd-la  

Entrada:

a

Salida:

a
randomra
fuente
arte ascii realmente agradable
Optimizer
2
¿Qué pasa si una superposición de X y + debe estar en el mismo lugar? ¿O no es ese un caso que debemos tener en cuenta?
theonlygusti
@theonlygusti "Si más de dos líneas se superponen cualquier par de ellos será uno de los solapamientos válidos" como, por ejemplo /y -solapamientos no válidos Xy +( / \ - and |) no puede producirse en la misma posición.
randomra
Sigo confundido; ¿Por qué no nos das algunos ejemplos?
theonlygusti
@theonlygusti: Básicamente, no es un caso que deba tener en cuenta
Claudiu

Respuestas:

3

Perl, 219

Algunas mejoras aún pueden ser posibles.

#!perl -p0
/
/;$x="@-";
sub g{map"(?=$_)(.@_)+[".chr(1+ord).chr(~-ord)."]",a..z}
sub f{for$p(g"{$x}"){s/$p/$&&((_."\177"x~-$x)x y!
!!)/se;$_=lc;s![\0\\]!@_!g}$x++}
f"/";y!\17!/!;f"|";f"\\";y/\17/X/;for$p(g){s/$p/$&=~y! |!-+!r/e}

Trate de mí .

nutki
fuente
6

JavaScript (ES6) 246 266 280 285 307

Bastante voluminoso ...

Una función con string param y que devuelve la cadena modificada. Una nueva línea final es opcional a menos que la entrada sea solo 1 fila (necesito una nueva línea para encontrar la fila len)

Solo para hacer feliz a alguien

F=b=>b.match(/\w/g).sort().map(l=>(q=b.indexOf(l),~p)?[o=b.indexOf('\n'),~o,o+2,1].map((d,i)=>{k=(q-p)/d|0;if(k&&k*d+p==q)for(m='/|\\-'[i];(p+=k>0?d:-d)-q;c==m|c>'`'&c<'{'?0:b[p]=c>' '?c<'/'|c>'z'?'+':'X':m)c=b[p]}):p=q,p=-1,b=[...b])&&b.join('')

Más legible

F=b=>
  b.match(/\w/g).sort().map(l=>
    (q=b.indexOf(l),~p)?
    [o=b.indexOf('\n'),~o,o+2,1].map((d,i)=>{
      k=(q-p)/d|0;
      if(k&&k*d+p==q)
        for(m='/|\\-'[i];
              (p+=k>0?d:-d)-q;
              c==m|c>'`'&c<'{'?0:b[p]=c>' '?c<'/'|c>'z'?'+':'X':m)
            c=b[p]
    })
    :p=q
  ,p=-1,b=[...b])
  &&b.join('')

Prueba en la consola Firefox / FireBug

console.log(F('\
b     d\n\
       \n\
       \n\
       \n\
       \n\
      e\n\
c     a\n'))

console.log(F('\
     dk    j\n\
            \n\
 b    l     \n\
            \n\
 c   fg     \n\
            \n\
     a    m \n\
            \n\
   i      h \n\
     e      \n'))

console.log(F('\
b     d    \n\
           \n\
           \n\
     h   gi\n\
           \n\
      e  f \n\
c     a    \n'))

Salida

b     d
|\   /|
| \ / |
|  X  |
| / \ |
|/   \e
c     a

     dk----j
    /||   / 
 b / |l  /  
 |X  | \/   
 c \ fg/\   
    \|/\ \  
     a  \ m 
    /|   \  
   i-+----h 
     e      

b     d    
|\   /|    
| \ / |    
|  X h+--gi
| / \ |  | 
|/   \e--f 
c     a    
edc65
fuente
Cuento 341caracteres.
mbomb007
@ mbomb007 no cuenta espacios en blanco de sangría y líneas nuevas
edc65