Vous devez écrire un programme ou une fonction qui reçoit un bloc de caractères représenté sous la forme d'une chaîne et génère ou renvoie une chaîne similaire dans laquelle les lettres adjacentes de l'alphabet sont connectées.

Un exemple visuel (sous forme de input => output):

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

Détails

• L'entrée sera une chaîne contenant des espaces, des retours à la ligne et exactement l'une de chacune des premières Nlettres minuscules.1 <= N <= 26
• Les lignes de l'entrée seront remplies d'espaces créant un bloc rectangulaire complet.
• Chaque paire de lettres adjacente à l'alphabet sera sur la même ligne, colonne ou ligne diagonale et devrait être connectée avec une ligne ascii droite en utilisant \ / | or -. (La ligne peut avoir une longueur de 0.)

• Les types de chevauchements sur deux lignes suivants doivent être traités:

  / and \ become X
  | and - become +
  / and / become /
  \ and \ become \
  | and | become |
  - and - become -
  [letter] and [anything] become [letter]
  

• Aucun autre type de chevauchement sur deux lignes ne se produira.

• Si plus de deux lignes se chevauchent, une paire d'entre elles sera garantie comme étant l'un des chevauchements valides. (par exemple, un [letter] / |triplet ne se produira jamais)
• En plus de changer les espaces en \ / | - X and +entrée et en sortie, ils doivent être identiques.
• Le retour à la ligne est facultatif mais doit être le même pour l'entrée et la sortie.
• Il s'agit de code-golf, donc l'entrée la plus courte l'emporte.

Exemples

Contribution:

b     d        


     h   gi    

      e  f     
c     a        

Sortie:

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

Contribution:

     dk    j   

 b    l        

 c   fg        

     a    m    

   i      h    
     e         

Sortie:

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

Contribution:

   eti  sqjh k  p  u  cfm vb owgzyx rnd la  

Sortie:

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

Contribution:

a

Sortie:

a

Perl, 219

Certaines améliorations peuvent encore être possibles.

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

Essayez- moi .

JavaScript (ES6) 246 266 280 285 307

Assez volumineux ...

Une fonction avec chaîne param et renvoyant la chaîne modifiée. Un retour à la ligne de fin est facultatif sauf si l'entrée est juste 1 ligne (j'ai besoin d'un retour à la ligne pour trouver la ligne len)

Juste pour rendre quelqu'un heureux

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('')

Plus lisible

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('')

Test dans la console 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'))

Sortie

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