"पता" या "नहीं"?


144

एक प्रोग्राम लिखें जो एक पेचीदा स्ट्रिंग के ASCII कला प्रतिनिधित्व को संसाधित करता है और यह तय करता है कि क्या यह एक साधारण लूप में असंगत हो सकता है या नहीं। वर्णों का उपयोग करके -और |क्षैतिज और ऊर्ध्वाधर खंडों +का प्रतिनिधित्व करने के लिए , और कोनों का प्रतिनिधित्व करने के लिए उलझन का प्रतिनिधित्व किया जाता है । वे स्थान जहाँ स्ट्रिंग स्वयं से गुज़रती है उन्हें निम्न प्रकार से दर्शाया जाता है:

            |                           |   
         -------                     ---|---
            |                           |   
(Horizontal segment on top)   (Vertical segment on top)

स्ट्रिंग के छोर एक साथ जुड़े हुए हैं; कोई ढीले सिरे नहीं हैं।

यदि आपका प्रोग्राम यह निर्णय लेता है कि स्ट्रिंग को एक साधारण लूप में नहीं रखा जा सकता है, तो उसे शब्द का उत्पादन करना चाहिए KNOT। अन्यथा, यह शब्द का उत्पादन करना चाहिए NOT

यह एक चुनौती है, इसलिए सबसे छोटा वैध उत्तर (स्रोत कोड के बाइट्स में मापा जाता है) जीत जाएगा।

सीमाएं

ASCII इनपुट में 80 वर्णों की 25 लाइनें शामिल होंगी। आप मान सकते हैं कि सभी लाइनें एक ही लंबाई के रिक्त स्थान के साथ गद्देदार हैं।

उदाहरण

इनपुट:

+-------+    +-------+    
|       |    |       |    
|   +---|----+   +-------+
|   |   |        |   |   |
+-------|------------|---+
    |   |        |   |    
    +---+        +---+    

आउटपुट:

KNOT

इनपुट:

+----------+         
|          |         
|    +--------------+
|    |     |        |
|    |   +-|----+   |
|    |   | |    |   |
|    +-----+    |   |
|        |      |   |
|        +------|---+
|               |    
+---------------+    

आउटपुट:

NOT

संदर्भ


36
+1 महान प्रश्न। लोगों को उस गाँठ सिद्धांत में कूदने के लिए प्रोत्साहित करने के लिए इस पर एक बाउंटी लगाने का प्रलोभन दिया गया।
डिजिटल ट्रामा

2
क्या हम मान सकते हैं कि यह एक गाँठ है (संभवतः unknot) या क्या यह> 1 जुड़े घटकों का लिंक हो सकता है?
msh210

@ msh210 हाँ, आप यह मान सकते हैं कि यह एक एकल गाँठ है :-)
स्क्विश ओस्फ़रेज

जवाबों:


94

पायथन 3, 457 316 306 बाइट्स

E=enumerate
V={'+'}
Q=[[(-j,i,k)for i,u in E(open(0))for j,v in E(u)for k in[{v}&V,'join'][u[j:j+2]=='|-']]]
while Q:
 a,b,c,d,*e=A=tuple(x//2for y,x in sorted((y,x)for x,y in E(Q.pop())));e or exit('NOT')
 if{A}-V:V|={A};Q+=[[c,d,a,b]+e,A,A[2:]+A[:2]][a<c<b<d:][c<a<d<b:]
 if b==d:Q=[[a,c]+e]
exit('KNOT')

है ना?

कार्यक्रम पहले गाँठ को एक आयताकार आरेख में परिवर्तित करता है, जिसमें निम्नलिखित प्रतिबंध हैं:

  1. कोई भी दो ऊर्ध्वाधर या क्षैतिज खंड एक ही रेखा पर नहीं होते हैं।
  2. क्षैतिज खंड पर कोई ऊर्ध्वाधर खंड पार नहीं होता है।

उदाहरण के लिए, पहला परीक्षण मामला निम्नलिखित आयताकार आरेख में बदल जाता है:

+-----------+            
|           |            
|           | +-------+  
|           | |       |  
| +-------+ | |       |  
| |       | | |       |  
| |     +---+ |       |  
| |     | |   |       |  
| |     | +---+       |  
| |     |             |  
| |     |       +-------+
| |     |       |     | |
+-----+ |       |     | |
  |   | |       |     | |
  | +---+       |     | |
  | | |         |     | |
  | | +-------------+ | |
  | |           |   | | |
  | |           | +---+ |
  | |           | | |   |
  | |           | | +---+
  | |           | |      
  +-+           | |      
                | |      
                +-+      

जो हम ऊर्ध्वाधर खंडों के y निर्देशांक के क्रम से विशिष्ट रूप से प्रतिनिधित्व करते हैं, दाएं से बाएं

(5,10, 1,9, 8,10, 9,12, 5,12, 1,4, 0,3, 2,4, 3,7, 6,8, 7,11, 2,11, 0,6)

इसके बाद इवान डायनिकोव में वर्णित आयताकार आरेख के सरलीकरण की खोज करता है , “लिंक की आर्क-प्रस्तुतियाँ। मोनोटोनिक सरलीकरण ”, 2004 । डायनिकोव ने साबित किया कि अनकॉट के किसी भी आयताकार आरेख से, सरल चालों का एक क्रम होता है जो तुच्छ आरेख पर समाप्त होता है। संक्षेप में, अनुमत चालों में शामिल हैं:

  1. ऊर्ध्वाधर (या क्षैतिज) खंडों को चक्रीय रूप से अनुमति देना;
  2. निश्चित कॉन्फ़िगरेशन बाधाओं के तहत लगातार ऊर्ध्वाधर (या क्षैतिज) सेगमेंट को स्वैप करना।
  3. तीन आसन्न सिरों को बदलना जो आरेख के बहुत कोने में एक शीर्ष के साथ स्थित हैं।

तस्वीरों के लिए पेपर देखें। यह एक स्पष्ट प्रमेय नहीं है; यह कहना नहीं है कि, क्या कहते हैं, Reidemeister चलता है कि क्रॉसिंग की संख्या में वृद्धि नहीं होती है इसके बजाय इसका उपयोग किया जाता है। लेकिन ऊपर दिए गए विशेष प्रकार के सरलीकरण के लिए, यह सच हो जाता है।

(हम केवल ऊर्ध्वाधर खंडों को अनुमति देकर कार्यान्वयन को सरल बनाते हैं, लेकिन पूरे गाँठ को ऊर्ध्वाधर से क्षैतिज रूप से स्थानांतरित करने की अनुमति देते हैं।)

डेमो

$ python3 knot.py <<EOF
+-------+    +-------+    
|       |    |       |    
|   +---|----+   +-------+
|   |   |        |   |   |
+-------|------------|---+
    |   |        |   |    
    +---+        +---+    
EOF
KNOT
$ python3 knot.py <<EOF
+----------+         
|          |         
|    +--------------+
|    |     |        |
|    |   +-|----+   |
|    |   | |    |   |
|    +-----+    |   |
|        |      |   |
|        +------|---+
|               |    
+---------------+    
EOF
NOT
$ python3 knot.py <<EOF  # the Culprit
        +-----+  
        |     |  
+-----------+ |  
|       |   | |  
|   +-+ | +---|-+
|   | | | | | | |
| +-|-------+ | |
| | | | | |   | |
+-|-+ | | +---+ |
  |   | |       |
  +---|---------+
      | |        
      +-+        
EOF
NOT
$ python3 knot.py <<EOF  # Ochiai unknot
    +-----+    
    |     |    
  +-|---------+
  | |     |   |
  | | +-+ |   |
  | | | | |   |
+-|-|---|-|-+ |
| | | | | | | |
| | | +---|---+
| | |   | | |  
+-------+ | |  
  | |     | |  
  | +-------+  
  |       |    
  +-------+    
EOF
NOT
$ python3 knot.py <<EOF  # Ochiai unknot plus trefoil
    +-----+ +-----+
    |     | |     |
  +-|---------+   |
  | |     | | |   |
  | | +-+ | +---+ |
  | | | | |   | | |
+-|-|---|-|-+ +---+
| | | | | | |   |  
| | | +---|-----+  
| | |   | | |      
+-------+ | |      
  | |     | |      
  | +-------+      
  |       |        
  +-------+        
EOF
KNOT
$ python3 knot.py <<EOF  # Thistlethwaite unknot
      +---------+        
      |         |        
    +---+ +---------+    
    | | | |     |   |    
    | +-------+ |   |    
    |   | |   | |   |    
    |   | | +---+   |    
    |   | | | |     |    
    |   | +-------+ |    
    |   |   | |   | |    
    |   +-------+ | |    
    |       | | | | |    
+-----------+ | | | |    
|   |         | | | |    
| +-----------+ | | |    
| | |           | | |    
| | +-------------+ |    
| |             |   |    
| |             +-----+  
| |                 | |  
| |                 +---+
| |                   | |
+---------------------+ |
  |                     |
  +---------------------+
EOF
NOT
$ python3 knot.py <<EOF  # (−3,5,7)-pretzel knot
      +-------------+
      |             |
    +-|-----+       |
    | |     |       |
  +-|-+   +-------+ |
  | |     | |     | |
+-|-+   +---+   +---+
| |     | |     | |  
| |   +---+   +---+  
| |   | |     | |    
| | +---+   +---+    
| | | |     | |      
| +---+   +---+      
|   |     | |        
|   |   +---+        
|   |   | |          
|   | +---+          
|   | | |            
|   +---+            
|     |              
+-----+              
EOF
KNOT
$ python3 knot.py <<EOF  # Gordian unknot
+-------------+                 +-------------+
|             |                 |             |
| +---------+ |                 | +---------+ |
| |         | |                 | |         | |
| | +-------------+         +-------------+ | |
| | |       | |   |         |   | |       | | |
| | | +---------+ |         | +---------+ | | |
| | | |     | | | |         | | | |     | | | |
| +-------+ | +-------+ +-------+ | +-------+ |
|   | |   | |   | |   | |   | |   | |   | |   |
+-------+ | +-------+ | | +-------+ | +-------+
    | | | |     | | | | | | | |     | | | |    
    | +-------+ | | | | | | | | +-------+ |    
    |   | |   | | | | | | | | | |   | |   |    
    +-------+ | | | | | | | | | | +-------+    
        | | | | | | | | | | | | | | | |        
        | +-----+ | | | | | | +-----+ |        
        |   | |   | | | | | |   | |   |        
        +---------+ | | | | +---------+        
            | |     | | | |     | |            
          +---------+ | | +---------+          
          | | |       | |       | | |          
          | | +-----------------+ | |          
          | |         | |         | |          
          | +---------------------+ |          
          |           | |           |          
          +-----------+ +-----------+          
EOF
NOT

वाह, यह उत्कृष्ट है।
स्क्विश ओशिफ्रेज

3
क्या आप अपने कोड का एक अनऑर्गलाइज्ड संस्करण पोस्ट कर सकते हैं?
जे एंटोनियो पेरेज़

इसके अलावा, आपके कार्यक्रम की समय जटिलता क्या है?
जे एंटोनियो पेरेज़

3
@ जोर्जप्रेज़ मैं एक अलग ungolfed संस्करण नहीं है; कार्यक्रम को समझने का सबसे अच्छा तरीका डायनिकोव के पेपर को पढ़ना है जो मैंने जुड़ा था। जटिलता कुछ बहुत ही घातीय है; जहाँ तक मुझे पता है, क्या एक बहुपद समय एल्गोरिथ्म मौजूद है, अभी भी एक खुली समस्या है।
एंडर्स कासोर्ग
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.