🐃 🔺 🚣🏾 रैखिक और बंद नामस्थानों में कम्प्यूटिंग अंतर्क्रिया 👶🏾 🐖 🎢

आपका स्वागत है! और एक बार मैं बहुत परिष्कृत नाम के लिए माफी माँगता हूँ, लेकिन यह सबसे नीचे दी गई सामग्री को पूरी तरह से दर्शाता है।

मुझे लगता है कि आप में से कई का सामना इंटरसेक्टिंग अंतराल की गणना करने की आवश्यकता से है। लेकिन दूसरे दिन मैंने जिस कार्य का सामना किया वह इतना तुच्छ नहीं था। लेकिन, पहली चीजें पहले।

एक रेखीय नाम स्थान में अंतरालीय अंतराल की गणना

यदि आपके पास पहले से ही अंतराल को समाप्त करने का विचार है, तो यहां ठीक से जाएं।

समय की सीधी रेखा पर समय अंतराल (समय अंतराल) के चौराहों की गणना मुश्किल नहीं है। हमारे पास सशर्त रूप से पांच प्रकार के अस्थायी चौराहे हो सकते हैं।
हम समय के एक खंड को "\" और दूसरे को "/ /" के रूप में निरूपित करते हैं

समय अक्ष में आगे बढ़ना "/ \ / \"
समय अक्ष के साथ पिछड़ा हुआ "\ / \ /"
घटना "/ \ /"
अवशोषण "\ / / \"
मैच XX

इस प्रकार, हम प्रत्येक विशिष्ट चौराहे को संकेतों <,> और = का उपयोग करके व्यक्त कर सकते हैं। और शस्त्रागार में संकेत <=> = होने से, हम गणना के लिए खाके की संख्या को चार तक कम कर सकते हैं (इस प्रकार, विलय, "प्रविष्टि" और "संयोग" या "अवशोषण" और "संयोग" या "विस्थापन और" संयोग ") । इसके अलावा, "प्रवेश" या "अवशोषण" (लेकिन दोनों नहीं) को भी "विस्थापन" के एक विशेष मामले पर विचार करते हुए समाप्त किया जा सकता है।
तो, फॉर्म की एक तालिका होने:

उपयोगकर्ता	प्रारंभ	अंत
user1	2	7
user2	5	9
user3	8	11
user4	1	12

तालिका से चुनने के लिए सभी उपयोगकर्ता दिए गए अंतराल को पार करते हैं (4-8 कहते हैं), हम क्वेरी का उपयोग करते हैं:

SET @start:=4; SET @end:=8; SELECT * FROM `table` WHERE (`start` >= @start AND `start` < @end) /* */ OR (`end` <= @end AND `end` > @start) /* */ OR (`start` < @end AND `end` > @start) /* -            */ OR (`start` >= @start AND `end` <= @end)/*  */

यह क्वेरी पहले, दूसरे और तीसरे उपयोगकर्ता को लौटाएगी। यह बहुत आसान है।

हम्म। लेकिन क्या होगा यदि आप अंतराल अंतराल का चयन करना चाहते हैं?
वास्तव में, सब कुछ और भी सरल है: चौराहे के विपरीत, चौराहे के केवल दो मामले हैं:

बैकवर्ड ऑफ़सेट "\ \ / /"
फॉरवर्ड ऑफ़सेट "/ / \ \"

और समय की एक सतत रेखा पर हमें केवल यह जांचना होगा कि क्या एक अंतराल का अंत दूसरे की शुरुआत से कम है।
और SQL क्वेरी घटा दी जाती है

 SET @start:=4; SET @end:=8; SELECT * FROM `table` WHERE `start` >= @end OR `end` <= @start /*  */

और यहां हम अभिव्यक्तियों की उपेक्षा को याद करते हैं। यदि गैर-चौराहों की गणना करना प्रतिच्छेद करने की तुलना में बहुत आसान है, तो फिर सभी गैर-चौराहों को क्यों नहीं छोड़ना चाहिए?

 WHERE NOT ( `start` >= @end OR `end` <= @start )

हम कोष्ठक खोलते हैं (धन्यवाद याग्ज़ ):

 WHERE `start` < @end AND `end` > @start

वाह रे! सब कुछ बहुत अधिक संक्षिप्त है!

यह सब बहुत सुंदर है, और महान काम करता है ... जबकि समय रेखा सीधी है।

बंद नामस्थानों में कम्प्यूटिंग अंतराल

हमने समय रेखा पर गणना की। तो एक "बंद" नाम स्थान क्या है?

यह एक ऐसा नामस्थान है, जब पहले क्रम के नाम समाप्त हो जाते हैं, एक नए क्रम पर नहीं जाता है, लेकिन इसकी शुरुआत में लौटता है।

रैखिक नाम स्थान:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 ...

बंद नाम स्थान:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 ...

मान लें कि हमारे पास काम की अनुसूची के साथ एक तालिका है (इसे एक चौबीस घंटे कॉल सेंटर होना चाहिए):
* मिनट "00" अभिव्यक्ति की आसानी के लिए छोड़ दिया जाता है

usrer	प्रारंभ	अंत
usrer1	0	6
usrer2	6	12
usrer3	12	18
usrer4	18	23

मैं 10 से 19 तक काम करता हूं और मैं जानना चाहता हूं कि कौन से कार्यकर्ता मेरे काम के कार्यक्रम को पार करेंगे।
हम योजना में पहले दिए गए चयन को बनाते हैं:

 SET @start:=10; SET @end:=19; SELECT * FROM `table` WHERE NOT ( `start` >= @end OR `end` <= @start )

सब कुछ बहुत अच्छा है! मुझे तीन श्रमिकों का डेटा मिला, जिनका अंतराल खदान के साथ ओवरलैप होता है।

ठीक है, अगर मैं रात में काम करूं तो क्या होगा? 20 से 6 तक कहते हैं? यही है, मेरे अंतराल की शुरुआत इसके अंत से अधिक है। इन शर्तों के तहत तालिका से एक चयन पूरी तरह से बकवास लौटाएगा। यही है, एक दुर्घटना तब होती है जब मेरा समय अंतराल "शून्य" दिन के निशान को पार करता है। लेकिन आखिरकार, "शून्य" चिह्न को अंतर करने वाले अंतराल को डेटाबेस में भी संग्रहीत किया जा सकता है।
मुझे दो दिन पहले इसी तरह की समस्या का सामना करना पड़ा था।

एक ग़ैर-रेखीय संरचना के डेटा के साथ एक तालिका से एक रैखिक विधि द्वारा अंतराल के नमूने की समस्या चेहरे पर थी।
मेरे साथ पहली बात यह थी कि दिन के स्थान को 48 घंटे तक विस्तारित करना था, जिससे "शून्य" निशान से छुटकारा मिला। लेकिन यह प्रयास क्रैश हो गया - क्योंकि 1 और 3 के बीच का अंतर 22 और 27 (3) के बीच के नमूने में नहीं जा सका। हाँ! अब, अगर मेरे पास एक चौबीस नंबर सिस्टम था, तो मैं बस दूसरे क्रम के संकेत और सभी चीजों को हटा दूंगा।

मैंने इंटरनेट पर इस समस्या का हल खोजने की कोशिश की। "रैखिक" समय पर अंतराल के चौराहे पर जानकारी बहुत थी। लेकिन या तो इस प्रश्न की व्यापक चर्चा नहीं हुई, या SQL गुरुओं ने "खुद के लिए" समाधान का आयोजन किया - एक बंद प्रणाली में कहीं भी कोई समाधान नहीं था।

सामान्य तौर पर, सलाह मंचों पर गुरुओं से पूछते हुए, मुझे एक समाधान मिला: "शून्य" को दो भागों में विभाजित करने वाले अंतराल को विभाजित करना आवश्यक था, जिससे दो रैखिक अंतराल प्राप्त होते हैं, और तालिका में अंतराल के साथ दोनों की तुलना करते हैं (जिसे भी दो भागों में विभाजित करना पड़ता था। यदि वे शून्य को पार करते हैं)। समाधान काम किया और काफी स्थिर था, हालांकि यह बोझिल था। हालांकि, यह महसूस करना कि सब कुछ "बहुत सरल" था, मुझे नहीं छोड़ा।
और इसलिए, इस प्रश्न के लिए कुछ घंटों का चयन करने के बाद, मैंने एक नोटबुक और एक पेंसिल ली ... मुझे जो मिला वह ले आया:

लब्बोलुआब यह है कि दिन समय की एक बंद रेखा है - एक चक्र।
और समय अंतराल इस चक्र के चाप का सार है।
इस प्रकार, गैर-चौराहों को नकारने के लिए (पोस्ट का पहला भाग देखें), हम गैर-अंतर-संचालन योजनाओं की एक जोड़ी बना सकते हैं:

पहले मामले में, हमारे पास गैर-चौराहों की उपेक्षा के लिए सामान्य रैखिक योजना है। दूसरे में से एक आर्क्स "शून्य" चिह्न को दबा देता है। एक तीसरा मामला है, जिसे तुरंत एक चौराहे के रूप में स्वीकार किया जा सकता है (गैर-प्रतिच्छेदन के नकारात्मक के बिना):

दोनों अंतराल "शून्य" चिह्न को पार करते हैं, जिसका अर्थ है कि वे परिभाषा द्वारा प्रतिच्छेद करते हैं। इसके अलावा, दो और मामले हैं जहां अंतराल (तालिका से दर्ज और लिया गया) "अदला-बदली" है।
आधार के साथ थोड़ा सा संयुग्मित होना (कहीं न कहीं अत्यधिक वैज्ञानिक प्रहार की पद्धति का उपयोग करके), मैं इस अनुरोध को एकत्र करने में कामयाब रहा:

 SET @start:= X ; SET @end:= Y; SELECT * FROM `lparty_ads` WHERE ((`prime_start` < `prime_end` AND @start < @end) AND NOT (`prime_end`<= @start OR @end <=`prime_start` ) OR (( (`prime_start` < `prime_end` AND @start > @end) OR (`prime_start` > `prime_end` AND @start < @end)) AND NOT ( `prime_end` <= @start AND @end <= `prime_start` )) OR (`prime_start` > `prime_end` AND @start > @end))

और kirillzorin से एक टिप्पणी से एक सरलीकृत संस्करण:

 set @start := X; set @end := Y; select * from tab where greatest(start, @start) <= least(end, @end) or ((end > @start or @end > start) and sign(start - end) <> sign(@start - @end)) or (end < start and @end < @start);

अनुरोध पूरी तरह से चालू है और, सबसे मज़ेदार है, किसी भी बंद संख्या प्रणाली के लिए सच है - यह घंटे, दिन, सप्ताह, महीने, वर्ष हो। और फिर भी, यह विधि "बैसाखी" का उपयोग नहीं करती है, जैसे कि अतिरिक्त क्षेत्र।

सबसे अधिक संभावना है, मैंने एक साइकिल का आविष्कार किया। लेकिन इस तथ्य के मद्देनजर कि मुझे खुद इस तरह की जानकारी नहीं मिली जब मुझे इसकी आवश्यकता थी - मुझे लगता है कि यह विधि बहुत व्यापक रूप से कवर नहीं है। इससे मेरी कहानी समाप्त होती है।

रैखिक और बंद नामस्थानों में कम्प्यूटिंग अंतर्क्रिया

एक रेखीय नाम स्थान में अंतरालीय अंतराल की गणना

बंद नामस्थानों में कम्प्यूटिंग अंतराल

More articles: