



'''simple docstring'''

from collections import defaultdict



class 		lowerCamelCase__      :




					'''simple docstring'''



					def __init__(  self				:	Dict     ,  UpperCamelCase_				:	Optional[Any]     ,  UpperCamelCase_				:	List[str]					)  ->       int:



						'''simple docstring'''





						_lowercase					:       List[str]       =		total  # total no of tasks (N)

						# DP table will have a dimension of (2^M)*N
						# initially all values are set to -1
						_lowercase					:       int       =		[
						    [-1 for i in range(total + 1					)] for j in range(2 ** len(UpperCamelCase_					)					)
						]

						_lowercase					:       Optional[int]       =		defaultdict(UpperCamelCase_					)  # stores the list of persons for each task

						# final_mask is used to check if all persons are included by setting all bits
						# to 1
						_lowercase					:       Union[str, Any]       =		(1 << len(UpperCamelCase_					)) - 1




					def 						__UpperCAmelCase     (  self				:	Tuple     ,  UpperCamelCase_				:	Dict     ,  UpperCamelCase_				:	Dict					)  ->       Union[str, Any]:



						'''simple docstring'''





						if mask == self.final_mask:
							return 1

						# if not everyone gets the task and no more tasks are available, return 0
						if task_no > self.total_tasks:
							return 0

						# if case already considered
						if self.dp[mask][task_no] != -1:
							return self.dp[mask][task_no]

						# Number of ways when we don't this task in the arrangement
						_lowercase					:       List[str]       =		self.count_ways_until(UpperCamelCase_     ,  task_no + 1					)

						# now assign the tasks one by one to all possible persons and recursively
						# assign for the remaining tasks.
						if task_no in self.task:
							for p in self.task[task_no]:
								# if p is already given a task
								if mask & (1 << p):
									continue

								# assign this task to p and change the mask value. And recursively
								# assign tasks with the new mask value.
								total_ways_util += self.count_ways_until(mask | (1 << p)     ,  task_no + 1					)

        # save the value.
						_lowercase					:       Dict       =		total_ways_util

						return self.dp[mask][task_no]




					def 						__UpperCAmelCase     (  self				:	Tuple     ,  UpperCamelCase_				:	Dict					)  ->       List[Any]:



						'''simple docstring'''





						for i in range(len(UpperCamelCase_					)					):
							for j in task_performed[i]:
								self.task[j].append(UpperCamelCase_					)

        # call the function to fill the DP table, final answer is stored in dp[0][1]
						return self.count_ways_until(0     ,  1					)


if __name__ == "__main__":
		_A				:    Dict     						=5  # total no of tasks (the value of N)

		# the list of tasks that can be done by M persons.
		_A				:    List[str]     						=[[1, 3, 4], [1, 2, 5], [3, 4]]
		print(
		    AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
		        task_performed
		    )
		)





'''simple docstring'''

from __future__ import annotations

import requests







def 						__UpperCamelCase				(							_lowercase					) ->			dict:
	_lowercase					:       Optional[int]       =		f'''https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty'''
	return requests.get(_lowercase					).json()







def 						__UpperCamelCase				(							_lowercase = 10					) ->			list[dict]:
	_lowercase					:       Union[str, Any]       =		'https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty'
	_lowercase					:       Optional[Any]       =		requests.get(_lowercase					).json()[:max_stories]
	return [get_hackernews_story(_lowercase					) for story_id in story_ids]







def 						__UpperCamelCase				(							_lowercase = 10					) ->			str:
	_lowercase					:       Tuple       =		hackernews_top_stories(_lowercase					)
	return "\n".join('* [{title}]({url})'.format(**_lowercase					) for story in stories					)


if __name__ == "__main__":
		print(hackernews_top_stories_as_markdown())
