_Friday 13th or Black Friday is considered as unlucky day. Calculate how many unlucky days are in the given year._

Find the number of Friday 13th in the given year.

__Input:__ Year as an integer.

__Output:__ Number of Black Fridays in the year as an integer.

__Examples:__

        unluckyDays(2015) == 3
        unluckyDays(1986) == 1

***Note:*** In Ruby years will start from 1593.

Difficulty: introductory

Starter code:

def unlucky_days(year):
	

Solutions:
from datetime import date

def unlucky_days(year):
    return sum(date(year, m, 13).weekday() == 4 for m in range(1, 13))

from calendar import weekday

def unlucky_days(year):
    return sum(1 for i in range(1, 13) if weekday(year, i, 13) == 4)


from datetime import datetime

def unlucky_days(year):
   return sum(datetime(year, month, 13).weekday() == 4 for month in range(1,13))

from datetime import date
def unlucky_days(year):    
    counter = 0 
    for months in range(1,13):
        if date(year, months, 13).weekday()==4:
            counter +=1            
    return counter



from datetime import date

def unlucky_days(year):
    return sum( 1 for month in range(1,13) if date(year,month,13).weekday()==4 )

import datetime as d
import calendar
def unlucky_days(year):
    l = []
    for i in range(1,13):
        l.append(calendar.monthrange(year,i)[1])
    count = 0
    for i in range(0,12):
        if l[i]>=28 and d.date(year,i+1,13).weekday() == 4:
            count+=1
    return count


import datetime

def unlucky_days(year):
    friday13 = 0
    months = range(1,13)
    for month in months:
      if datetime.date(year,month, 13).weekday() == 4:
        friday13 += 1
    return friday13

unlucky_days = lambda y: sum(__import__("datetime").date(y, m, 13).weekday() == 4 for m in range(1, 13))

def unlucky_days(y):    
    count = 0 # Clean & Pure Math Example      
    for m in range(3,15):
        if m == 13: y-=1            
        if (y%100+(y%100//4)+(y//100)//4-2*(y//100)+26*(m+1)//10+12)%7==5:
            count += 1
    return count

import calendar 
def unlucky_days(year):
    return [calendar.weekday(year, m, 13) for m in range(1,13)].count(4)

from datetime import date

unlucky_days = lambda year: sum(date(year, month, 13).weekday() == 4 for month in range(1, 13))

def unlucky_days(year):
    x=0
    import datetime
    for i in range(1, 13):
        if datetime.date(year, i, 13).weekday()==4:
            x=x+1
    return x

def unlucky_days(year):
    import calendar
    fridays = 0
    for i in range(1,13):
        if calendar.weekday(year,i,13) == 4:
            fridays += 1
    return fridays

def unlucky_days(year):
    import datetime
    
    # setting variables
    i, count = 1, 0
    
    # loop for each month
    while i <= 12:

        # checks if there is an unlucky day in the month
        if (datetime.datetime(year, i, 13).strftime('%w') ==  '5'): count += 1
        
        i += 1
        
    return count    

from datetime import date
def unlucky_days(year):
    black_fridays = 0
    for month in range(1,13):
        if date(year,month,13).isoweekday() == 5:
            black_fridays+=1
    return black_fridays

def unlucky_days(year):
    from datetime import date
    black_Fri = 0
    for i in range(1,13):
        if date(year, i, 13).weekday() == 4:
            black_Fri += 1
    return black_Fri

from datetime import date

def unlucky_days(year):
    count = 0
    for i in range(1, 13):
        if date(year, i, 13).weekday() == 4:
            count += 1
    return count


import calendar


def unlucky_days(year):
    answer = 0

    for month in range(1, 13):
        for day in calendar.Calendar().itermonthdays2(year, month):
            if day[0] == 13 and day[1] == 4:
                answer += 1

    return answer


import datetime
def unlucky_days(y):                                 #(year,month,day)
    return len([i for i in range(12) if datetime.date(y,i+1,13).weekday() == 4])
                  #for month the range of 12 months,
                                            #if the weekday == friday 13th in y year, i+1 month,
               #return the number of months that have friday the 13th in them as a list.
            #find the length of it.


import datetime
def unlucky_days(y):
    return len([i for i in range(12) if datetime.date(y,i+1,13).weekday() == 4])

from datetime import datetime

def unlucky_days(year):
    return sum(True for month in range(1, 13) if datetime(year=year, month=month, day=13).weekday() == 4)

from datetime import datetime


def unlucky_days(year):
    return sum(datetime(year, a, 13).weekday() == 4 for a in range(1, 13))


def unlucky_days(year):
    c=year//100
    y=year-100*c
    c1=(year-1)//100
    y1=year-1-100*c1
    return (1 if (y1+y1//4+c1//4-2*c1+26*(13+1)//10+12)%7==5 else 0)+(1 if (y1+y1//4+c1//4-2*c1+26*(14+1)//10+12)%7==5 else 0)+sum(1 for m in range(3,13) if (y+y//4+c//4-2*c+26*(m+1)//10+12)%7==5)

import calendar

def unlucky_days(year):
    f13=0
    for i in range(1,13):
        c=calendar.monthcalendar(year,i)
        for f in [c[0],c[1],c[2],c[3]]:
            if f[calendar.FRIDAY]==13:
                f13+=1
    return f13


import time
def unlucky_days(y):
    return sum([time.strptime('%s-%d-13' % (y,x+1),'%Y-%m-%d').tm_wday == 4 for x in range(12)])

import datetime


def unlucky_days(year):
    return sum(map(lambda x: datetime.datetime(year, x, 13).weekday() == 4, range(1, 13)))

import calendar
c=calendar.Calendar()

def unlucky_days(year):
    cont=0
    for mes in range(1,13):
        for i in c.monthdayscalendar(year,mes):
            if i[4]==13:
                cont=cont+1
    return cont        

from datetime import datetime 
def unlucky_days(year):
    return sum(1 for x in range(1, 13) if datetime(year, x, 13).strftime('%a') == 'Fri')

import datetime
def unlucky_days(n):

   t=0
   initial_date = datetime.date(n,1,1)
   for e in range(1,365):   # прибавлять по дню и счетчик если
      my_date = initial_date + datetime.timedelta(days=e)
      if my_date.isoweekday() == 5 and my_date.day == 13:
         t+=1
   return t

from calendar import weekday

def unlucky_days(year):
    
    c = 0
    
    for m in range(1,13):
    
        u = weekday(year,m,13)
        
        if u==4:
            
            c+= 1
    
    return c



import datetime as dt

def unlucky_days(y):
    return sum(dt.datetime(y, i+1, 13).weekday() == 4 for i in range(12))



from datetime import date, timedelta

def unlucky_days(year):
    d = date(year, 1, 1)
    d += timedelta(days=4 - d.weekday())
    counter = 0
    
    while d.year != year + 1:
        if d.weekday() == 4 and d.day == 13:
            counter += 1
        d += timedelta(days=7)
    
    return counter

import datetime
def unlucky_days(year):
    sum = 0
    for month in range(1,13):
        date = datetime.datetime(year,month,13).strftime("%w")
        if date == '5':
            sum += 1
    return sum

import datetime
def unlucky_days(year):
    sum = 0
    for month in range(1,13):
        date = datetime.datetime(year,month,13).strftime("%w")
        if date == '5':
            sum += 1
    return sum
print(unlucky_days(2015))

from datetime import datetime

def unlucky_days(year):
    return sum(map(lambda i: datetime(year, i, 13).weekday() == 4, [i for i in range(1, 13)]))

import datetime
def unlucky_days(year):
    howmany=0
    for i in range(1,13):
        day=datetime.datetime(year,i,13)
        if day.weekday()==4:
            howmany+=1 
    return howmany

from datetime import date, timedelta


def unlucky_days(year):
    count = 0
    start_day = date(year, 1, 1)
    end_day = date(year, 12, 31)

    while start_day <= end_day:
        if (start_day.weekday() == 4) and (start_day.day == 13):
          #  print(start_day)
            count += 1
        else:
            pass
        start_day += timedelta(days=1)

    return count

import datetime
def unlucky_days(year):
    return sum(1 for month in range(1,13) if datetime.date(year, month, 13).isoweekday() == 5)


import datetime
def unlucky_days(year):
    cnt = 0
    for i in range(1, 13):
        d = datetime.datetime(year, i, 13)
        if d.weekday() == 4:
            cnt += 1
    return cnt

import datetime

def unlucky_days(year):
    sm=0
    for i in range(1,13):
        dt=datetime.datetime(year,i,13)
        if dt.strftime("%A")=="Friday":
            sm+=1
            
    return sm

from datetime import date, timedelta    

def calc(y):

    st  = date(y, 1, 1)
    fin = date(y, 12, 31)
    numday = timedelta(days=1)
    while st < fin:
        if st.weekday() == 4 and st.day == 13:
             yield st
        st = st + numday
        
    
def unlucky_days(year):
    count = 0
    res = [str(i) for y in range(year - 1,year + 1) for i in calc(y)]
    for x in range(len(res)):
        if str(year) in res[x]:
            count = count + 1
    return count


import datetime

def unlucky_days(year):
    i = 0
    for item in range(1, 13):
        day = datetime.date(year, item, 13).isoweekday()
        if day == 5:
            i += 1
    return i

unlucky_days = lambda y: len([m for m in range(1, 13) if __import__('datetime').date(y, m, 13).weekday() == 4])

import calendar

def unlucky_days(year):
    res_date = calendar.Calendar()
    res_days = 0
    for month in range(1, 13):
        for day in res_date.itermonthdays2(year, month):
            if day[0] == 13 and day[1] == 4:
                res_days += 1
    return res_days


import calendar
import datetime


def unlucky_days(year):
    start_date = datetime.date(year, 1, 1)
    end_date = datetime.date(year, 12, 31)
    delta = datetime.timedelta(days=1)
    counter = 0
    while start_date <= end_date:
        year = int(str(start_date)[:4])
        month = int(str(start_date)[5:7])
        day = int(str(start_date)[8:10])
        if day == 13 and calendar.weekday(year, month, day) == 4:
            counter += 1
        start_date += delta
    
    return counter


import datetime
def unlucky_days(year):
    return sum([1 for m in range(1,13) if datetime.date(year,m,13).weekday()==4])

import datetime

def unlucky_days(n):

        c=0
       
        d=datetime.timedelta(days=1)
        t = datetime.date(n, 1, 1)
        while t !=  datetime.date(n,12,31):

           
            if  t.day==13 and t.strftime("%A")=='Friday':
                c=c+1
            t=t+d

        return c


import datetime
def unlucky_days(y):
    return sum(datetime.date(y,i,13).weekday() == 4 for i in range(1,13))

def unlucky_days(year):
    
    from datetime import datetime as dt
    
    count = 0
    
    for i in range(1,13):
        if dt(year, i, 13).weekday() == 4:
            count += 1
    
    return count

import datetime

def unlucky_days(year):
    counter = 0
    for i in range(1, 13):
        d = datetime.date(year, i, 13)
        if d.weekday() == 4:
            counter += 1
    return counter

import datetime

def unlucky_days(year):
    dates_13 = [datetime.datetime.strptime (f'{year}-{i}-13', '%Y-%m-%d').date () for i in range (1, 13)]

    res = [mon for mon in dates_13 if mon.isoweekday() == 5]

    return len(res)

import datetime
def unlucky_days(year):
    ans = 0
    for i in range(1, 13):
        day = datetime.date(year, i, 13)
        ans += (day.weekday() == 4)
    
    return(ans)

from datetime import date

def unlucky_days(year):
    return sum(date(year, month, 13).isoweekday() == 5 for month in range(1, 13))


def __starting_point():
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert unlucky_days(2015) == 3, "First - 2015"
    assert unlucky_days(1986) == 1, "Second - 1986"
__starting_point()

import datetime
def unlucky_days(year):
    count = 0
    for i in range(1, 13):
        a = datetime.datetime(year, i, 13)
        if a.strftime("%A") == 'Friday':
            count += 1
    return count

def unlucky_days(year):
    from datetime import datetime
    
    fridays = 0
    
    for i in range(1, 13):
        if datetime(year, i, 13).weekday() == 4:
            fridays += 1
    
    return fridays

import calendar


def unlucky_days(year):
    c = calendar.Calendar()
    counter = 0
    for month in range(1,13):
        print(f"Months is {month}")
        for day in c.itermonthdays2(year, month):
            print(f"Day is {day}")
            if day[0] == 13 and day[1] == 4:
                print(f"This is Friday 13th {day}")
                counter += 1
    return counter

def unlucky_days(year):
    from datetime import datetime as dt
    from datetime import timedelta
    
    cnt = 0
    x = dt(year,1,1)
    while x.year == year:
        x = x + timedelta(days = 1)
        if x.day == 13 and x.weekday() == 4:
            cnt = cnt + 1
    return cnt

from calendar import Calendar
def unlucky_days(year):
    x = Calendar()
    lst = []
    for month in range(1, 13):
        for days in x.itermonthdays2(year, month):
            if days[0] == 13 and days[1] == 4:
                lst.append(days)
    return len(lst)

import calendar


def unlucky_days(year):
    return sum([calendar.weekday(year, month, 13) == 4 for month in range(1,13)])

from datetime import date

def unlucky_days(year,count=0):
    d1 = date.toordinal(date(year,1,1))
    d2 = date.toordinal(date(year,12,31))
    for i in range(d1, d2+1):
        if date.weekday(date.fromordinal(i)) == 4 and date.fromordinal(i).day == 13:
            count += 1
    return count

from datetime import date

def unlucky_days(year,count=0):
    d1 = date.toordinal(date(year,1,1))
    d2 = date.toordinal(date(year,12,31))
    for i in range(d1, d2+1):
        #print(date.weekday(date.fromordinal(i)), date.fromordinal(i).day)
        if date.weekday(date.fromordinal(i)) == 4 and date.fromordinal(i).day == 13:
            count += 1
    return count

from datetime import date
def unlucky_days(year):
    NumDays=0
    for i in range(1,12+1):
        if date(year,i,13).weekday()==4:
            NumDays+=1
    return NumDays


from datetime import datetime
from functools import reduce

def unlucky_days(year):
    return reduce(lambda r, month: r + int(datetime.strptime(f'{year}-{month:02}-13', '%Y-%m-%d').weekday() == 4), range(1,13), 0)

import pandas as pd
from datetime import datetime, timedelta

def unlucky_days(year):
    unlucky = 0
    start_date = datetime(year, 1, 1)
    end_date = datetime(year+1, 1, 1)
    delta = end_date - start_date
    for i in range(delta.days + 1):
        day = start_date + timedelta(days=i)
        if ((day.strftime('%A') == "Friday") and (day.strftime('%d') == "13")):
            unlucky += 1
    return unlucky
    


import calendar

def unlucky_days(year):
    return [calendar.weekday(year, x+1, 13) for x in range(12)].count(4)

from datetime import date
def unlucky_days(year):
    thirteenths=[]
    for m in range(1,13):
        if date(year,m,13).weekday()==4:
            thirteenths.append(m)
        else:
            continue
    return len(thirteenths)

def unlucky_days(year):
    from datetime import date
    unluckyday = 0
    for month in range(1,13):
        if date(year,month,13).weekday() == 4:
            unluckyday +=1
    return unluckyday

import datetime
def unlucky_days(year):
    friday_13 = 0
    months = range(1, 13)
    for i in months:
        if datetime.date(year, i, 13).weekday() == 4:
            friday_13 += 1
    return friday_13

import datetime

def unlucky_days(year):
    return sum(datetime.datetime(year, m + 1, 13).weekday() == 4 for m in range(12))


import calendar

def unlucky_days(year):
    n = 0
    for i in range (1,13):
        if calendar.weekday(year, i, 13) == 4:
            n += 1
    return n

import datetime
def unlucky_days(year):
    unlucky = 0
    for month in range(1,13):
        if datetime.datetime(year,month, 13).weekday() == 4:
            unlucky += 1
    return unlucky

import datetime


def unlucky_days(year):

    counter = 0
    for i in range(1,13):
        thirteenth = datetime.date(year, i, 13)
        if thirteenth.weekday() == 4:
            counter += 1

    return counter

import datetime


def unlucky_days(year):
    black_fridays = 0
    for i in range(1, 13):
        d = datetime.date(year, i, 13)
        if (d.weekday() == 4):
            black_fridays += 1

    return black_fridays

from calendar import weekday
def unlucky_days(year):
    return sum(weekday(year,i,13) == 4 for i in range(1, 13))

from functools import reduce
import datetime

def unlucky_days(year):
    return  reduce(
        lambda a, b: a + (1 if datetime.datetime(year, b + 1, 13).weekday() == 4 else 0)
        , range(12), 0)

import calendar

cal = calendar.Calendar()

def unlucky_days(input):
    count = 0
    for month in range(1, 13):
        results = cal.monthdays2calendar(input, month)
        for result in results:
            if (13, 4) in result:
                count += 1
    return count


import datetime

def unlucky_days(year):
    total = 0
    for x in range(1,13):
        if datetime.date(year,x,13).isoweekday() == 5:
            total += 1
    return total

from datetime import datetime as dt
def unlucky_days(year):
    return sum(int(dt(year,x,13).weekday()==4) for x in range(1,13))

from datetime import date
def unlucky_days(year):
    contador = 0
    for i in range(1,13):
        dato = date(year,i,13)
        if dato.weekday() == 4:
            contador+=1

    return contador

import datetime
def unlucky_days(year):
    total = 0
    month = 1
    while month < 13:
        test = datetime.datetime(year, month, 13)
        if datetime.datetime.weekday(test) == 4:
            total += 1
            month += 1
        else:
            month +=1
            continue
    return total


import datetime

def unlucky_days(year):
    date_=datetime.date(year,1,1)
    
    while date_.weekday() != 4: 
        date_+=datetime.timedelta(days=1)
    
    bad_days=0
    
    while date_.year==year:
        if date_.day==13:
            bad_days+=1
        date_+=datetime.timedelta(days=7)
    return bad_days

from datetime import datetime


def unlucky_days(year):
    """returns the numbers of Fridays 13th found in a given year.
       
       example:
       >> print('%s unlucky days found in year 2020.' % unlucky_days(2020))
    """
    spooky_days = 0
    if (isinstance(year, int) and (0 < year < 10000)):
        months = ('01', '02', '03', '04', '05', '06', 
                  '07','08', '09', '10', '11', '12')
        for m in months:
            date_to_check = str(year) + '-' + m + '-13'
            day = datetime.strptime(date_to_check, '%Y-%m-%d').weekday()
            if day == 4:
                spooky_days += 1
    return spooky_days

from datetime import date
def unlucky_days(year):    
    return sum(date(year,months,13).weekday()==4 for months in range(1,13))



from datetime import datetime
def unlucky_days(year: int) -> sum:
    return sum(datetime(year, month, 13).weekday() == 4 for month in range(1, 13))

from calendar import Calendar, MONDAY, FRIDAY

def unlucky_days(year):
    c = Calendar(firstweekday=MONDAY)
    return sum(1 for x in [[1 for d, wd in c.itermonthdays2(year, m) if wd == FRIDAY and d == 13] for m in range(1,13)] if x)


from datetime import datetime
def unlucky_days(year):
    return sum(map(lambda x: datetime(year, x, 13).weekday() == 4, range(1,13)))

from datetime import date

def unlucky_days(year):
    # Only need to check the 13th of each month
    day = 13
    
    # Counter for unlucky days
    unlucky_days_count = 0
    
    # Loop through the months (1 to 12)
    for x in range(1, 13):
        # Create date object for each month
        date_obj = date(year=year, month=x, day=day)
        
        # Check if the 13th of current month is Friday
        # Weekdays range from 0 (Monday) to 6 (Sunday)
        if date_obj.weekday() == 4:
            # Increment unlucky days counter if current 13th is Friday
            unlucky_days_count += 1
    
    # Return the unlucky days counter
    return unlucky_days_count

from datetime import date, timedelta
def unlucky_days(year):
    start_date = date(year,1,1)
    end_date = date(year,12,31)
    delta_days = (end_date - start_date).days
    count = 0
    
    for n in range(delta_days):
        if(start_date.strftime("%a %d") == "Fri 13"):
            count=count+1
        start_date=start_date+(timedelta(days=1))
    return count

import calendar

def unlucky_days(year):
    c = calendar.Calendar()
    return sum(sum(sum(list(c.yeardays2calendar(year,width=12)), []), []), []).count((13,4))

import datetime

def unlucky_days(year):
    number = 0
    for month in range(1, 13):
        d = datetime.date(year, month, 13)
        if (d.strftime("%A") == "Friday"):
            number += 1
    return number

import datetime

def unlucky_days(year):
    
    count = 0 
    
    for month in range(12):
        if datetime.date(year,month+1,13).weekday() == 4:
            count += 1
            
    return count


from calendar import weekday as wd
def unlucky_days(year):
    day=13;k=0
    for month in range(1,13):
        if wd(year,month,day)==4:
            k+=1
    return k

from datetime import timedelta, date

def unlucky_days(year):
    day_td = timedelta(days=1)
    date_i = date(year,1,1)
    
    unlucky_counter = 0
    
    for i in range(366):
        date_i = date_i + day_td
        if date_i.day == 13 and date_i.weekday() == 4:
            unlucky_counter += 1
    return unlucky_counter

from datetime import datetime

def unlucky_days(year):
    bfriday = 0
    for i in range(1, 13):
        if datetime(year, i, 13).strftime("%a") == "Fri":
            bfriday+=1
    return bfriday

from datetime import datetime

FRIDAY = 4

def unlucky_days(year):
    bad_days_counter = 0
    for month in range(1, 13):
        if datetime(year, month, 13).weekday() == FRIDAY:
            bad_days_counter += 1
            
    return bad_days_counter


import datetime
def unlucky_days(year):
    total=0
    for i in range(12):
        date=datetime.datetime(year,i+1,13)
        if date.weekday()==4:total+=1    
    return total



def unlucky_days(year):
    import datetime
    weekdays_13 = [ datetime.date(year,mm,13).weekday() for mm in range(1,13) ]
    return weekdays_13.count(4)

import calendar
def unlucky_days(year):
    c=0
    cal=calendar.Calendar()
    for i in range(1,13):
        for d,w in cal.itermonthdays2(year,i):
            if d==13 and w==4:
                c=c+1
    return c

from datetime import datetime

def unlucky_days(year):
  days = 0
  date_string = "13/{}/{}"
  for i in range(1,13):
      date_obj = datetime.strptime(date_string.format(str(i).zfill(2),str(year)),'%d/%m/%Y').weekday()
      if date_obj==4:
        days+=1
  return days