वॉन कोच अनुमान

Question

आप गणितज्ञ वॉन कोच को उनके प्रसिद्ध बर्फ के टुकड़े से जान सकते हैं। हालाँकि उन्हें अपनी आस्तीन पर अधिक दिलचस्प कंप्यूटर विज्ञान समस्याएं हैं। वास्तव में, आइए इस अनुमान पर एक नज़र डालें:

nनोड्स के साथ एक पेड़ दिया (इस प्रकार n-1किनारों)। से नोड्स की गणना करने में एक रास्ता खोजें 1करने के लिए nऔर, तदनुसार, से किनारों 1को n-1इस तरह से, कि प्रत्येक बढ़त के लिए kअपने नोड संख्या के अंतर के बराबर होती है k। अनुमान यह है कि यह हमेशा संभव है।

इसे पूरी तरह से स्पष्ट करने के लिए एक उदाहरण यहां दिया गया है:

आपका कार्य

आपका कोड एक पेड़ के रूप में ले जाएगा, आप जो प्रारूप चाहते हैं, ले सकते हैं, लेकिन परीक्षण के मामलों के लिए मैं पेड़ को उनके आर्क्स और उनके नोड्स की सूची प्रदान करूंगा।

उदाहरण के लिए यह चित्र में पेड़ के लिए इनपुट है:

[a,b,c,d,e,f,g]
d -> a
a -> b
a -> g
b -> c
b -> e
e -> f

आपके कोड को नोड्स और किनारों के साथ पेड़ को वापस करना होगा। आप अधिक चित्रमय आउटपुट वापस कर सकते हैं, लेकिन मैं परीक्षण मामलों के लिए इस तरह का आउटपुट प्रदान करूंगा:

[a7,b3,c6,d1,e5,f4,g2]
d -> a 6
a -> b 4
a -> g 5
b -> c 3
b -> e 2
e -> f 1

परीक्षण के मामलों

[a,b,c,d,e,f,g]             [a7,b3,c6,d1,e5,f4,g2]
d -> a                      d -> a 6
a -> b                      a -> b 4
a -> g             =>       a -> g 5
b -> c                      b -> c 3
b -> e                      b -> e 2
e -> f                      e -> f 1


[a,b,c,d]                   [a4,b1,c3,d2]
a -> b                      a -> b 3
b -> c            =>        b -> c 2
b -> d                      b -> d 1


[a,b,c,d,e]                [a2,b3,c1,d4,e5]
a -> b                      a -> b 1
b -> c                      b -> c 2
c -> d             =>       c -> d 3
c -> e                      c -> e 4

यह कोड-गोल्फ है बाइट्स जीत में यह सबसे छोटा जवाब है!

नोट: यह रिंगेल-कोटज़िग अनुमान से अधिक मजबूत है , जिसमें कहा गया है कि हर पेड़ पर एक सुंदर लेबलिंग है। चूंकि कोच अनुमान में रिंगेल-कोटज़िग अनुमान में सुंदर लेबलिंग के विपरीत पूर्णांक को छोड़ना संभव नहीं है। ग्रेसफुल लेबलिंग यहाँ से पहले पूछा गया है ।

Comments

क्या 26 से अधिक नोड होंगे?

— लीक

@LeakyNun 17 नोड्स के बाद बल लगाना पहले से ही कठिन है ^ ^

@WheatWizard यह पूरी तरह से वॉन कोच अनुमान के समान नहीं है क्योंकि इस धागे में आपको पूर्णांक को छोड़ने की अनुमति है। अनुमान का पूरा बिंदु लंघन के बिना लेबलिंग को संभव बना रहा है

Answer 1

जेली , 30 बाइट्स

JŒ!³,$€
ǵy⁴VIAµ€Q⁼$€TðḢịø³JŒ!

इसे ऑनलाइन आज़माएं! ( GṄ³çGआउटपुट प्रीटियर बनाने के लिए पाद लेख के रूप में उपयोग करें ।)

उदाहरण, उदाहरण abcdefऔर के समान इनपुट[d,a],[a,b],[a,g],[b,c],[b,e],[e,f]

सूची a,b,c,d,e,fको क्रम में जैसे आउटपुट करता है ।

नोट: मेरा कार्यक्रम परीक्षण मामलों की तुलना में विभिन्न मूल्यों का उत्पादन करता है क्योंकि कई संभावनाएं हैं जो सभी मान्य हैं।

व्याख्या

JŒ!³,$€                - helper function, generates all possible numberings, input is e.g. 'abcd'
J                      - range(len(input)). e.g. [1,2,3,4]
 Œ!                    - all permutations of the range.
   ³,$                 - pair the input with ... 
      €                - each permutation. Sample element e.g. ['abcd',[3,1,2,4]]

ǵy⁴VIAµ€Q⁼$€TðḢịø³JŒ! - main dyadic link, input is e.g. 'abcd' and '[a,b],[b,c],[b,d]'
 µy                    - use a numbering as an element-wise mapping e.g. 'abcd'->[3,1,2,4]
   ⁴                   - apply this to the list of edges. e.g. '[3,1],[1,2],[1,4]'
    V                  - turn this into an internal list.
     IAµ€              - find absolute difference on each edge
         Q⁼            - Is this invariant under deduplication? Returns 1 if the numbering is valid; 0 otherwise.
Ç          $€          - apply this to all possible numberings
             Tð        - return the indices of all valid numberings
               Ḣ       - choose the first one and
                ị      - get the element corresponding to its index in 
                 ø³JŒ! - all possible numberings 

सभी संभावित समाधान दिखा कर 1 बाइट बचाएं:

JŒ!³,$€
ǵy⁴VIAµ€Q⁼$€Tðịø³JŒ!

इसे ऑनलाइन आज़माएं! ( GṄ³çG⁷³Gआउटपुट प्रीटियर बनाने के लिए पाद लेख के रूप में उपयोग करें )

एक इनपुट सूची में कॉपी-पेस्ट परीक्षण मामले में कनवर्टर का उपयोग करें ।

Answer 2

रूबी, 108 बाइट्स

लांबा फ़ंक्शन, किनारों वाले 2-तत्व सरणियों के एक सरणी को स्वीकार करता है (जहां प्रत्येक किनारे को संबंधित नोटों के अनुरूप संख्याओं की एक जोड़ी के रूप में व्यक्त किया जाता है।)

->a{[*1..1+n=a.size].permutation.map{|i|k=a.map{|j|(i[j[0]-1]-i[j[1]-1]).abs}
(k&k).size==n&&(return[i,k])}}

परीक्षण कार्यक्रम में अपराजित

f=->a{                                    #Accept an array of n tuples (where n is the number of EDGES in this case)
  [*1..1+n=a.size].permutation.map{|i|    #Generate a range 1..n+1 to label the nodes, convert to array, make an array of all permutations and iterate through it.
    k=a.map{|j|(i[j[0]-1]-i[j[1]-1]).abs} #Iterate through a, build an array k of differences between nodes per current permutation, as a trial edge labelling.
    (k&k).size==n&&(return[i,k])          #Intersect k with itself to remove duplicates. If all elements are unique the size will still equal n so
  }                                       #return a 2 element array [list of nodes, list of edges]
}

p f[[[4,1],[1,2],[1,7],[2,3],[2,5],[5,6]]]

p f[[[1,2],[2,3],[2,4]]]

p f[[[1,2],[2,3],[3,4],[2,5]]]

उत्पादन

आउटपुट एक 2 तत्व सरणी है, जिसमें शामिल हैं:

नया नोड नंबरिंग

किनारे की संख्या।

उदाहरण के लिए पहले उदाहरण का पहला किनारा [4,1]नए नोड नंबरिंग के तहत नोड 6 और 1 के बीच है और इसलिए बढ़त 6-1 = 5 है।

[[1, 5, 2, 6, 3, 4, 7], [5, 4, 6, 3, 2, 1]]
[[1, 4, 2, 3], [3, 2, 1]]
[[1, 5, 3, 4, 2], [4, 2, 1, 3]]

वास्तव में प्रत्येक परीक्षण मामले के लिए कई विलेय हैं। returnसमारोह बंद हो जाता है एक बार पहले एक पाया जाता है।