แรงบันดาลใจจากสถานการณ์ในชีวิตจริงซึ่งฉันได้ขอคำตอบจากที่นี่: /superuser/1312212/writing-a-formula-to-count-how-many-times-each-date- ปรากฏใน-a-ชุดจากวันที่วิ่ง

กำหนดอาร์เรย์ของ timespans (หรือคู่ startdate-enddate) ให้นับจำนวนครั้งที่ครอบคลุมกี่ครั้งต่อวันสำหรับทุกวันในช่วงทั้งหมด

ตัวอย่างเช่น:

  #      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)

คุณจะต้องส่งออกการนับสำหรับแต่ละวัน (ตามลำดับเรียงลำดับที่เก่าแก่ที่สุด); ไม่ใช่ระเบียนที่จะปรากฏ

คุณสามารถสมมติได้ว่าแต่ละช่วงเวลามีเฉพาะวันที่เท่านั้นไม่ใช่เวลา ดังนั้นทั้งวันจะถูกนำเสนอเสมอ

I / O

อินพุตสามารถเป็นรูปแบบใด ๆ ที่แสดงถึงชุดของช่วงเวลา - ดังนั้นชุดของเวลาหรือชุดของวัตถุ (บิวด์อิน) ที่มีวันที่เริ่มต้นและวันที่สิ้นสุด เวลาวันที่จะถูก จำกัด อยู่ระหว่างปีพ. ศ. 2444-2542 ตามปกติสำหรับความท้าทาย PPCG

คุณสามารถสมมติว่าอินพุตถูกเรียงลำดับล่วงหน้าตามที่คุณต้องการ (ระบุในคำตอบของคุณ) รวมวันที่ที่ป้อนเข้า (ดังนั้นช่วงจึงรวมวันที่เริ่มต้นและวันที่สิ้นสุดทั้งหมด)

นอกจากนี้คุณยังสามารถสันนิษฐานได้ว่าในสองวันที่ในช่วงที่กำหนดช่วงแรกจะเก่ากว่าหรือเท่ากับวินาที (เช่นคุณจะไม่มีช่วงวันที่ติดลบ)

เอาท์พุทเป็นอาร์เรย์ที่มีการนับในแต่ละวันจากที่เก่าที่สุดไปจนถึงใหม่ล่าสุดในการป้อนข้อมูลเมื่อเรียงตามวันที่เริ่มต้น

ดังนั้นผลลัพธ์สำหรับตัวอย่างข้างต้นจะเป็น {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

อัลกอริทึมอื่น ๆ เพื่อให้ได้ผลลัพธ์เดียวกันนั้นใช้ได้

APL (Dyalog Unicode) , 32 ไบต์^SBCS

โปรแกรมเต็มรูปแบบ แสดง stdin สำหรับรายการคู่ของตัวเลขวันที่ระหว่างประเทศ (เช่นที่ Excel และ MATLAB ใช้) ทั้งรายการและคู่อาจได้รับในลำดับใด ๆ เช่น (จบ, เริ่ม) พิมพ์รายการการนับเป็น stdout

¯1+⊢∘≢⌸(R,⊢)∊(R←⌊/,⌊/+∘⍳⌈/-⌊/)¨⎕ ลองออนไลน์!

หากสิ่งนี้ไม่ถูกต้องสามารถแปลงรายการของคู่ (YMD) เป็น 21 ไบต์เพิ่มเติมรวม 53:

¯1+⊢∘≢⌸(R,⊢)∊(R⌊/,⌊/+∘⍳⌈/-⌊/)¨{2⎕NQ#'DateToIDN'⍵}¨¨⎕ ลองออนไลน์!

⎕ พร้อมต์คอนโซลสำหรับอินพุตที่ประเมิน

(... )¨ ใช้ฟังก์ชั่นโดยปริยายต่อไปนี้กับแต่ละคู่

⌊/ ขั้นต่ำ (ลดความสว่างขั้นต่ำ) คือวันที่เริ่มต้น

⌈/- สูงสุด (เช่นวันที่สิ้นสุด) ลบด้วย

⌊/+∘⍳ วันที่เริ่มต้นบวกช่วงที่ 1 ถึงถึงนั้น

⌊/, วันที่เริ่มต้นซึ่งรวมอยู่ในนั้น

R← กำหนดฟังก์ชั่นนี้ให้กับR(สำหรับR ange)

∊ ε nlist (เรียบ) รายการช่วงเป็นรายการเดียว

(... ) ใช้ฟังก์ชัน tacit ต่อไปนี้กับสิ่งนั้น:

 R,⊢ ผลลัพธ์ของการใช้R(เช่นช่วงวันที่) ตามด้วยอาร์กิวเมนต์
  ^{(เพื่อให้แน่ใจว่าแต่ละวันในช่วงจะแสดงอย่างน้อยหนึ่งครั้งและวันที่ปรากฏตามลำดับที่เรียง)}

… ⌸ สำหรับแต่ละคู่ที่ไม่ซ้ำกัน (วันที่, ดัชนีการเกิดขึ้นในอินพุท), ทำ:

 ⊢∘≢ ละเว้นวันที่เกิดขึ้นจริงเพื่อสนับสนุนการนับดัชนี

¯1+ เพิ่ม -1 ให้กับการนับเหล่านั้น (เนื่องจากเราได้เตรียมหนึ่งวันในแต่ละช่วงในช่วง

JavaScript (ES6), 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 ไบต์หากเราสามารถใช้ JS timestamps เป็นอินพุต (ตามที่แนะนำโดย @Shaggy)

JavaScript, 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

ลองออนไลน์ (หรือด้วยวันที่มนุษย์อ่านได้ในผลลัพธ์ )

อ็อกเทฟ 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ค่าเหล่านี้โดยมีช่องเก็บของตามช่วงระหว่างวันที่ต่ำสุดและสูงสุด

R , 75 ไบต์

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

ลองออนไลน์!

อินพุตเป็นเมทริกซ์ที่มีคอลัมน์แรกคือเริ่มและคอลัมน์ที่สองคือสิ้นสุด ถือว่า Start <= End แต่ไม่ต้องการเรียงลำดับวันที่เริ่มต้น

สีแดง 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
    ]      
]

Groovy ขนาด 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.
    }
}

Python 2 , 114 87 93 ไบต์

-27 ไบต์ขอบคุณ Jonathan Allan
+6 ไบต์ขอบคุณ sundar

รับอินพุตเป็นรายการคู่ของออบเจ็กต์ datetime
สมมติว่าคู่แรกเริ่มต้นด้วยวันที่ต่ำที่สุด

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)

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 62 ไบต์

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

ลองออนไลน์!

+35 ไบต์เนื่องจาก OP ระบุว่า 0ต้องรวมอยู่ในผลลัพธ์

หากไม่อนุญาตให้ป้อนรายการในพจนานุกรมจะมีขนาด 27 ไบต์

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

ลองออนไลน์!

ในตัวDayRangeยอมรับสองDateObjects (หรือเทียบเท่าสตริง) และส่งออกรายการDatesระหว่างวันที่เหล่านั้น (รวม)

R , 65 63 ไบต์

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

ลองออนไลน์!

นี่คือความร่วมมือระหว่างJayCeกับตัวฉันเองซึ่งเป็นคำตอบของ Stewie Griffinให้กับ R

ในการอ้างถึง JayCe:

อินพุตเป็นเมทริกซ์ที่มีคอลัมน์แรกคือเริ่มและคอลัมน์ที่สองคือสิ้นสุด ถือว่า Start <= End แต่ไม่ต้องการเรียงลำดับวันที่เริ่มต้น

อาจ$cจะไม่จำเป็น แต่ก็ไม่ได้อยู่ในจิตวิญญาณของความท้าทายดังนั้นฉันจึงรวมมันเข้าด้วยกัน

Powershell, 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)

J, 43 ไบต์

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

อินพุตเป็นรายการของคู่ของจำนวนเต็มโดยที่จำนวนเต็มแต่ละค่าจะถูกชดเชยจากค่า 0 ทั่วไปใด ๆ

ungolfed

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

คำอธิบาย

โครงสร้างคือ:

(A)&:(B) C

• C สร้างเบ็ดที่ให้คำกริยาหลัก A&:Bอินพุตด้านซ้ายและอินพุตแบนด้านขวา
• B aka ((>./ (] + i.@>:@-) <./)"1)ใช้เวลาขั้นต่ำและสูงสุดของรายการและส่งกลับช่วงผลลัพธ์และดำเนินการกับอันดับ 1 ดังนั้นจึงให้ช่วงทั้งหมดทางด้านขวาและแต่ละช่วงทางด้านซ้าย
• จากนั้นใช้=กับอันดับ"0 _(เช่นอันดับของ{) เพื่อนับจำนวนครั้งที่แต่ละอินพุตปรากฏในช่วงใดช่วงหนึ่ง ในที่สุดมันก็รูดรหัสทุก ๆ ปีด้วยจำนวนเหล่านั้น

ลองออนไลน์!

JavaScript (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 จะสั้นลงถ้าคุณเห็นองค์ประกอบและใช้สแต็กมากขึ้นเท่านั้น

Ruby , 70 ไบต์

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

ลองออนไลน์!

การป้อนข้อมูล:

อาร์เรย์ของคู่ของวันที่เรียงตามวันที่สิ้นสุดจากมากไปน้อย

R (70)

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

สมมติกรอบข้อมูลที่xมีสองคอลัมน์ ( StartและEndหรืออาจเป็นSและE ) กับวันที่ (คลาสDate)

ลองออนไลน์

Julia 0.6 , 77 bytes

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

ลองออนไลน์!

แรงบันดาลใจจาก @ DeadPossum ของการแก้ปัญหาหลาม

รับอินพุตเป็นเมทริกซ์โดยที่แต่ละแถวมีสองวันที่: วันที่เริ่มต้นและสิ้นสุดของช่วงข้อมูลเข้า สมมติว่าอินพุตมีวันที่ที่เร็วที่สุดก่อนและแต่ละแถวมีวันที่เริ่มต้นก่อน

วิธีแก้ปัญหาที่เก่ากว่า:

Julia 0.6 , 124 bytes

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)...)])

ลองออนไลน์!

ยอมรับอินพุตเป็นอาร์เรย์ของช่วงวันที่ ไม่ถือว่าการเรียงลำดับใด ๆ ในช่วงที่แตกต่างกันในอาร์เรย์