नोड्स का एक नेटवर्क ड्रा करें

24

वहाँ 26 नोड्स (नामित करने के लिए ऊपर का एक नेटवर्क है Aकरने के लिए Zया aकरने के लिए zअपनी इच्छा के अनुसार)। नोड्स की प्रत्येक जोड़ी कनेक्ट या डिस्कनेक्ट हो सकती है। एक नोड अधिकतम 4 अन्य नोड्स से जुड़ा हो सकता है। आपका कार्य एक 2D आरेख में नेटवर्क को आकर्षित करना है। इनपुट इस तरह दिया जाएगा कि यह कार्य संभव है (आउटपुट सेक्शन में अधिक अवरोध देखें)।

स्वरूप

इनपुट

  • (पत्र के जोड़े Aके लिए Zया aकरने के लिए zअपनी इच्छा के अनुसार)। वे किसी भी क्रम में क्रमबद्ध नहीं हैं।
  • वैकल्पिक - जोड़े की संख्या

उत्पादन

  • एक ASCII ड्राइंग जो नोड्स के बीच वास्तविक लिंक को दर्शाता है। नोड्स द्वारा दिया जाता है aकरने के लिए zया Aकरने के लिए Z। -क्षैतिज लिंक के लिए और |ऊर्ध्वाधर लिंक के लिए उपयोग करें । लिंक किसी भी (गैर-शून्य) लंबाई के हो सकते हैं लेकिन वे सीधे क्षैतिज / ऊर्ध्वाधर रेखाएं होनी चाहिए जो झुकती नहीं हैं । रिक्त स्थान जोड़े जा सकते हैं बशर्ते वे चित्र को न हटाएं।

आप बिल्ट-इन का उपयोग नहीं कर सकते हैं जो ग्राफ़ के लेआउट में मदद करते हैं। अन्य ग्राफ से संबंधित अंतर्निहित इंस की अनुमति दी जा सकती है (हालांकि बिल्ट-इन के बिना समाधान को अधिक सराहा जाएगा)। सबसे छोटा कोड जीतता है।

नमूना डेटा

इनपुट

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

उत्पादन

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

इनपुट

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

उत्पादन

A - B ----- F
|   |       |
D - C - H - G
code-golf  ascii-art  graph-theory 
— ghosts_in_the_code
स्रोत
1
मुझे लगता है कि मेरे पिछले प्रश्नों का पर्याप्त उत्तर दिया गया है, लेकिन ध्यान दें कि नया परीक्षण मामला गलत है क्योंकि पहली पंक्ति है H Aऔर वह धार दिए गए आउटपुट में नहीं है। संपादित करें: समस्या की पहचान की और तय की।
— पीटर टेलर
2
शायद इसे "पहले (काम करने वाले) कोड जीतता है"? ;-) गंभीरता से, यह अपने दम पर चुनौतीपूर्ण है, यहां तक ​​कि गोल्फिंग के बिना भी ...
— Marco13
@ Marco13 कि सबसे अधिक संभावना है कि विषय के रूप में चुनौती बंद हो जाएगी।
— डेनिस
@ghosts_in_the_code मॉडरेटर्स प्रश्न पूछने के लिए झंडे का उपयोग न करें। अगर आपको किसी चीज़ पर प्रतिक्रिया चाहिए, तो हमेशा उन्नीसवीं बाइट होती है ।
— डेनिस
@ डेनिस ओके, सॉरी। मैं पहले कभी चैट पर नहीं गया, इसलिए मुझे नहीं पता कि यह कैसे काम करता है।
— भूत_न_थे_कोड १४

जवाबों:

3

CJam, 142

आपने एक इष्टतम, निर्धारक या तेज समाधान के लिए नहीं पूछा, इसलिए यहां आप जाएं:

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*

इसे ऑनलाइन आज़माएं

यह प्रत्येक अक्षर और परीक्षणों के लिए यादृच्छिक निर्देशांक उत्पन्न करता है यदि लेआउट स्वीकार्य है (बढ़त पत्र अस्तर और कोई चौराहा नहीं है), जब तक कि यह न हो। जब आप अधिक किनारों को जोड़ते हैं तो यह मन-सुन्न हो जाता है।

Dकोड में दो अक्षर अधिकतम x और y निर्देशांक निर्दिष्ट करते हैं; मैंने उठाया D(= 13) क्योंकि मुझे लगता है कि यह सभी मामलों के लिए पर्याप्त होना चाहिए, मुझे गलत साबित करने के लिए स्वतंत्र महसूस करें। लेकिन आप कार्यक्रम को गति देने के लिए उन्हें अन्य मूल्यों में बदल सकते हैं, उदाहरण के लिए 2 उदाहरण को एक या दो मिनट के भीतर समाप्त करना चाहिए यदि आप इसके बजाय 3 और 4 का उपयोग करते हैं।

— aditsu
स्रोत
मैंने एक तेज़ समाधान के लिए नहीं कहा, लेकिन शायद मुझे एक निर्धारक के लिए पूछना चाहिए था। लेकिन अब जब यह प्रश्न इतने लंबे समय से है, तो मैं इसे नहीं बदलूंगा।
— भूत_न_थे_कोड
@ghosts_in_the_code इसे निर्धारित करने के लिए बहुत कठिन नहीं होना चाहिए - निर्देशांक के सभी संयोजनों का प्रयास करें। लेकिन यह शायद लंबा और बहुत धीमा होगा, और बहुत सारी मेमोरी भी खाएगा।
— aditsu
3

सी, 813 बाइट्स

#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();}

कमांडलाइन तर्कों के रूप में इनपुट लेता है, जैसे:

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

आकार के हिसाब से एडिट्स के उत्तर के साथ प्रतिस्पर्धी कहीं नहीं, लेकिन बहुत अधिक कुशल!

यह सभी संभावित समाधानों को बाध्य करेगा, लेकिन असफलता को तुरंत पहचान लेगा। दो परीक्षण मामलों के लिए, यह लगभग तुरंत खत्म हो जाता है, और यह केवल कुछ सेकंड के लिए और अधिक अजीब इनपुट पर लगता है। इसमें स्वीकृत नोड नामों की भी कोई सीमा नहीं है (हालांकि आप एक स्थान का नाम नहीं दे सकते, |या -) और नोड्स की संख्या पर कोई सीमा नहीं है (जब तक सभी नाम बाइट में फिट होते हैं, इसलिए व्यावहारिक सीमा 252 नोड है, और यह उस तक पहुंचने से बहुत पहले धीमा हो जाएगा)।

इसमें तेजी लाने की बहुत गुंजाइश है; शॉर्ट-सर्किट से बाहर निकलने का एक बहुत कुछ गोल्फ के लिए खो गया था, और ऐसे हिस्से थे जिन्हें गर्म-छोरों से बाहर निकाला जा सकता था। समरूपता के कुछ अवलोकन नाटकीय रूप से अन्य चीजों के साथ पहले 2 नोड्स की स्थिति को कम कर सकते हैं।

टूट - फूट:

#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
}
— डेव
स्रोत
आखिरकार! 2 महीने हो गए। मैं व्यक्तिगत रूप से इस तरह के जवाब के लिए गोल्फ के पक्ष में नहीं हूं, मुझे केवल इस साइट के लोगों द्वारा आवश्यक था।
— भूत_न_थे_कोड
@ghosts_in_the_code यदि आप कोड गोल्फ नहीं चाहते हैं तो अन्य बहुत सारे उद्देश्य जीतने वाले मानदंड हैं जिनका आप उपयोग कर सकते हैं (हालांकि जाहिर है, आप इस चुनौती को बदल नहीं सकते हैं अब यह पोस्ट किया गया है)। समय-आधारित उदाहरण होंगे: विशिष्ट हार्डवेयर पर परिणाम उत्पन्न करने के लिए सबसे तेज़ (जैसे विशेष EC2 उदाहरण / रास्पबेरी पाई / आदि), समय सीमा के भीतर परीक्षणों की बैटरी के लिए सबसे कॉम्पैक्ट आउटपुट, सबसे बड़ी नेटवर्क एक परीक्षण के भीतर बैटरी से समर्थित समय सीमा (जैसे एक दिन, विशिष्ट हार्डवेयर पर लचीलेपन की अनुमति)। अगली बार सैंडबॉक्स का उपयोग करने का प्रयास करें; लोग आपको एक उद्देश्य चुनने में मदद कर सकते हैं।
— डेव
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.