(Adında 26 düğümlerine up bir ağ vardır Aiçin Zya ahiç zdilek göre). Her düğüm çifti bağlanabilir veya bağlantısı kesilebilir. Bir düğüm en fazla 4 diğer düğüme bağlanabilir. Görevin, ağı 2B diyagramda çizmek. Bu görevin mümkün olabileceği şekilde girdi verilecektir (çıktı bölümündeki daha fazla kısıtlamaya bakın).

Giriş

• (Harf çiftleri Aiçin Zya ahiç zdilek göre). Herhangi bir sırayla sıralanmazlar.
• İsteğe bağlı - çift sayısı

Çıktı

• Düğümler arasındaki gerçek bağlantıları gösteren bir ASCII çizimi. Düğümler tarafından verilmektedir aiçin zya Ahiç Z. -Yatay bağlantılar ve |dikey bağlantılar için kullanın . Bağlantılar (sıfır olmayan) herhangi bir uzunlukta olabilir, ancak bükülmeyen düz yatay / dikey çizgiler olmalıdır . Resmi bozmamaları koşuluyla boşluk eklenebilir.

Grafiğin düzeninde yardımcı olan bileşenleri kullanamazsınız. Grafikle ilgili diğer yerleşik yapılara izin verilebilir (dahili yapı olmayan çözümler daha fazla takdir edilse de). En kısa kod kazanır.

Giriş

A B
B F
B L
F K
L K
K R
K S
R P
S J
S P
J A
T V
V N

Çıktı

A - B - F   T - V
|   |   |       |
|   L - K - R   N
|       |   |
J ----- S - P

Giriş

H C
G H
A B
B F
B C
F G
C D
D A

Çıktı

A - B ----- F
|   |       |
D - C - H - G

CJam, 142

En uygun, deterministik veya hızlı bir çözüm istemediniz, işte buradasınız:

qN%Sf%::c_s_&:Aff#:E;{A{;[DmrDmr]2f*}%:C;E{Cf=~.-:*}%0m1{E{Cf=$~1$.-_:g:T\:+,1>\ff*\f.+T0="-|"=f+~}%CA.++:L2f<__&=!}?}gS25*a25*L{~2$4$=\tt}/N*

Çevrimiçi deneyin

Bu, her bir harf için rastgele koordinatlar oluşturur ve mizanpajın kabul edilebilir olup olmadığını test eder (kenar sıraları yukarı ve kesişme olmadan). Daha fazla kenar eklerken zihin uyuşukça yavaşlar.

Koddaki iki Dharf maksimum x ve y koordinatlarını belirtir; Ben seçtim D(= 13), çünkü tüm durumlar için yeterli olması gerektiğini düşünüyorum, yanlış olduğumu kanıtlamaktan çekinmeyin. Ancak, programı hızlandırmak için bunları diğer değerlere değiştirebilirsiniz, örneğin, yerine 3 ve 4 kullanıyorsanız, 2. örnek bir veya iki dakika içinde bitmelidir.

C, 813 bayt

#include<map>
#include<set>
#include<cstdlib>
typedef int I;typedef char*C;I a,t,s,h;struct p{I x,y;}j,k;std::map<I,std::set<I>>l;std::map<I,p>g;C m,M="  |-";I L(I n,C q,C Q){j=g[n],h=1;for(I o:l[n])if(g.find(o)!=g.end())if(!(a=(k=g[o]).y==j.y)&&k.x^j.x)h=0;else for(I x=j.x,y=j.y,e=k.y*s+k.x,b,d=(k.x<j.x||k.y<j.y)?-1:1;a?x+=d:y+=d,(b=y*s+x)^e;m[b]=q[a])if(m[b]^Q[a]){h=0;break;}}I N(){for(auto i:g)for(I n:l[i.first])if(g.find(n)==g.end())return n;for(auto i:l)if(g.find(a=i.first)==g.end())return a;exit(puts(m));}I f(){for(I n=N(),x,y=0,b;y<s;y+=2)for(x=0;x<s;x+=2)m[b=y*s+x]==*M?g[n]={x,y},m[b]=n,L(n,M+2,M),h&&f(),L(n,M,M+2),m[b]=*M,g.erase(n):0;}I main(I c,C*v){for(;--c;l[a].insert(s),l[s].insert(a))a=v[c][0],s=v[c][1];t=l.size(),s=t|1;memset(m=(C)calloc(s,s),*M,s*s-1);for(a=1;a<s;++a)m[a*s-1]=10;f();}

Komut satırı argümanları olarak girdi alır, örneğin:

./network AB BF BL FK LK KR KS RP SJ SP JA TV VN

Aditsu'nun büyüklüğüne göre cevabı ile rekabet edebilecek bir yer yok ama çok daha verimli!

Bu, olası tüm çözümleri zorla uygulayacaktır, ancak ilerledikçe arızayı çabucak tanıyacaktır. İki test durumu için neredeyse hemen bitiyor ve daha garip girdilerde sadece birkaç saniye sürüyor gibi görünüyor. Ayrıca, kabul edilen düğüm adlarıyla ilgili herhangi bir sınırlaması yoktur (bir boşluk adlandıramasanız da, |veya -) ve düğüm sayısı sınırlaması yoktur (tüm adlar bir bayta sığdığı sürece, bu nedenle pratik sınır 252 düğümdür, ve çok sayıda kişiye ulaşmadan çok önce yavaşlayacaktır).

Bunu hızlandırmak için çok fazla alan var; golf oynamak için çok sayıda kısa devre çıkışı kesildi ve sıcak devrelerden ayrılabilecek parçalar var. Ayrıca bazı simetri gözlemleri, diğer şeylerin yanı sıra ilk 2 düğümün konumunu önemli ölçüde azaltabilir.

Yıkmak:

#include<map>
#include<set>
#include<cstdlib>
typedef int I;
typedef char*C;
I a,t,s,h;                // Variables shared between functions
struct p{I x,y;}          // Coord datatype
j,k;                      // Temporary coord references
std::map<I,std::set<I>>l; // Bidirectional multimap of node links
std::map<I,p>g;           // Map of nodes to positions
C m,                      // Rendered grid
M="  |-";                 // Lookup table for output characters

// Line rendering function
// Sets h to 1 if all lines are drawn successfully, or 0 if there is a blocker
I L(I n,C q,C Q){
  j=g[n],h=1;
  for(I o:l[n])                  // For each connection to the current node
    if(g.find(o)!=g.end())       // If the target node has been positioned
      if(!(a=(k=g[o]).y==j.y)&&k.x^j.x)h=0; // Fail if the nodes are not aligned
      else
        for(I x=j.x,y=j.y,             // Loop from node to target
          e=k.y*s+k.x,
          b,d=(k.x<j.x||k.y<j.y)?-1:1;
          a?x+=d:y+=d,(b=y*s+x)^e;
          m[b]=q[a])                   // Render character (| or -)
          if(m[b]^Q[a]){h=0;break;}    // Abort if cell is not blank
}

// Next node selection: finds the next connected node to try,
// or the next unconnected node if the current connected set is complete.
// Displays the result and exits if the entire graph has been rendered.
I N(){
  for(auto i:g)for(I n:l[i.first])  // Search for a connected node...
    if(g.find(n)==g.end())return n; // ...and return the first available
  for(auto i:l)                     // Else search for an unconnected node...
    if(g.find(a=i.first)==g.end())
      return a;                     // ...and return the first available
  exit(puts(m));                    // Else draw the grid to screen and stop
}

// Recursive brute-force implementation
I f(){
  for(I n=N(),x,y=0,b;y<s;y+=2) // Loop through all grid positions
    for(x=0;x<s;x+=2)
      m[b=y*s+x]==*M            // If the current position is available
       ?g[n]={x,y},             // Record the location for this node
        m[b]=n,                 // Render the node
        L(n,M+2,M),             // Render lines to connected nodes
        h&&f(),                 // If line rendering succeeded, recurse
        L(n,M,M+2),             // Un-render lines
        m[b]=*M,g.erase(n)      // Un-render node
       :0;
}

// Input parsing and grid setup
I main(I c,C*v){
  // Parse all inputs into a bidirectional multi-map
  for(;--c;l[a].insert(s),l[s].insert(a))a=v[c][0],s=v[c][1];
  t=l.size(),s=t|1; // Calculate a grid size
  // Allocate memory for the grid and render newlines
  memset(m=(C)calloc(s,s),*M,s*s-1);
  for(a=1;a<s;++a)m[a*s-1]=10;
  f(); // Begin recursive solving
}