def can_finish_brute_force(number_of_courses, prerequisites):
    import itertools

    # Generate all possible course orderings
    for course_ordering in itertools.permutations(range(number_of_courses)):
        
        can_take_all_courses = True
        # Check if the current ordering is valid
        for course_to_take in course_ordering:
            for prerequisite_course, course_needing_prerequisite in prerequisites:
                if course_needing_prerequisite == course_to_take:
                    # Ensure prerequisite is met before taking the course
                    if course_needing_prerequisite in course_ordering and prerequisite_course in course_ordering:
                        if course_ordering.index(prerequisite_course) > course_ordering.index(course_needing_prerequisite):
                            can_take_all_courses = False
                            break
            if not can_take_all_courses:
                break

        # If a valid ordering is found, return True
        if can_take_all_courses:
            return True

    # If no valid ordering is found, return False
    return False

def can_finish(number_of_courses, prerequisites):
    # Create a list to store the in-degree of each course
    course_indegree = [0] * number_of_courses
    
    # Create a list to store the adjacencies of each course
    course_adjacencies = [[] for _ in range(number_of_courses)]

    for course, prerequisite in prerequisites:
        course_indegree[course] += 1
        course_adjacencies[prerequisite].append(course)

    # Queue for courses with no prerequisites.
    no_prerequisites_queue = []
    for course in range(number_of_courses):
        if course_indegree[course] == 0:
            no_prerequisites_queue.append(course)

    courses_taken_count = 0

    # Iteratively take courses.
    while no_prerequisites_queue:
        course = no_prerequisites_queue.pop(0)
        courses_taken_count += 1

        # Reduce the in-degree of dependent courses.
        for dependent_course in course_adjacencies[course]:
            course_indegree[dependent_course] -= 1

            # Enqueue courses with no remaining prerequisites.
            if course_indegree[dependent_course] == 0:
                no_prerequisites_queue.append(dependent_course)

    # If we've taken all courses, it's possible.
    if courses_taken_count == number_of_courses:
        return True
    else:
        # Cycle exists if we can't take all courses
        return False