Relier les lettres

23

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
randomra
la source
art ascii vraiment sympa
Optimizer
2
Et si un chevauchement X et + devait être au même endroit? Ou n'est-ce pas un cas dont nous devrions tenir compte?
theonlygusti
@theonlygusti "Si plus de deux lignes se chevauchent, n'importe quelle paire sera l'une des chevauchements valides" Comme par exemple /et -sont des chevauchements invalides Xet +( / \ - and |) ne peut pas se produire à la même position.
randomra
Encore confus; pourquoi ne pas nous en donner quelques exemples?
theonlygusti
@theonlygusti: Fondamentalement, ce n'est pas un cas à prendre en compte
Claudiu

Réponses:

3

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 .

nutki
la source
6

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    
edc65
la source
Je compte les 341caractères.
mbomb007
@ mbomb007 ne compte pas les espaces blancs d'indentation et les nouvelles lignes
edc65