अंतराल का संघ

Question

अंतराल की एक सूची को देखते हुए, उनमें से संघ का प्रदर्शन करें, और ओवरलैप को कम करें। इसका मतलब है, अतिव्यापी भागों को कम कर दिया जाता है। ( [a, b] U [c, d] = [a, d]यदि b > c) सभी अंतरालों में सभी को एक मान लें [a, b]। इनपुट अंतराल की सूची के एक समारोह के रूप में लागू -> आउटपुट अंतराल की सूची। सबसे छोटा कोड जीतता है। आप किसी भी मौजूदा पुस्तकालयों का उपयोग नहीं कर सकते।

स्पष्टीकरण:

• खुले और बंद अंतराल प्रतिष्ठित नहीं हैं।
• वास्तविक संख्याओं के लिए अंतराल, पूर्णांक नहीं। ( [2, 3], [4, 5] -> [2, 3], [4, 5])
• आउटपुट अंतराल को सॉर्ट करने की आवश्यकता नहीं है
• आदेश अगर इनपुट से कोई फर्क नहीं पड़ता
• अवैध इनपुट केवल [a, b]जहां हैं b >= a, इसका इनपुट अंतराल के क्रम और इनपुट अंतराल की संख्या से कोई लेना-देना नहीं है।
• आपको अपरिभाषित व्यवहारों पर त्रुटि संदेश दिखाने की आवश्यकता नहीं है

उदाहरण (संख्या रेखाओं के साथ)

 [2, 4], [7, 9] --> [2, 4], [7, 9]
   234
        789
-> 234  789

 [1, 5], [2, 10] --> [1, 10] (overlapping [2, 5] reduced)

   12345
    234567890
-> 1234567890
 [2, 4], [3, 6], [8, 9] -> [2, 6], [8, 9]
   234
    3456
         89
-> 23456 89

 [4, 2], [2, 2] -> (undefined behavior: against the assumption)

Comments

क्या अंतराल हमेशा हल किए जाएंगे क्योंकि वे आपके उदाहरणों में हैं?

— पीटर ओल्सन

[२, ३], [४, ५] ओवरलैप या [२, ४], [४, ५] या तो क्यों नहीं? इन दोनों की उपज 2345 है।

— मेलमोकब

क्या पूर्णांक के सेट पर ही अंतराल हैं?

— लोजैकर

हमें कुछ स्पष्टीकरण की आवश्यकता है: 1) क्या [४,५], [१,२] कानूनी इनपुट है? 2) क्या [2,3], [4,5] का उत्पादन [2,5] या [2,3], [4,5] होना चाहिए? 3) क्या [2,3], [3,4] का उत्पादन [2,4] या [2,3], [3,4] होना चाहिए?

— माउंटन व्यूमार्क

स्पष्टीकरण के लिए धन्यवाद, लेकिन "सॉर्ट करने की आवश्यकता नहीं है" का मतलब क्या है? आउटपुट की छंटनी की जरूरत नहीं है? या कि इनपुट पहले से ही हल है?

— माउंटनवार्कर

Answer 1

GolfScript, 32

[{1$1$*-2%~2->{*$[(\)\;]}{}if}*]

• यदि आप एक ब्लॉक पसंद करते हैं तो 4, यदि आप एक नामित ब्लॉक पसंद करते हैं, तो 2 वर्ण जोड़ें।
• इनपुट और आउटपुट जोड़े की सरणी हैं, उदाहरण के लिए [[2 4] [3 5]]
• मान लेता है कि इनपुट पहले तत्व द्वारा आदेशित है।
• कॉम्पैक्ट्स "आसन्न" पर्वतमाला ([२ ४] [५ ६] -> [२ ६])
• पहला गोल्फस्क्रिप्ट प्रयास। सलाह और सड़े हुए फल की सराहना की।

पूर्ण परीक्षण कार्यक्रम:

[~](;2/[{1$1$*-2%~2->{*$[(\)\;]}{}if}*]`

उदाहरण आह्वान:

ruby golfscript.rb intervals.gs <<EOF
3
2 4
3 6
8 9
EOF
# Expected output: [[2 6] [8 9]]

Answer 2

हास्केल (103)

मुझे लगता है, यह वैसे भी हास्केल के लिए क्रिया है। अपने छँटाई समारोह के लिए होआ लॉन्ग टैम का धन्यवाद।

m%(x:y)|x>m=m:x:y|2>1=x:m%y;m%_=[m]
(x:y)?l|x`elem`l=y?l|0<1=x:y?(x:l);a?_=a
a∪b=foldr(%)[](a++b)?[]

हास्केल में, से एक intervall aकरने bसे दर्शाया जाता है [a..b]। मेरा अंकन गणितीय अंकन के समान है। इसे इस तरह उपयोग करें:

[a..b] ∪ [c..d] ∪ ... ∪ [y..z]

Answer 3

ठीक है, यहाँ मेरा 250 चरित्र दरार है।

void n(int a[]){if(!a[2])return;if(a[2]<=a[1]){if(a[1]<a[3])a[1]=a[3];
int *b=a+2;while(*b=*(b+2))++b;n(a);}n(a+2);}
void m(int a[]){if(!a[2])return;if(a[0]>a[2]){int s=a[0],t=a[1];
a[0]=a[2];a[2]=s;a[1]=a[3];a[3]=t;m(a+2);m(a);n(a);}m(a+2);n(a+2);}

फ़ंक्शन एक अंतर सरणी लेता है, और उस पर इन-सीटू संचालित करता है। सरणी को 0 से समाप्त किया जाता है, और अंतराल किसी भी क्रम में दिया जा सकता है।

नमूना उत्पादन:

input list: (7,9) (5,6) (1,4) (15,18) (13,16) (2,3) (8,11) 
output list: (1,4) (5,6) (7,11) (13,18) 

नमूना कार्यक्रम:

#include <stdio.h>

void n(int a[]){if(!a[2])return;if(a[2]<=a[1]){if(a[1]<a[3])a[1]=a[3];
int *b=a+2;while(*b=*(b+2))++b;n(a);}n(a+2);}
void m(int a[]){if(!a[2])return;if(a[0]>a[2]){int s=a[0],t=a[1];
a[0]=a[2];a[2]=s;a[1]=a[3];a[3]=t;m(a+2);m(a);n(a);}m(a+2);n(a+2);}


/*
void n(int a[])
{
    if(!a[2])return;
    if(a[2]<=a[1]) {
        if(a[1]<a[3])
            a[1]=a[3];
        int *b=a+2;
        while(*b=*(b+2))++b;
        n(a);
    }
    n(a+2);
}

void m(int a[])
{
    if(!a[2])return;
    if(a[0]>a[2]) {
        int s=a[0],t=a[1];
        a[0]=a[2];a[2]=s;
        a[1]=a[3];a[3]=t;
        m(a+2);m(a);n(a);
    }
    m(a+2);n(a+2);
}
*/

void p(int a[]) 
{
    if(!*a) {
        printf("\n");
        return;
    }
    printf("(%d,%d) ",a[0],a[1]);
    p(a+2);
}

int main (int argc, const char * argv[]) 
{
    // Code golf entry
    // Interval Merging

    int a[] = {7,9,5,6,1,4,15,18,13,16,2,3,8,11,0};
    printf( "input list: " ); p(a);
    m(a);
    printf( "output list: " ); p(a);

    return 0;
}

Comments

perform the union of themनेतृत्व करना चाहिए (1,11) (13,18), यह नहीं करना चाहिए?

— उपयोगकर्ता अज्ञात

@user अज्ञात: मैंने एक ही बात सोची होगी, लेकिन मुझे लगता है कि निर्देशों का कहना है कि यदि वे ओवरलैप करते हैं तो केवल गठबंधन करें। इसलिए (1, 4) (5, 6) नियम के अनुसार संयुक्त नहीं हैं ([a, b] U [c, d] = [a, d] if b > c)। और उस मामले के लिए, यहां तक ​​कि (1, 5) (5, 6) संयुक्त नहीं होगा।

— मेलमोकब

"अंतराल की एक सूची को देखते हुए, उनमें से संघ का प्रदर्शन करें, और ओवरलैप को andकम करें " ओवरलैप को कम करें - नहीं if they overlap। ठीक है - निम्नलिखित that means ...बिंदुओं को फिर से विपरीत दिशा में।

— उपयोगकर्ता अज्ञात

@user अज्ञात: मैं सहमत हूं। इसलिए मैंने इसके बारे में सवाल पर टिप्पणी की है। उम्मीद है कि ओपी जवाब देगा :)

— mellamokb

Answer 4

अजगर, 100 चरस

def f(L):R=sorted(set(p for p in sum(L,[])if 1-any(x<p<y for x,y in L)));return zip(R[::2],R[1::2])
print f([[2, 4], [7, 9]])
print f([[1, 5], [2, 10]])
print f([[3, 6], [2, 4], [8, 9]])
print f([[1, 5], [3, 5], [4, 5]])

उत्पन्न करता है

[(2, 4), (7, 9)]
[(1, 10)]
[(2, 6), (8, 9)]
[(1, 5)]

अंतराल के सभी समापन बिंदुओं को लेता है, किसी भी अन्य अंतराल के अंदर कड़ाई से हटाता है, उन्हें विशिष्ट करता है और उन्हें सॉर्ट करता है, और जोड़े देता है।

Comments

— a

Answer 5

हास्केल, 55 वर्ण

v(q@(a,b):p@(c,d):r)|c>b=q:v(p:r)|1<3=v((a,d):r);v x=x

यदि इनपुट अनसोल्ड है, तो 88 अक्षर:

p@(a,b)§(q@(c,d):r)|b<c=p:q§r|a>d=q:p§r|1<3=(min a c,max b d)§r;p§_=[p]
u i=foldr(§)[]i

टेस्ट रन:

ghci> testAll v
pass: [(2,4),(7,9)] --> [(2,4),(7,9)]
pass: [(1,5),(2,10)] --> [(1,10)]
pass: [(2,4),(3,6),(8,9)] --> [(2,6),(8,9)]
ghci> testAll u
pass: [(2,4),(7,9)] --> [(2,4),(7,9)]
pass: [(1,5),(2,10)] --> [(1,10)]
pass: [(2,4),(3,6),(8,9)] --> [(2,6),(8,9)]

मैं मान रहा हूं कि "किसी भी मौजूदा लाइब्रेरी का उपयोग नहीं कर सकता" आयात Listऔर कॉल करने को रोकता है sort। यदि वह कानूनी था, तो बिना संस्करण के केवल 71 वर्ण होंगे।

Comments

Listपैकेज से आयात Haskell98पर्याप्त IMHO होगा।

— फ़ूजक्कल

Answer 6

स्काला, 272 वर्ण

type p=List[(Int,Int)];def f(l:p):p={var(a,s,c,o)=(new Array[Int]((l map(x=>x._2)max)+1),0,0,List[Int]());l map(x=>(a(x._1)+=1,a(x._2)-=1));while(c<a.size){s+=a(c);if(a(c)==1&&s==1)o=o:+c;if(a(c)== -1&&s==0)o=o:+c;c+=1};return(o.grouped(2).map(x=>(x.head,x.last)).toList)}

उपयोग:

object Intervals2 extends Application
{
    type p=List[(Int,Int)];def f(l:p):p={var(a,s,c,o)=(new Array[Int]((l map(x=>x._2)max)+1),0,0,List[Int]());l map(x=>(a(x._1)+=1,a(x._2)-=1));while(c<a.size){s+=a(c);if(a(c)==1&&s==1)o=o:+c;if(a(c)== -1&&s==0)o=o:+c;c+=1};return(o.grouped(2).map(x=>(x.head,x.last)).toList)}

    print(f(List((1,2),(3,7),(4,10))))
}

एक सरणी बनाता है और प्रत्येक अंतराल के प्रारंभ के लिए 1 और प्रत्येक अंतराल के अंत के लिए -1 सम्मिलित करता है। फिर सरणी के माध्यम से मानों को जोड़ने के लिए एक काउंटर को शुरू करने के लिए हर बार काउंटर को 0 से 1 तक और जब यह 1 से 0. तक कदम रखता है और संभवतः अनावश्यक रूप से जटिल होता है।

आउटपुट:

List((1,2), (3,10))

Answer 7

पर्ल (146) (92) (90)

रेगेक्स इंजन का उपयोग करके रचनात्मक रूप से 90 चार्ट तक नीचे गिरा

उप u {नक्शा $ h [$ _] = 1, @ $ _ [0] .. @ $ _ [1] @_ के लिए; $ w। = $ _ + 0for @ h; पुश @ r, $ - [0 ], $ + [0] -1while $ w = ~ / 1 + / जी; @r}

उपयोग उदाहरण:

मेरे @ आउट 1 = यू ([1, 5], [2, 10]); # (1,10)
मेरे @ आउट 2 = यू ([2, 4], [3, 6], [8, 9]); # (2, 6, 8, 9)

चलिए इस कोड को थोड़ा समझाते हैं।

इस सबरूटीन को एरेइरेफ़्स का एक सरणी प्राप्त होता है, प्रत्येक एरेफ़ दो तत्वों से युक्त एक ऐरे की ओर इशारा करता है, अंतराल का प्रारंभ और अंत: ([2, 4], [3, 6], [8, 9])

प्रत्येक एरेफ के लिए, हम पहले से आखिरी तक तत्वों की एक सरणी उत्पन्न करते हैं ($_->[0] .. $_->[1])। तब हम @h से 1 में ऐसे अनुक्रमित तत्वों को सेट करने के लिए मानचित्र का उपयोग करते हैं।

के लिये (@_) {
    मानचित्र {$ h [$ _] = 1} ($ _-> [0] .. $ _-> [1]);
}

इसके बाद, @hस्पष्टता के लिए हाइफ़न के रूप में नीचे दिए गए या तो (अंतराल के लिए) या undefs शामिल होंगे।

सूचकांक: 0 1 2 3 4 5 6 7 8 9
@ ह: - - १ १ १ १ १ १ - १ १

अगले हम @ से एक स्ट्रिंग बनाते हैं, कुछ और उपयोगी के साथ undefs को बदलने के लिए 0 को जोड़ते हैं (undef + 0 = 0)।

$w .= $_+0 for @h;

$ w में 011111011अभी शामिल है।

यह रेगेक्स इंजन का दुरुपयोग करने का समय है।

push @r, ($-[0], $+[0]-1) while $w=~/1+/g;

सफल मैचों के बाद, प्रत्येक मैच के प्रारंभ और अंत में क्रमशः @ - और @ + सरणियाँ होती हैं; पूरे मैच के लिए 0 वें तत्व का उपयोग किया जाता है, पहले $ 1 के लिए, दूसरा $ 2 के लिए और इसी तरह।

$+[0] वास्तव में पहले गैर-मिलान चार की स्थिति शामिल है, इसलिए हमें एक को बदलना होगा।

@r(2, 6, 8, 9)अब शामिल है

@r

उप वापसी करने के लिए @r।

Comments

असली संख्या [2,3],[4,5]पैदावार के लिए काम नहीं करता है2 5

— Xcali

Answer 8

बिना आह्वान के स्काला 305 279 चरस:

type I=(Int,Int)
def l(p:I,q:I)=if(p._1<q._1)true else if(p._1>q._1)false else p._2<q._2
def r(l:List[I]):List[I]=l match{case x::y::z=>{if(y._1<=x._2&&y._2>x._2)(x._1,y._2)::r(z)else
if(y._1<=x._2&&y._2<=x._2)x::r(z)else  
x::r(y::z)}case _=>l}
def c(v:List[I])=r(v.sortWith(l))

मंगलाचरण:

val i=List((7,9),(5,6),(1,4),(15,18),(13,16),(2,3),(8,11))
c(i)
res0: List[(Int, Int)] = List((1,4), (5,6), (7,11), (13,18))

Answer 9

ब्रेकीलॉग , 12 बाइट्स

⟦₂ᵐcod~c~⟦₂ᵐ

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

एक खुशी से घोषित समाधान, इनपुट चर के माध्यम से सूचियों की सूची के रूप में इनपुट लेना और आउटपुट चर के माध्यम से सूचियों की सूची तैयार करना।

        ~⟦₂ᵐ    The output is a list of intervals, where each interval is a range in
      ~c        the smallest partition of
  ᵐ             each element of the input
⟦₂              converted to an inclusive range,
   c            concatenated,
    o           sorted,
     d          and deduplicated
        ~⟦₂ᵐ    for which each element of the partition is a range.

Answer 10

क्लोजर, 138 बाइट्स

#(let[S(set(apply mapcat range(apply map list %)))Q(sort S)](map list(for[s Q :when(not(S(dec s)))]s)(for[s(map inc Q):when(not(S s))]s)))

यदि इनपुट अधिक लचीला है, तो यह 119 बाइट्स को छोटा कर देता है, अर्थात अंतराल के एक बिंदु की सूची और अंतराल की सूची 'समाप्त' होती है:

#(let[S(set(mapcat range % %2))Q(sort S)](map list(for[s Q :when(not(S(dec s)))]s)(for[s(map inc Q):when(not(S s))]s)))

कोई बेहतर तरीका ज़रूर होगा।

Answer 11

जाप , 18 बाइट्स

यह बहुत लंबा लगता है। I / O को छाँटे गए, अंतराल के 2D सरणी।

c_ròÃòÈaY Éîg[TJ]

कोशिश करो

Answer 12

पर्ल 5 -MList::Util=max -n , 89 बाइट्स

@r=/\S+/g;map{/ /;$`<=$r[1]?$r[1]=max@r,$'*1:(say"@r")|(@r=($`,$'))}sort{$a-$b}<>;say"@r"

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