Buchstaben verbinden

23

Sie sollten ein Programm oder eine Funktion schreiben, die einen als Zeichenfolge dargestellten Zeichenblock empfängt und eine ähnliche Zeichenfolge ausgibt oder zurückgibt, in der die im Alphabet benachbarten Buchstaben verbunden sind.

Ein visuelles Beispiel (in Form von input => output):

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

Einzelheiten

  • Die Eingabe erfolgt als Zeichenfolge mit Leerzeichen, Zeilenumbrüchen und genau einem der ersten NKleinbuchstaben.1 <= N <= 26
  • Die Zeilen der Eingabe werden mit Leerzeichen aufgefüllt, um einen vollständigen rechteckigen Block zu erstellen.
  • Jedes im Alphabet benachbarte Buchstabenpaar befindet sich in derselben Zeile, Spalte oder Diagonale und sollte mit einer geraden ASCII-Linie verbunden werden \ / | or -. (Die Linie kann eine Länge von 0 haben.)
  • Die folgenden Arten von zweizeiligen Überlappungen sollten behandelt werden:

    / and \ become X
    | and - become +
    / and / become /
    \ and \ become \
    | and | become |
    - and - become -
    [letter] and [anything] become [letter]
    
  • Es wird keine andere Art von zweizeiliger Überlappung auftreten.

  • Wenn sich mehr als zwei Linien überlappen, wird garantiert, dass eines der Paare eine der gültigen Überlappungen ist. (zB [letter] / |Triplett wird niemals auftreten)
  • Abgesehen davon, dass Leerzeichen in \ / | - X and +Eingabe und Ausgabe geändert werden, sollten sie identisch sein.
  • Der Zeilenumbruch ist optional, muss jedoch für die Eingabe und Ausgabe identisch sein.
  • Dies ist Code-Golf, also gewinnt der kürzeste Eintrag.

Beispiele

Eingang:

b     d        


     h   gi    

      e  f     
c     a        

Ausgabe:

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

Eingang:

     dk    j   

 b    l        

 c   fg        

     a    m    

   i      h    
     e         

Ausgabe:

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

Eingang:

   eti  sqjh k  p  u  cfm vb owgzyx rnd la  

Ausgabe:

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

Eingang:

a

Ausgabe:

a
randomra
quelle
Wirklich schöne ASCII-Kunst
Optimierer
2
Was ist, wenn sich ein X und ein + an derselben Stelle befinden sollten? Oder ist das kein Fall, für den wir Rechenschaft ablegen sollten?
theonlygusti
@theonlygusti „Wenn mehr als zwei Zeilen überlappen , jedes Paar von ihnen einen der gültigen Überlappungen werden“ wie zB /und -ungültig sind Überlappungen Xund +( / \ - and |) nicht an der gleichen Stelle auftreten.
Randomra
Immer noch verwirrt; Warum geben Sie uns nicht einige Beispiele?
Theonlygusti
@ Theonlygusti: Grundsätzlich ist es kein Fall, den Sie erklären sollten
Claudiu

Antworten:

3

Perl, 219

Einige Verbesserungen sind möglicherweise noch möglich.

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

Versuch es mit mir .

nutki
quelle
6

JavaScript (ES6) 246 266 280 285 307

Ziemlich sperrig ...

Eine Funktion mit String-Parameter und Rückgabe des modifizierten Strings. Ein abschließender Zeilenumbruch ist optional, es sei denn, die Eingabe besteht nur aus einer Zeile (ich benötige einen Zeilenumbruch, um die Zeilenlänge zu ermitteln).

Nur um jemanden glücklich zu machen

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

Mehr lesbar

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 In der Firefox / FireBug-Konsole

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

Ausgabe

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
quelle
Ich zähle 341Zeichen.
mbomb007
@ mbomb007 zählen nicht Einrückung Leerzeichen und Zeilenumbrüche
edc65