संघबद्ध अंतराल संकेतन में 2 सेटों का अंतर ज्ञात कीजिए

Question

संघबद्ध अंतराल संकेतन में 2 सेटों का अंतर ज्ञात कीजिए

अंतराल के मिलन के रूप में वर्णित वास्तविक संख्याओं के दो सेटों को देखते हुए, एक ही प्रकार के अंतराल के संघ के रूप में इन दो सेटों के प्रतिच्छेदन का वर्णन प्रस्तुत किया जाता है।

इनपुट सेट हमेशा अंतराल के यूनियनों से मिलकर बना होता है जैसे कि प्रत्येक अंतराल एक अलग पूर्णांक पर शुरू होता है और समाप्त होता है (अर्थात किसी अंतराल में शून्य माप नहीं होता है)। हालाँकि, एक ही सेट में अलग-अलग अंतराल एक ही पूर्णांक या ओवरलैप पर शुरू या समाप्त हो सकते हैं।

आउटपुट सेट भी अंतराल का एक संघ होना चाहिए जो पूर्णांक पर शुरू और समाप्त होता है, लेकिन आउटपुट में कोई भी अंतराल किसी एक पूर्णांक पर भी ओवरलैप नहीं कर सकता है ।

इनपुट किसी भी रूप को ले सकता है जो आपकी पसंद की भाषा के लिए उपयुक्त है, जब तक कि इसमें पूर्णांकों के जोड़े की दो सूची शामिल हैं।

उदाहरण के लिए, आप सेट का प्रतिनिधित्व कर सकते हैं रूप :

[-10,-4]u[1,5]u[19,20]

या के रूप में:

[[-10,-4],[1,5],[19,20]]

या के रूप में:

[-10,-4;1,5;19,20]

आपका आउटपुट प्रतिनिधित्व आपके इनपुट प्रतिनिधित्व के समान होना चाहिए (सिवाय इसके कि यह दो के बजाय केवल अंतराल की एक सूची है)।

उदाहरण / परीक्षण के मामले:

इनपुट:

[[[-90,-4],[4,90]],[[-50,50]]]

आउटपुट:

[[-50,-4],[4,50]]

दूसरे शब्दों में, हम उस सेट को इंटरसेक्ट कर रहे हैं जिसमें -90 और -4 के बीच सभी वास्तविक संख्याएँ हैं और सभी वास्तविक संख्याओं के बीच 4 और 90 के बीच सेट है जिसमें सभी वास्तविक संख्याएँ -50 और 50 के बीच हैं। प्रतिच्छेदन सभी से युक्त सेट है -50 और -4 के बीच वास्तविक संख्या और 4 और 50 के बीच सभी वास्तविक संख्या। अधिक दृश्य स्पष्टीकरण:

-90~~~~~-4  4~~~~~90   intersected with
    -50~~~~~~~~50        yields:
    -50~-4  4~~50

---

इनपुट:

"[-2,0]u[2,4]u[6,8]
[-1,1]u[3,5]u[5,9]"

आउटपुट:

"[-1,0]u[3,4]u[6,8]"

---

इनपुट:

[-9,-8;-8,0;-7,-6;-5,-4]
[-7,-5;-1,0;-8,-1]

आउटपुट:

[-8,0]

अमान्य आउटपुट (भले ही वह समान सेट का प्रतिनिधित्व करता हो):

[-8,0;-7,-5;-5,0]

स्कोरिंग:

यह कोड-गोल्फ है बाइट्स जीत में इतना छोटा स्रोत है, जैसा कि संभावित रूप से निम्न बोनस द्वारा संशोधित किया गया है।

बक्शीश:

-15% अगर आप भी अंतराल की सीमा के रूप में सकारात्मक और नकारात्मक अनंत का समर्थन करते हैं। आप चुन सकते हैं कि इन नंबरों का क्या टोकन है। (और हाँ, अनन्तता हाइपररेल्स में एक संख्या है; पी)

Comments

क्या हम मान सकते हैं कि प्रत्येक चौराहे के समंदर में विभिन्न संघटित सेट बढ़ते क्रम में लिखे गए हैं? दूसरे शब्दों में (लेकिन इसके विपरीत), निम्नलिखित इनपुट वैध है? [[[4,90],[-90,-4]],[[-50,50]]]

— msh210

@ msh210 तीसरे उदाहरण को इस सवाल का जवाब देना चाहिए। (नहीं। उन्हें स्वयं क्रमबद्ध करें।)

— क्विंटोपिया

@ नमि तुम सही हो। तय

— क्विंटोपिया 19

Answer 1

गणितज्ञ, 41 बाइट्स - 15% = 34.85

Mathematica में इंटरवल चौराहे के लिए एक अंतर्निहित फ़ंक्शन होता है।

List@@IntervalIntersection@@Interval@@@#&

उदाहरण:

In[1]:= List@@IntervalIntersection@@Interval@@@#&[{{{-90, -4}, {4, Infinity}}, {{-50,Infinity}}}]

Out[1]= {{-50, -4}, {4, Infinity}}

Comments

वाह ... मैं बस इसे पढ़ने के बिना एक ही समाधान के साथ आया था। +1

— लीजनमैनल 978

गोटे को मैथमेटिका का ऑटो-यूनियनिंग से प्यार है Interval।

— mbomb007

Answer 2

हास्केल, 145 बाइट्स

import Data.List
q(a,b)=[a,a+0.5..b]
p@(a,b)%(h:t)|h==b+0.5=(a,h)%t|1<2=p:(h,h)%t
p%_=[p]
a#b|h:t<-nub$sort$intersect(q=<<a)$q=<<b=(h,h)%t|1<2=[]

प्रयोग उदाहरण: [(-2.0,0.0),(2.0,4.0),(5.0,6.0),(6.0,8.0)] # [(-1.0,1.0),(3.0,5.0),(5.0,9.0)]-> [(-1.0,0.0),(3.0,4.0),(5.0,8.0)]।

यह काम किस प्रकार करता है:

                 q=<<a            -- turn each pair in the 1st input list into
                                  -- lists with halves in between (e.g. (1,4) ->
                                  -- [1,1.5,2,2.5,3,3.5,4]) and concatenate them
                                  -- to a single list
                      q=<<b       -- same for the second input list
    nub$sort$intersect            -- sort the intersection of those lists
                                  -- and remove duplicates
h:t<-                             -- call the first element h and the rest t
                       (h,h)%t    -- start rebuilding the intervals
                          |1<2=[] -- if there's no first element h, one of the
                                  -- input lists is empty, so the output is also
                                  -- empty


p@(a,b)%(h:t)                     -- an interval p = (a,b), build from a list (h:t)
             =(a,h)%t             -- becomes (a,h)
      |h==b+1                     --   if h equals b+0.5
                    p:(h,h)%t     -- or is put in the output list, followed by
                                  --       a new interval starting with (h,h)
      |1<2                        --   otherwise
p%_=[p]                           -- base case of the interval rebuilding function 

मैं "आधा" x.5सूची में डाल रहा हूं , क्योंकि मुझे इससे अलग (1,2),(3,4)होने की आवश्यकता है (1,4)। इसके बिना x.5, दोनों बन जाएंगे [1,2,3,4], लेकिन x.51 के साथ [1,1.5,2,3,3.5,4](जिसमें कमी है 2.5) और दूसरा [1,1.5,2,2.5,3,3.5,4]।

Comments

आउटपुट इनपुट के समान होना चाहिए। ... तो बस यह कहें कि आपके इनपुट की जरूरत है .0 प्रत्येक पूर्णांक के बाद भी;)

— क्विंटोपिया

@ क्विंटोपिया: हां, धन्यवाद।

— nimi

Answer 3

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

दो सेटों में से प्रत्येक को एक फ्लैट सरणी में मैप करें, उन सरणियों के सेट चौराहे को प्राप्त करता है, फिर परिणाम को कंटोस चंक्स में स्लाइस करता है और प्रत्येक चंक को पहले और अंतिम तत्व में मैप करता है। बहुत आसान।

->s{a,b=s.map{|y|y.flat_map{|f,l|[*f..l]}.sort}
(a&b).slice_when{|a,b|b-a>1}.map &:minmax}

उपयोग:

f=->s{a,b=s.map{|y|y.flat_map{|f,l|[*f..l]}.sort}
(a&b).slice_when{|a,b|b-a>1}.map &:minmax}

s = [[[-90,-4],[4,90]], [[-50,50]]]
p f[s] # => [[-50, -4], [4, 50]]

s = [[[-2,0],[2,4],[6,8]], [[-1,1],[3,5],[5,9]]]
p f[s] # => [[-1, 0], [3, 4], [6, 8]]

s = [[[-9,-8],[-8,0],[-7,-6],[-5,-4]],[[-7,-5],[-1,0],[-8,-1]]]
p f[s] # => [[-8, 0]]

Comments

आपके प्रोग्राम का आउटपुट क्या है s = [[[1,2],[3,4]], [[1,2],[3,4]]]? (मेरा माणिक संस्करण मेरे पास नहीं है slice_when, इसलिए मैं खुद का परीक्षण नहीं कर सकता)

— 9'15

@ मिमी यह देता है [[1, 4]]। slice_whenविधि रूबी 2.2 के आसपास कहीं मुझे लगता है कि जोड़ दिया गया।

— डेनियरो

... लेकिन यह होना चाहिए [[१,२], [३,४]]

— निम्मी

सेट वास्तविक संख्या से अधिक हैं, केवल अंतराल सीमाएं पूर्णांक हैं, इसलिए 2.2इनपुट में नहीं है s = [[[1,2],[3,4]], [[1,2],[3,4]]], लेकिन आपके आउटपुट में है [[1, 4]]।

— नीमी

हम्म, तुम सही हो। यह स्पष्ट किया जा सकता है / गणितीय रूप से खुद को चुनौती देने के लिए थोड़ा सा खाली कर दिया गया ..

— daniero