17

एक वास्तविक जीवन के परिदृश्य से प्रेरित है, जो मैंने यहाँ एक उत्तर के लिए कहा है: /superuser/1312212/writing-a-formula-to-count-how-many-times-each-date प्रतीत होता है-में-एक-सेट की तारीख दौड़ा

टाइमपास की एक सरणी (या स्टार्ट-एंडडेट जोड़े) को देखते हुए, कुल रेंज में सभी दिनों के लिए प्रत्येक दिन कितने टाइमपैन को कवर किया जाता है, इसकी एक संख्या का उत्पादन करें।

उदाहरण के लिए:

  #      Start      End
  1    2001-01-01 2001-01-01
  2    2001-01-01 2001-01-03
  3    2001-01-01 2001-01-02
  4    2001-01-03 2001-01-03
  5    2001-01-05 2001-01-05

उपरोक्त आंकड़ों को देखते हुए, परिणाम निम्नानुसार होने चाहिए:

2001-01-01: 3 (Records 1,2,3)
2001-01-02: 2 (Records 2,3)
2001-01-03: 2 (Records 2,4)
2001-01-04: 0
2001-01-05: 1 (Record 5)

आपको केवल प्रत्येक दिन के लिए गणना करने की आवश्यकता है (क्रम में, सबसे पुराना-नवीनतम क्रमबद्ध); न कि वे किस रिकॉर्ड में दिखाई देते हैं।

आप यह मान सकते हैं कि प्रत्येक बार के समय में केवल तिथियां होती हैं, समय नहीं; और इसलिए पूरे दिन हमेशा प्रतिनिधित्व करते हैं।

आई / ओ

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

आप मान सकते हैं कि इनपुट पहले की तरह छांटा गया है लेकिन आपको (आपके उत्तर में निर्दिष्ट) पसंद है। इनपुट तिथियां समावेशी होती हैं (इसलिए रेंज में संपूर्ण आरंभ और समाप्ति तिथियां शामिल हैं)।

आप यह भी मान सकते हैं कि, किसी भी सीमा में दो तिथियों में, पहला पुराना या दूसरे के बराबर होगा (यानी आपके पास नकारात्मक तिथि सीमा नहीं होगी)।

आउटपुट एक सरणी है जिसमें प्रत्येक दिन के लिए गिनती होती है, जो प्रारंभ तिथि द्वारा छांटे जाने पर सबसे पुराने से इनपुट में सबसे नए तक होती है।

तो, उपरोक्त उदाहरण के लिए आउटपुट होगा {3,2,2,0,1}

यह संभव है कि कुछ दिन किसी भी समय सीमा में शामिल नहीं हैं, जिस स्थिति 0में उस तिथि के लिए आउटपुट है।

जीत का मानदंड

यह कोड-गोल्फ है, इसलिए सबसे कम बाइट्स जीतती हैं। सामान्य बहिष्करण लागू होते हैं

छद्म एल्गोरिथ्म का उदाहरण

For each time range in input
    If start is older than current oldest, update current oldest
    If end is newer than current newest, update current newest
End For
For each day in range oldest..newest
   For each time range
       If timerange contains day
            add 1 to count for day
End For
Output count array

समान परिणाम प्राप्त करने के लिए अन्य एल्गोरिदम ठीक हैं।

code-golf date

— simonalexander2005
स्रोत

3

क्या पूर्णांक की एक सरणी की आवश्यकता है, या क्या हमें किसी और चीज़ को वापस करने की अनुमति है, प्रत्येक तिथि के साथ कुंजियों का एक शब्दकोश कहें? यदि हमें एक शब्दकोश वापस करने की अनुमति है, तो क्या हम उन तारीखों को छोड़ सकते हैं जो किसी भी समय में नहीं हैं?

— जुंगह्वान मिन

1

क्या हम इनपुट को दो सूचियों के रूप में ले सकते हैं, एक आरंभ तिथियों के साथ और दूसरा अंतिम तिथियों के साथ?

— ग्यूसेप

हाँ, उन सभी चीजें ठीक हैं, एक तारीख को छोड़कर - मैं स्पष्ट रूप से कहता हूं कि 0 उस मामले में आउटपुट होना चाहिए

— simonalexander2005

3

क्या मैं पूछ 0सकता हूं कि एक शब्दकोश में क्यों होना चाहिए? यह केवल से पुनरावृति करने के लिए उपयोगकर्ता के लिए मजबूर करने के लिए प्रकट min(input)करने के लिए max(input)है, जो चुनौती (कंप्यूटिंग timespans) के कोर करने के लिए कुछ भी जोड़ने की नहीं लगती।

— जुंगह्वान मिन

2

@ JungHwanMin मुझे लगता है कि यह इसे बदल नहीं सकता है; लेकिन क्योंकि मैं स्पष्ट रूप से यह कल्पना में था जब मैंने इसे पोस्ट किया था, मैं इसके साथ खिलवाड़ नहीं करना चाहता और किसी और को अपना जवाब फिर से बनाना चाहता हूं

— simonalexander2005

3

एपीएल (Dyalog यूनिकोड) , 32 बाइट्स ^SBCS

पूरा कार्यक्रम। अंतर्राष्ट्रीय तिथि संख्याओं (जैसे एक्सेल और MATLAB का उपयोग करें) के जोड़े की सूची के लिए संकेत स्टड। सूची और जोड़े दोनों किसी भी क्रम में दिए जा सकते हैं, उदाहरण के लिए (अंत, प्रारंभ)। स्टडआउट के लिए मायने रखता है प्रिंट की सूची।

¯1+⊢∘≢⌸(R,⊢)∊(R←⌊/,⌊/+∘⍳⌈/-⌊/)¨⎕ इसे ऑनलाइन आज़माएं!

यदि यह अमान्य है, तो (YMD) जोड़े की एक सूची को अतिरिक्त 21 बाइट्स के लिए परिवर्तित किया जा सकता है, कुल 53:

¯1+⊢∘≢⌸(R,⊢)∊(R⌊/,⌊/+∘⍳⌈/-⌊/)¨{2⎕NQ#'DateToIDN'⍵}¨¨⎕ इसे ऑनलाइन आज़माएं!

⎕ मूल्यांकन किए गए इनपुट के लिए शीघ्र कंसोल

(… )¨ प्रत्येक जोड़े के लिए निम्नलिखित tacit फ़ंक्शन लागू करें

⌊/ न्यूनतम (lit. न्यूनतम-कमी), अर्थात प्रारंभ तिथि

⌈/- अधिकतम (अर्थात अंतिम तिथि) शून्य से

⌊/+∘⍳ प्रारंभ दिनांक, श्रेणी 1-थ्रू-प्लस

⌊/, शुरुआत की तारीख उसी से जुड़ी थी

R← इस फ़ंक्शन को R( R ange के लिए) असाइन करें

∊ ϵ nlist (समतल) एक सूची में श्रेणियों की सूची

(… ) उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

R,⊢ आवेदन करने का परिणाम R(यानी तारीख सीमा) तर्क के बाद
^{(यह सुनिश्चित करता है कि सीमा में प्रत्येक तिथि का कम से कम एक बार प्रतिनिधित्व किया जाता है, और यह कि क्रमबद्ध क्रम में तारीखें दिखाई देती हैं)}

... ⌸ प्रत्येक जोड़ी के लिए अद्वितीय (तिथि, इनपुट में घटना के इसके सूचकांक), करें:

⊢∘≢ सूचकांकों के मिलान के पक्ष में वास्तविक तिथि को अनदेखा करें

¯1+ -1 को उन ऊँचाइयों पर जोड़ें (क्योंकि हमने सीमा में प्रत्येक तिथि को पूर्व निर्धारित किया था)

— एडम
स्रोत

9

जावास्क्रिप्ट (ईएस 6), 85 बाइट्स

Dateजोड़े की सूची के रूप में इनपुट लेता है । तारीख शुरू होने से सूची को छांटने की उम्मीद है। पूर्णांकों की एक सरणी देता है।

f=(a,d=+a[0][0])=>[a.map(([a,b])=>n+=!(r|=d<b,d<a|d>b),r=n=0)|n,...r?f(a,d+864e5):[]]

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

या 84 बाइट्स अगर हम जेएस टाइमस्टैम्प को इनपुट के रूप में ले सकते हैं (जैसा कि @Saggy द्वारा सुझाया गया है)

— Arnauld
स्रोत

आह, पागल!

— झबरा

इनपुट के रूप में आदिम मूल्यों को ले कर एक बाइट को बचाएं: TIO

— झबरा

7

जावास्क्रिप्ट, 75 73 बाइट्स

तारीख आदिम जोड़े के सरणियों के क्रमबद्ध सरणी के रूप में इनपुट लेता है, एक ऑब्जेक्ट को आउटपुट करता है जहां कुंजियाँ प्रत्येक तिथि की प्रधानता होती हैं और श्रेणियों में उन तिथियों के मानों को मानती हैं।

a=>a.map(g=([x,y])=>y<a[0][0]||g([x,y-864e5],o[y]=~~o[y]+(x<=y)),o={})&&o

कोशिश करो

मैं इस 60 बाइट संस्करण पर काम कर रहा था, जब तक यह पुष्टि नहीं हो गई थी कि किसी भी सीमा में दिखाई देने वाली तारीखों को शामिल नहीं किया जाना चाहिए ताकि जल्दबाजी में इसे उपरोक्त समाधान में अपडेट किया जा सके।

a=>a.map(g=([x,y])=>x>y||g([x+864e5,y],o[x]=-~o[x]),o={})&&o

इसे ऑनलाइन आज़माएं (या आउटपुट में मानव पठनीय तिथियों के साथ )

— झबरा
स्रोत

ऐसा लगता है कि ES6 JS ऑब्जेक्ट्स के लिए एक महत्वपूर्ण ऑर्डर परिभाषित करता है ( stackoverflow.com/a/31102605/8127 ), स्ट्रिंग और सिम्बल कीज़ के लिए बेसिकल इंसर्शन ऑर्डर (और TIO के Nodejs को लगता है कि निम्नलिखित का पालन करते हैं: smallll.com/ybjqtd89 )। और आम तौर पर मेरी राय यह है कि एक कार्यान्वयन विवरण (जो कि यहां की वस्तु है) चुनौती नियमों की व्याख्या को निर्धारित नहीं करना चाहिए, लेकिन मैं मेटा पोस्ट की प्रतीक्षा करूंगा।

— सूंदर - मोनिका

6

ऑक्टेव , 63 बाइट्स

@(x)histc(t=[cellfun(@(c)c(1):c(2),x,'un',0){:}],min(t):max(t))

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

अब वह कुरूप था!

स्पष्टीकरण:

datenumतत्वों के सेल सरणी के रूप में इनपुट लेता है (जैसे कि एक स्ट्रिंग "2001-01-01"एक संख्यात्मक मान में परिवर्तित होता है, इस तरह दिख रहा है:

{[d("2001-01-01") d("2001-01-01")]
[d("2001-01-01") d("2001-01-03")]
[d("2001-01-01") d("2001-01-02")]
[d("2001-01-03") d("2001-01-03")]
[d("2001-01-05") d("2001-01-05")]};

जहां d()समारोह है datenum। फिर हम cellfunउन पंक्तियों में से प्रत्येक के लिए पहली कॉलम से दूसरी तक की रेंज के साथ सेल बनाने के लिए उपयोग करते हैं। हम इन श्रेणियों को क्षैतिज रूप से बदलते हैं, ताकि हमारे पास सभी तिथियों के साथ एक लंबा क्षैतिज वेक्टर हो।

हम तब histcइन मूल्यों का उपयोग करते हुए एक हिस्टोग्राम बनाते हैं, जिसमें सबसे कम और उच्चतम तिथि के बीच सीमा द्वारा दिए गए डिब्बे होते हैं।

— स्टीवी ग्रिफिन
स्रोत

5

आर , 75 बाइट्स

function(x,u=min(x):max(x))rowSums(outer(u,x[,1],">=")&outer(u,x[,2],"<="))

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

इनपुट एक मैट्रिक्स है जिसका पहला कॉलम स्टार्ट है और दूसरा कॉलम एंड है। प्रारंभ मानें = समाप्त करें, लेकिन क्रमबद्ध किए जाने के लिए प्रारंभ दिनांक की आवश्यकता नहीं है।

— Jayce
स्रोत

यह जहाँ तक मैं स्टिव ग्रिफिन द्वारा ऑक्टेव उत्तर को दोहराने की कोशिश करने में सक्षम था ... क्या मैं गलत कर रहा हूँ?

— JayCe

यह इस तरह से है क्योंकि आर अपने डिब्बे में करता है hist; आप पहले c(-25668,min(x):max(x))से कर सकते हैं, लेकिन यह आपके सुझाए गए उत्तर से अधिक लंबा है। कहा जा रहा है, तारीखों को उत्पन्न करने का एक बेहतर तरीका है ; मेरे पास 68 बाइट्स में से एक है और मुझे इसे स्वयं पोस्ट करने का समय नहीं मिला है। -255681900apply

— ग्यूसेप

आह, नहीं, वास्तव में, उपयोग करें (min(x)-1):max(x)और इसे उम्मीद के मुताबिक काम करना चाहिए; तब यदि आप apply63 बाइट्स को प्राप्त करने की तारीखों को उत्पन्न करने का तरीका नहीं खोज सकते हैं और ऑक्टेव उत्तर को टाई कर सकते हैं।

— ग्यूसेप

@Giuseppe आपको इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए :)

— JayCe

प्रेषित :-) मुझे स्वीकार करना होगा, मैं उपयोग कर रहा था tableऔर factorइससे पहले Map68 बाइट्स के लिए मेरा मूल उपयोग था , लेकिन histएक साफ दृष्टिकोण है कि मैं हमेशा के बारे में भूल जाता हूं, शायद क्योंकि यह डिब्बे को सही पाने के लिए कष्टप्रद है (जैसा कि हमने देखा है) )

— ग्यूसेप

4

लाल , 174 बाइट्स

func[b][m: copy #()foreach[s e]b[c: s
until[m/(c): either none = v: m/(c)[1][v + 1]e < c: c + 1]]c: first sort b
until[print[either none = v: m/(c)[0][v]](last b)< c: c + 1]]

काफी लंबा और शाब्दिक कार्यान्वयन।

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

पठनीय:

f: func [ b ] [
    m: copy #()
    foreach [ s e ] b [
        c: s
        until [
            m/(c): either none = v: m/(c) [ 1 ] [ v + 1 ]   
            e < c: c + 1
        ]      
    ]
    c: first sort b
    until[
        print [ either none = v: m/(c) [ 0 ] [ v ] ]
        ( last b ) < c: c + 1
    ]      
]

— गैलेन इवानोव
स्रोत

4

ग्रूवी, 142 बाइट्स

{a={Date.parse('yyyy-mm-dd',it)};b=it.collect{a(it[0])..a(it[1])};b.collect{c->b.collect{it}.flatten().unique().collect{it in c?1:0}.sum()}}

प्रारूपित:

 {                                   // Begin Closure
    a={Date.parse('yyyy-mm-dd',it)}; // Create closure for parsing dates, store in a().
    b=it.collect{                    // For each input date pair...
        a(it[0])..a(it[1])           // Parse and create date-range.
    };
    b.collect{                       // For each date range...
        c->
        b.collect{                   // For each individual date for that range...
           it
        }.flatten().unique().collect{ // Collect unique dates.
            it in c?1:0
        }.sum()                      // Occurrence count.
    }
}

— जादू ऑक्टोपस Urn
स्रोत

4

अजगर 2 , 114 87 93 बाइट्स

-27 बाइट्स के लिए धन्यवाद जोनाथन एलन
+6 बाइट्स सूंदर का शुक्रिया

डेटाटाइम ऑब्जेक्ट्स के जोड़े की सूची के रूप में इनपुट लेता है।
मान लेता है कि पहली जोड़ी सबसे कम तारीख से शुरू होती है।

def F(I):
 d=I[0][0]
 while d<=max(sum(I,[])):print sum(a<=d<=b for a,b in I);d+=type(d-d)(1)

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

— मृत पोसुम
स्रोत

daysके लिए डिफ़ॉल्ट तर्क है timedelta।

— जोनाथन एलन

... वास्तव में मैं तुम्हें छोड़ सकते हैं लगता है from datetime import*और की जगह d+=timedelta(days=1)के साथ d+=type(d-d)(1)के बाद से आदानों पहले से ही कर रहे हैं dateहै। 87 बाइट्स

— जोनाथन एलन

1

ऐसा लगता है कि पहली श्रेणी की शुरुआत सबसे कम तिथि है और अंतिम सीमा का अंत उच्चतम है - लेकिन मुझे लगता है कि कभी-कभी यह संभव नहीं होता है, भले ही ओपी हमें छंटे हुए इनपुट को लेने की अनुमति देता हो। उदाहरण के लिए। यदि इनपुट है [(2001-01-01, 2001-01-05), (2001-01-02, 2001-01-03)]। जब तक ओपी हमें प्रीप्रोसेसिंग के दौरान इन श्रेणियों को विभाजित करने और पुनर्व्यवस्थित करने की अनुमति देता है (जो कि संभावना नहीं लगती है), इस इनपुट को इस कोड द्वारा ठीक से संसाधित नहीं किया जा सकता है।

— सूंदर -

@ सूंदर हां, मैं देख रहा हूं कि आप किस बारे में बात कर रहे हैं। मैंने इसे संभालने के लिए समाधान अपडेट किया है। धन्यवाद!

— मृत पोसुम

3

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 62 बाइट्स

Lookup[d=DayRange;Counts[Join@@d@@@#],#[[1,1]]~d~#[[-1,1]],0]&

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

+35 बाइट्स क्योंकि ओपी ने निर्दिष्ट किया है 0 आउटपुट में शामिल होना चाहिए।

यदि किसी शब्दकोश में प्रविष्टि को छोड़ने की अनुमति थी, तो 27 बाइट्स

Counts[Join@@DayRange@@@#]&

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

अंतर्निहित DayRangeदो DateObjectएस (या एक स्ट्रिंग समतुल्य) को स्वीकार करता है और Datesउन तिथियों (समावेशी) के बीच की सूची को आउटपुट करता है ।

— जंगहवान मिन
स्रोत

3

आर , 65 63 बाइट्स

function(x)hist(unlist(Map(`:`,x[,1],x[,2])),min(x-1):max(x))$c

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

यह जेसीई और खुद के बीच एक सहयोग है, स्टिव ग्रिफिन के उत्तर को आर के ऊपर पोर्ट करना।

JayCe को उद्धृत करने के लिए:

इनपुट एक मैट्रिक्स है जिसका पहला कॉलम स्टार्ट है और दूसरा कॉलम एंड है। प्रारंभ मानें = समाप्त करें, लेकिन क्रमबद्ध किए जाने के लिए प्रारंभ दिनांक की आवश्यकता नहीं है।

संभवतः, $cअनावश्यक है लेकिन यह चुनौती की भावना में काफी नहीं है इसलिए मैंने इसे शामिल किया है।

— ग्यूसेप
स्रोत

1

2 बाइट्स के लिए न्यूनतम (x-1)?

— JayCe

^ जिससे मेरा यह

— JayCe

@ जय, हाँ, अच्छा! मेरा इससे पहले आने का मतलब था लेकिन मैं भूल गया।

— ग्यूसेप

3

पॉवर्सशेल, 122 121 118 113 बाइट्स

filter d{0..($_[-1]-($s=$_[0])).Days|%{$s.AddDays($_)}}$c=@{};$args|d|%{++$c.$_};,($c.Keys.Date|sort)|d|%{+$c.$_}

इसे सहेजें count-timespan.ps1। टेस्ट स्क्रिप्ट:

.\count-timespan.ps1 `
    @([datetime]"2001-01-01", [datetime]"2001-01-01")`
    @([datetime]"2001-01-01", [datetime]"2001-01-03")`
    @([datetime]"2001-01-01", [datetime]"2001-01-02")`
    @([datetime]"2001-01-03", [datetime]"2001-01-03")`
    @([datetime]"2001-01-05", [datetime]"2001-01-05")

व्याख्या

filter d{                           # define a function with a pipe argument (it's expected that argument is an array of dates)
    0..($_[-1]-($s=$_[0])).Days|%{  # for each integer from 0 to the Days
                                    # where Days is a number of days between last and first elements of the range
                                    # (let $s stores a start of the range)
        $s.AddDays($_)              # output to the pipe a date = first date + number of the current iteration
    }                               # filter returns all dates for each range
}                                   # dates started from first element and ended to last element
$c=@{}                              # define hashtable @{key=date; value=count}
$args|d|%{++$c.$_}                  # count each date in a array of arrays of a date
,($c.Keys.Date|sort)|d|%{+$c.$_}    # call the filter via pipe with the array of sorted dates from hashtable keys

# Trace:
# call d @(2001-01-01, 2001-01-01) @(2001-01-01, 2001-01-03) @(2001-01-01, 2001-01-02) @(2001-01-03, 2001-01-03) @(2001-01-05, 2001-01-05)
# [pipe]=@(2001-01-01, 2001-01-01, 2001-01-02, 2001-01-03, 2001-01-01, 2001-01-02, 2001-01-03, 2001-01-05)
# $c=@{2001-01-03=2; 2001-01-01=3; 2001-01-05=1; 2001-01-02=2}
# call d @(2001-01-01, 2001-01-02, 2001-01-03, 2001-01-05)
# [pipe]=@(2001-01-01, 2001-01-02, 2001-01-03, 2001-01-04, 2001-01-05)
# [output]=@(3, 2, 2, 0, 1)

— Mazzy
स्रोत

धन्यवाद! $cnt.Keys.Dateबेशक।

— माज़ी

-3 बाइट्स: के functionसाथ प्रतिस्थापित scriptblock। गोल्फ और ungolfed कोड का परीक्षण किया जाता है।

— माज़ी

-5 बाइट्स: scriptblockपर प्रतिस्थापित filter। A का कॉल filterअधिक कॉम्पैक्ट है।

— माज़ी

3

जे, 43 बाइट्स

(],.[:+/@,"2="{~)&:((>./(]+i.@>:@-)<./)"1),

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

ungolfed

(] ,. [: +/@,"2 ="{~)&:((>./ (] + i.@>:@-) <./)"1) ,

व्याख्या

संरचना है:

(A)&:(B) C

C एक हुक बनाता है जो मुख्य क्रिया देता है A&:B को बाईं ओर इनपुट और इनपुट दाईं ओर चपटा होता है
B उर्फ ((>./ (] + i.@>:@-) <./)"1) एक सूची का न्यूनतम और अधिकतम ले जाता है और परिणामी सीमा देता है, और रैंक 1 के साथ काम करता है। इसलिए यह दाईं ओर कुल सीमा देता है, और बाईं ओर अलग-अलग रेंज।
तब किसी भी श्रेणी में प्रत्येक इनपुट कितने बार दिखाई देता है यह गिनने के लिए =रैंक "0 _(यानी, रैंक {) का उपयोग करता है। अंत में यह उन गणनाओं के साथ हर साल ज़िप करता है।

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

— जोनाह
स्रोत

2

जावास्क्रिप्ट (Node.js) , 80 बाइट्स

(a,u=[])=>a.map(g=([p,q])=>p>q||g([p,q-864e5],u[z=(q-a[0][0])/864e5]=-~u[z]))&&u

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

undefinedशून्य का मतलब; पहला तत्व जल्द से जल्द शुरू होना चाहिए

(a,u=[])=>a.map(g=([p,q])=>p>q||g([p,q-1],u[z=(q-a[0][0])/864e5]=-~u[z]))&&u कम है यदि आप केवल तत्वों को देखते हैं और अधिक स्टैक का उपयोग करते हैं

— l4m2
स्रोत

6

आपको पुष्टिकरण के लिए पूछना चाहिए कि किसी अन्य मान को प्रतिस्थापित 0करना स्वीकार्य है।

— झबरा

1

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

->s{f,=s.min;(p s.count{|a,b|(f-a)*(f-b)<=0};f+=86400)until f>s[0][1]}

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

इनपुट:

तारीखों के जोड़े की सरणी, नीचे उतरने की तारीख को छाँटकर।

— जीबी
स्रोत

1

आर (70)

function(x)(function(.)tabulate(.-min(.)+1))(unlist(Map(seq,x$S,x$E,"d")))

दिनांक (वर्ग ) के xसाथ दो कॉलम ( Startऔर Endया संभवतः Sऔर E) के साथ एक डेटा फ्रेम ग्रहण करता है Date।

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

— lebatsnok
स्रोत

नमस्ते, क्या आप एक उदाहरण इनपुट / आउटपुट के साथ TIO लिंक (अन्य उत्तर देखें) शामिल कर सकते हैं? यह एक पैकेज को शामिल करने के लिए धोखा नहीं दे रहा है, लेकिन library(magrittr)बाइट की गिनती में शामिल करने की आवश्यकता है।

— JayCe

साथ ही सर्वसम्मति के अनुसार प्रस्तुतियाँ पूर्ण कार्य या कार्यक्रम होनी चाहिए, स्निपेट नहीं, इसलिए यदि आप किसी ऐसे फ़ंक्शन के साथ जाते हैं जिसका एकमात्र तर्क xआपका उत्तर है function(x)और फिर फ़ंक्शन का मुख्य भाग।

— JayCe

1

जूलिया 0.6 , 77 बाइट्स

M->[println(sum(d∈M[r,1]:M[r,2]for r∈1:size(M,1)))for d∈M[1]:max(M...)]

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

@ DeadPossum के पाइथन समाधान से प्रेरित ।

एक मैट्रिक्स के रूप में इनपुट लेता है, जहां प्रत्येक पंक्ति में दो तिथियां होती हैं: इनपुट रेंज की शुरुआती और समाप्ति तिथियां। मान लें कि इनपुट में सबसे पहले की तारीख है, और प्रत्येक पंक्ति में शुरुआती तारीख पहले है, लेकिन अलग-अलग पंक्तियों के बीच कोई छंटनी नहीं करता है।

पुराना समाधान:

जूलिया 0.6 , 124 बाइट्स

R->(t=Dict();[[d∈keys(t)?t[d]+=1:t[d]=1 for d∈g]for g∈R];[d∈keys(t)?t[d]:0 for d∈min(keys(t)...):max(keys(t)...)])

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

इनपुट को एक तिथि सीमा के रूप में स्वीकार करता है। सरणी में विभिन्न श्रेणियों के बीच किसी भी तरह की छंटाई नहीं करता है।

— sundar - मोनिका को बहाल करना
स्रोत

कालगणना गिनें

आई / ओ

जीत का मानदंड

छद्म एल्गोरिथ्म का उदाहरण

एपीएल (Dyalog यूनिकोड) , 32 बाइट्स SBCS

जावास्क्रिप्ट (ईएस 6), 85 बाइट्स

जावास्क्रिप्ट, 75 73 बाइट्स

ऑक्टेव , 63 बाइट्स

स्पष्टीकरण:

आर , 75 बाइट्स

लाल , 174 बाइट्स

पठनीय:

ग्रूवी, 142 बाइट्स

अजगर 2 , 114 87 93 बाइट्स

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 62 बाइट्स

यदि किसी शब्दकोश में प्रविष्टि को छोड़ने की अनुमति थी, तो 27 बाइट्स

आर , 65 63 बाइट्स

पॉवर्सशेल, 122 121 118 113 बाइट्स

व्याख्या

जे, 43 बाइट्स

ungolfed

व्याख्या

जावास्क्रिप्ट (Node.js) , 80 बाइट्स

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

इनपुट:

आर (70)

जूलिया 0.6 , 77 बाइट्स

जूलिया 0.6 , 124 बाइट्स

एपीएल (Dyalog यूनिकोड) , 32 बाइट्स ^SBCS