diff --git a/Submissions/002683914_Xiaoyang_Chen/Assignment1.ipynb b/Submissions/002683914_Xiaoyang_Chen/Assignment1.ipynb new file mode 100644 index 0000000..0363d20 --- /dev/null +++ b/Submissions/002683914_Xiaoyang_Chen/Assignment1.ipynb @@ -0,0 +1,569 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c68443c2", + "metadata": {}, + "source": [ + "# INFO 6205 – Program Structure and Algorithms Worked Assignment 1" + ] + }, + { + "cell_type": "markdown", + "id": "a9323afd", + "metadata": {}, + "source": [ + "Student Name:**Xiaoyang Chen** \n", + "Professor: **Nik Bear Brown**" + ] + }, + { + "cell_type": "markdown", + "id": "b03b8372", + "metadata": {}, + "source": [ + "## Q1 (10 Points) \n", + "Arrange the following functions in increasing order of growth\n", + "• log^2(n)\n", + "• 5n^2 + 3n\n", + "• n^0.5 + 7\n", + "• n log(n)\n", + "• 3^n\n", + "• 2n^3\n", + "• n^2 log(n)" + ] + }, + { + "cell_type": "markdown", + "id": "37bfe5f9", + "metadata": {}, + "source": [ + "Solution: \n", + "1、n^0.5 + 7 \n", + "2、log^2(n) \n", + "3、n log(n) \n", + "4、5n^2 + 3n \n", + "5、n^2 log(n) \n", + "6、2n^3 \n", + "7、3^n" + ] + }, + { + "cell_type": "markdown", + "id": "2dbbcb60", + "metadata": {}, + "source": [ + "Explain: \n", + "1、n^0.5 + 7 \n", + "For large n, the constant part has little effect on the overall growth, so it is mostly a square root growth.\n", + "\n", + "2、log^2(n) \n", + "For large values of n, the square of the logarithmic function will grow faster than the single logarithmic function, but still slower than linear, polynomial, and exponential functions.\n", + "\n", + "3、n log(n)\n", + "When n is large, linear logarithmic functions are faster than linear functions but slower than polynomial functions.\n", + "\n", + "4、5n^2 + 3n\n", + "The quadratic part dominates the growth, so it grows as n squared.\n", + "\n", + "5、n^2 log(n)\n", + "This is faster than n^2 but slower than n^3. Its growth is dominated by the n^2 part, but log(n) makes it grow slightly faster.\n", + "\n", + "6、2n^3\n", + "\n", + "7、3^n\n", + "The exponential function grows very fast, far exceeding all the polynomial functions above." + ] + }, + { + "cell_type": "markdown", + "id": "f4fedfd6", + "metadata": {}, + "source": [ + "## Q2 (10 Points)\n", + "Proposition 1:If f(n)=O(g(n)) and g(n)=O(h(n)),then f(n)=O(h(n)). \n", + "Proposition 2:If f(n)=O(g(n)+h(n)),then f(n)=O(g(n)) or f(n)=O(h(n)) \n", + "Proposition 3:If f(n)is a polynomial function and g(n) is an exponential function,then f(n)=o(g(n))." + ] + }, + { + "cell_type": "markdown", + "id": "a7b03a65", + "metadata": {}, + "source": [ + "Answer: \n", + "1、Counter proof：\n", + "If f(n)=O(g(n)), then there exists a constant C1 such that f(n)≤C1*g(n) for sufficiently large n.\n", + "If g(n)=O(h(n)), then there exists a constant C2 such that g(n)≤C2*h(n).\n", + "Combining the two inequalities, we get f(n)≤C1*C2*×h(n), thus f(n)=O(h(n)).\n", + "\n", + "2、Counter proof：\n", + "Let f(n)=2n, g(n)=n, and h(n)=n.\n", + "Clearly, f(n)=2n is O(n+n), but f(n)=2n is neither an upper bound of O(n) nor lower bound of O(n).\n", + "\n", + "3、Let f(n)=n^k where k is any positive constant.\n", + " Let g(n)=a^n where a is a constant greater than 1.\n", + "For any polynomial f(n), its growth rate is always surpassed by the corresponding exponential function g(n). That is, f(n)m. Each mission requires a specific player skill set to complete. Each player has a set of skills, but they may not be good at all tasks. In addition, each player has a preference list for tasks based on the rewards they wish to receive. Missions also have a list of player preferences based on the skills required to complete the mission.\n", + "\n", + "Question: How to assign a player to each task so that as many tasks as possible are completed by the appropriate player, taking into account player and task preferences?" + ] + }, + { + "cell_type": "markdown", + "id": "ef115d7b", + "metadata": {}, + "source": [ + "Solution： \n", + "The solution to this problem is different from the Gale-Shapley algorithm, because we are not only looking for stable matching, but also consider both aspects of skill matching and preference. Furthermore, we are also more concerned with maximizing the number of completed tasks than just finding stable matches.\n", + "\n", + "\n", + "The algorithm terminates in O(mnlog(n)).The algorithm is as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b80a7aa6", + "metadata": {}, + "outputs": [], + "source": [ + "function assignPlayersToTasks(players, tasks):\n", + " unassignedTasks = []\n", + " for task in tasks:\n", + " suitablePlayers = findPlayersWithRequiredSkills(task, players)\n", + " if suitablePlayers is empty:\n", + " unassignedTasks.append(task)\n", + " continue\n", + " sortedPlayers = sortPlayersByPreference(suitablePlayers, task)\n", + " assignPlayerToTask(sortedPlayers[0], task)\n", + "\n", + " for task in unassignedTasks:\n", + " alternativePlayers = findPlayersWithoutRequiredSkills(task, players)\n", + " if alternativePlayers is not empty:\n", + " sortedPlayers = sortPlayersByPreference(alternativePlayers, task)\n", + " assignPlayerToTask(sortedPlayers[0], task)\n", + "\n", + "function findPlayersWithRequiredSkills(task, players):\n", + " suitablePlayers = []\n", + " for player in players:\n", + " if player has all skills required by task:\n", + " suitablePlayers.append(player)\n", + " return suitablePlayers\n", + "\n", + "function sortPlayersByPreference(suitablePlayers, task):\n", + " return players sorted by:\n", + " 1. Player's preference for the task\n", + " 2. Task's preference for the player's skills\n" + ] + }, + { + "cell_type": "markdown", + "id": "b6e25f9a", + "metadata": {}, + "source": [ + "## Q4 (10 Points)\n", + "One algorithm requires 10log3(n) microseconds, and another algorithm requires n^(1/3) microseconds. Which one is asymptotically faster? What is the cross-over value of n?\n", + "\n", + "Solution:\n", + "The first algorithm is asymptotically faster than the second.\n", + "The order of growth of 10log3(n) is less than the order of growth of n^(1/3)\n", + "Crossover point of n is when 10log3(n)=n^(1/3)." + ] + }, + { + "cell_type": "markdown", + "id": "a15955db", + "metadata": {}, + "source": [ + "## Q5（10 Points）\n", + "A tower is built using a sequence of cubic blocks. The total number of blocks used to build each level is the product of the number of blocks used to build the current level and the level just below it. Suppose for validation, each level has a total number of blocks that is bounded by constant d, and the tower will comprise at most m blocks. Demonstrate how to construct such a tower with blocks which have height g(m), for a function g(m) that escalates as slowly as possible." + ] + }, + { + "cell_type": "markdown", + "id": "3f8c27d0", + "metadata": {}, + "source": [ + "Suppose to accumulate m blocks, we require L levels. We document the process as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9503cd60", + "metadata": {}, + "outputs": [], + "source": [ + "Level 1 = \n", + "Level 2 = \n", + "...\n", + "Level L = \n", + "\n", + "For i = 1,2,..L\n", + " For j = 1,2,...i\n", + " Multiply blocks j through L\n", + " Endfor\n", + "Endfor" + ] + }, + { + "cell_type": "markdown", + "id": "1d87372c", + "metadata": {}, + "source": [ + "The nested For loops have a span bounded by constant d1. Hence, the significant space in the documentation is consumed by the number of blocks on the level. Each of these levels in the documentation has a span at most d2(where d2 is the maximum number of blocks d for a level plus the space to add a new block). Therefore, in total, the space necessitated by the documentation D=d1+(d2∗L).\n", + "\n", + "Recall that m symbolizes the number of blocks needed to erect the tower, m is at least \n", + "1∗2∗....∗L=L!. This leads us to L!≤m, which gives us an estimate on L.\n", + "\n", + "Plugging this into our limit on the span of the documentation, we derive g(m)=D≤d1+d2\n", + "∗L=O(L). Given the factorial relationship, the slowest growth would be closer to logarithmic, but it's more complex to precisely determine without further context." + ] + }, + { + "cell_type": "markdown", + "id": "445970de", + "metadata": {}, + "source": [ + "## Q6 (5 Points）\n", + "One algorithm takes log4(n) seconds and another algorithm requires n^(1/4) seconds. Which one grows asymptotically faster? In other words, which one grows faster as \n", + "n becomes larger? What is the cross-over value of n? (The point where the two time complexities intersect)?" + ] + }, + { + "attachments": { + "%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20230922204528.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "ecb65cdf", + "metadata": {}, + "source": [ + "log4(n) grows logarithmically, which means it will grow slower than any polynomial function of n (including n^(1/4)).\n", + "n^(1/4) grows as the cube root of n, which means it will grow faster than log 4(n) but slower than linear growth.\n", + "So, Algorithm B that takes n^(1/4) seconds grows faster asymptotically than Algorithm A that takes log4(n) seconds.\n", + "![%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20230922204528.png](attachment:%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20230922204528.png)" + ] + }, + { + "cell_type": "markdown", + "id": "c2b07404", + "metadata": {}, + "source": [ + "x = 256 \n", + "The order of growth of log4(n) is less (slower) than the order of growth of n^(1/4)\n", + "Crossover point of n is 256." + ] + }, + { + "cell_type": "markdown", + "id": "f3f436bb", + "metadata": {}, + "source": [ + "## Q7 (10 Points） \n", + "In a town of artists, every artist has a preference list of galleries where they'd like to display their artwork. Consider a scenario where Gallery X ranks Artist Y as its top choice and Artist Y ranks Gallery X as its top choice. If we try to create a stable matching between artists and galleries, will Artist Y and Gallery X always be matched together? State your reasoning or provide a counterexample.\n" + ] + }, + { + "cell_type": "markdown", + "id": "869d1cee", + "metadata": {}, + "source": [ + "Statement: Yes.\n", + "\n", + "Explanation: In the context of the Stable Matching problem, if Gallery X ranks Artist Y as its top choice and Artist Y ranks Gallery X as its top choice, then in any stable matching, Artist Y and Gallery X must be matched together. If they weren't paired in some proposed stable matching, it implies that either Artist Y is displaying at another gallery or Gallery X is hosting another artist (or both). Given their mutual top preferences for each other, they would prefer to be matched together over their current matches. This forms a blocking pair, contradicting the definition of a stable matching. Hence, for a matching to be stable, Artist Y and Gallery X must be paired together." + ] + }, + { + "cell_type": "markdown", + "id": "b12d39f3", + "metadata": {}, + "source": [ + "## Q8 （10 Points） \n", + "Two competing research institutions, Lab Alpha and Lab Beta, are involved in various research projects. Each lab has several scientists with specific expertise. Each research project requires expertise in one particular field, and each scientist can only be assigned to one project.\n", + "\n", + "Each scientist has a proficiency score for each project based on their expertise and previous work. A project is considered successful if the assigned scientist from Lab Alpha has a higher proficiency score for that project than the scientist from Lab Beta, and vice versa. Both labs aim to have as many successful projects as possible.\n", + "\n", + "Let's suppose in the initial planning phase, Lab Alpha chooses a strategy P (scientists to projects) and Lab Beta chooses a strategy Q. The pair (P,Q) is stable if neither lab can change its strategy unilaterally to have more successful projects. That means there isn't a strategy P for Lab Alpha such that they would have more successful projects with (P ,Q), and there isn't a strategy Q for Lab Beta such that they would have more successful projects with (P,Q).\n", + "\n", + "Given the set of scientists and their proficiency scores for each project, is there always a stable pair of strategies?" + ] + }, + { + "cell_type": "markdown", + "id": "c0bc2a14", + "metadata": {}, + "source": [ + "False\n", + "\n", + "Counterexample for Stable Laboratory Assignments:\n", + "\n", + "Consider two projects: Project 1 and Project 2. Let's have two scientists from each lab:\n", + "\n", + "For Lab Alpha: \n", + "Scientist A1 has proficiency scores of 5 for Project 1 and 6 for Project 2. \n", + "Scientist A2 has proficiency scores of 7 for Project 1 and 4 for Project 2. \n", + " \n", + "For Lab Beta: \n", + "Scientist B1 has proficiency scores of 6 for Project 1 and 5 for Project 2. \n", + "Scientist B2 has proficiency scores of 8 for Project 1 and 3 for Project 2. \n", + "\n", + "Now, consider the initial strategies: \n", + "P: A1 -> Project 1, A2 -> Project 2 \n", + "Q: B1 -> Project 1, B2 -> Project 2 \n", + "\n", + "Using these strategies, Lab Beta wins both projects. However, Lab Alpha can change its strategy by assigning A2 to Project 1 and A1 to Project 2, and they would win Project 1. When they do this, Lab Beta could switch B1 and B2, making them win both projects again. This can keep going in circles without arriving at a stable assignment.\n", + "\n", + "Thus, there isn't always a guaranteed stable pair of strategies for the given problem." + ] + }, + { + "cell_type": "markdown", + "id": "5ded01c4", + "metadata": {}, + "source": [ + "## Q9 （25 Points）\n", + "A large university library is introducing a study-group matching system. The library has several study rooms available for booking, and students form groups for collaborative learning. However, the library has noted that many groups tend to shift rooms, leading to logistical challenges.\n", + "\n", + "To address this, they decide to use the Gale-Shapley matching algorithm. Each study group will rank their preferred rooms based on factors like lighting, room size, proximity to resources, etc. Each room has a \"personality\" based on its attributes, and room managers will rank study groups based on the kind of group activity (quiet discussion, multimedia presentations, etc.).\n", + "\n", + "A study group-room match is stable if:\n", + "\n", + "No study group and room both prefer each other over their current assignments. \n", + "No study group remains without a room. \n", + "Students, library staff, and faculty will be asked to provide input to create these rankings, ensuring that each study group is matched with a room that best fits their needs." + ] + }, + { + "cell_type": "markdown", + "id": "7dab72dd", + "metadata": {}, + "source": [ + "### A\n", + "Modify an existing Gale-Shapley implementation in python to build stable maching for assgining the roommates \n", + "\n", + "### Solution:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac4fb5ee", + "metadata": {}, + "outputs": [], + "source": [ + "def gale_shapley_study_groups(study_groups_prefs, study_rooms_prefs):\n", + " # Initialize the unmatched study groups and their current proposals\n", + " unmatched_study_groups = list(study_groups_prefs.keys())\n", + " proposals = {}\n", + "\n", + " # Each study room is initially available\n", + " room_matches = {room: None for room in study_rooms_prefs}\n", + "\n", + " while unmatched_study_groups:\n", + " study_group = unmatched_study_groups.pop(0)\n", + " study_group_prefs = study_groups_prefs[study_group]\n", + "\n", + " # Propose to the first preferred room not yet proposed to\n", + " for room in study_group_prefs:\n", + " if room not in proposals.get(study_group, []):\n", + " if room_matches[room] is None:\n", + " # The room is free, match the study group\n", + " room_matches[room] = study_group\n", + " proposals[study_group] = proposals.get(study_group, []) + [room]\n", + " break\n", + " else:\n", + " current_study_group = room_matches[room]\n", + " if study_rooms_prefs[room].index(study_group) < study_rooms_prefs[room].index(current_study_group):\n", + " # The room prefers the new study group\n", + " room_matches[room] = study_group\n", + " proposals[study_group] = proposals.get(study_group, []) + [room]\n", + " unmatched_study_groups.append(current_study_group)\n", + " break\n", + " else:\n", + " # Continue with the next preference\n", + " proposals[study_group] = proposals.get(study_group, []) + [room]\n", + "\n", + " return room_matches\n", + "\n", + "# Example usage:\n", + "\n", + "study_groups_prefs = {\n", + " 'GroupA': ['Room1', 'Room2', 'Room3'],\n", + " 'GroupB': ['Room2', 'Room3', 'Room1'],\n", + " 'GroupC': ['Room3', 'Room1', 'Room2']\n", + "}\n", + "\n", + "study_rooms_prefs = {\n", + " 'Room1': ['GroupA', 'GroupB', 'GroupC'],\n", + " 'Room2': ['GroupB', 'GroupA', 'GroupC'],\n", + " 'Room3': ['GroupC', 'GroupA', 'GroupB']\n", + "}\n", + "\n", + "matches = gale_shapley_study_groups(study_groups_prefs, study_rooms_prefs)\n", + "print(matches)\n" + ] + }, + { + "cell_type": "markdown", + "id": "3e23bcaa", + "metadata": {}, + "source": [ + "### B\n", + "suppose that instead of a simple ranked preference list, each study room and study group assigns weights to their preferences. The weight reflects how suitable or ideal a match is.\n", + "\n", + "For instance, a study group might assign a weight of 0.9 to a particular room indicating a strong preference, whereas a weight of 0.2 indicates a weak preference. Similarly, study rooms would assign weights to study groups." + ] + }, + { + "cell_type": "markdown", + "id": "8fcec67b", + "metadata": {}, + "source": [ + "### Solution: \n", + "Start with the Gale-Shapley algorithm but use weights instead of rankings to establish initial matches. \n", + "Check for stability. If stable, calculate the total weight. \n", + "If not stable, adjust the rankings based on weights and re-run the Gale-Shapley algorithm. \n", + "Repeat the above steps iteratively until a stable match with a high total weight is found. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4849ff14", + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "\n", + "def gale_shapley_weighted(study_groups_prefs, study_rooms_prefs):\n", + " unmatched_study_groups = list(study_groups_prefs.keys())\n", + " proposals = {}\n", + " room_matches = {room: None for room in study_rooms_prefs}\n", + "\n", + " while unmatched_study_groups:\n", + " study_group = unmatched_study_groups.pop(0)\n", + " study_group_prefs = sorted(study_groups_prefs[study_group].items(), key=lambda x: x[1], reverse=True)\n", + " for room, _ in study_group_prefs:\n", + " if room not in proposals.get(study_group, []):\n", + " if room_matches[room] is None:\n", + " room_matches[room] = study_group\n", + " proposals[study_group] = proposals.get(study_group, []) + [room]\n", + " break\n", + " else:\n", + " current_study_group = room_matches[room]\n", + " if study_rooms_prefs[room][study_group] > study_rooms_prefs[room][current_study_group]:\n", + " room_matches[room] = study_group\n", + " proposals[study_group] = proposals.get(study_group, []) + [room]\n", + " unmatched_study_groups.append(current_study_group)\n", + " break\n", + " else:\n", + " proposals[study_group] = proposals.get(study_group, []) + [room]\n", + " return room_matches\n", + "\n", + "def total_weight(matches, study_groups_prefs, study_rooms_prefs):\n", + " weight = 0\n", + " for room, study_group in matches.items():\n", + " weight += study_groups_prefs[study_group][room] + study_rooms_prefs[room][study_group]\n", + " return weight\n", + "\n", + "study_groups_prefs = {\n", + " 'GroupA': {'Room1': 0.9, 'Room2': 0.5, 'Room3': 0.4},\n", + " 'GroupB': {'Room2': 0.8, 'Room3': 0.7, 'Room1': 0.4},\n", + " 'GroupC': {'Room3': 0.9, 'Room1': 0.6, 'Room2': 0.5}\n", + "}\n", + "\n", + "study_rooms_prefs = {\n", + " 'Room1': {'GroupA': 0.9, 'GroupB': 0.5, 'GroupC': 0.7},\n", + " 'Room2': {'GroupB': 0.7, 'GroupA': 0.5, 'GroupC': 0.6},\n", + " 'Room3': {'GroupC': 0.8, 'GroupA': 0.4, 'GroupB': 0.7}\n", + "}\n", + "\n", + "max_weight = 0\n", + "best_match = None\n", + "\n", + "# Iterative process\n", + "for _ in range(1000): # You can adjust the number of iterations\n", + " matches = gale_shapley_weighted(study_groups_prefs, study_rooms_prefs)\n", + " weight = total_weight(matches, study_groups_prefs, study_rooms_prefs)\n", + " \n", + " if weight > max_weight:\n", + " max_weight = weight\n", + " best_match = matches\n", + " \n", + " # Randomly shuffle the preferences to potentially find better matches\n", + " for prefs in [study_groups_prefs, study_rooms_prefs]:\n", + " for entity in prefs:\n", + " items = list(prefs[entity].items())\n", + " random.shuffle(items)\n", + " prefs[entity] = dict(items)\n", + "\n", + "print(\"Best Match:\", best_match)\n", + "print(\"Max Weight:\", max_weight)\n" + ] + }, + { + "cell_type": "markdown", + "id": "2c8bff13", + "metadata": {}, + "source": [ + "### C \n", + "Double the size of the lists preferences and measure the amount of time it takes to create stable matches. How fast does the execution time grow in relation to the size of the lists?\n", + "\n", + "### Solution: \n", + "Given the initial assumption:\n", + "\n", + "There are n+1 students.\n", + "Each student has a preference list of length n.\n", + "So, the algorithm's time complexity is O((n+1)×n)=O(n^2).\n", + "\n", + "Now, when the preference list doubles to 2n:\n", + "The number of students becomes 2(n+1).\n", + "Each student has a preference list of length 2n.\n", + "The algorithm's time complexity would be O((2(n+1))×2n)=O(4n^2+4n)=O(n^2) because we drop constant factors and lower-order terms for Big-O notation.\n", + "Therefore, despite the doubling of the preference list and student number, the algorithm's time complexity remains \n", + "O(n^2) in both scenarios." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "149351f8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/002683914_Xiaoyang_Chen/Xiaoyang_Chen_002683914.md b/Submissions/002683914_Xiaoyang_Chen/Xiaoyang_Chen_002683914.md new file mode 100644 index 0000000..62b101a --- /dev/null +++ b/Submissions/002683914_Xiaoyang_Chen/Xiaoyang_Chen_002683914.md @@ -0,0 +1 @@ +When I utilize ChatGPT, it typically delivers insightful answers. However, there are moments when it stumbles over fundamental concepts, and at times, it can misconstrue descriptions leading to inaccurate conclusions. Expecting it to provide flawless answers on the first attempt might be unrealistic; often, multiple corrections are needed to fine-tune the response. I've also observed that while ChatGPT's coding abilities are commendable for simpler tasks, it tends to falter with intricate algorithms, especially when not provided with a template or reference. Therefore, it's crucial to critically assess ChatGPT's feedback and maintain an independent line of reasoning. Through this exercise, my understanding of algorithmic analysis and data structures has deepened. Moreover, I've pondered over various scenarios of stable matching and discerned how the algorithm adapts across different contexts. \ No newline at end of file diff --git a/Submissions/002688252_Zijian_Feng/Assignment1.ipynb b/Submissions/002688252_Zijian_Feng/Assignment1.ipynb new file mode 100644 index 0000000..067848b --- /dev/null +++ b/Submissions/002688252_Zijian_Feng/Assignment1.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 1\n", + "- Student Name:Zijian Feng\n", + "- NUID:002688252\n", + "- Professor: Nik Bear Brown" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Q1 Arrange the following functions in increasing order of growth:\n", + "- log(log(10n))\n", + "- 0.8^n\n", + "- n!\n", + "- n^2+n+101\n", + "- n+10\n", + "- log(100n+101)\n", + "- 10^n+2000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution:\n", + "1. 0.8^n \n", + "As n tends to infinity, the expression tends to a constant \n", + "2. log(log(10n)) \n", + "This is the logarithm of log(logarithmic) in log(logarithmic), which grows very slowly. \n", + "3. log(100n+10) \n", + "Logarithmic time complexity: although it contains a linear term, the lower terms and constant factors are usually ignored in large O representations, so this is still logarithmic level time complexity. \n", + "4. n+10\n", + "The growth rate is linear. \n", + "5. n^2+n+101 \n", + "This is quadratic time complexity because the main growth term is n^2. Despite the fact that there is a linear term, the main focus is on the highest-order term in the big-O representation. \n", + "6. 10^n+2000 \n", + "Exponential time complexity.When n grows, this is a very fast exponential growth. \n", + "7. n! \n", + "Factorial Time Complexity: this is the highest time complexity because it grows very fast, as n increases, the execution time grows at a factorial level, much faster than the other functions. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Q2\n", + "Assume that the function f and g such that f(n) is O(g(n)). Please judge the following statements are true or false.\n", + "- $f(n)=θ(f(n/2)$\n", + "- $f(n)=O(f(\\sqrt[3]{n}))$\n", + "- If f(n) is a linear function and g(n) is an exponential function,then f(n) = O(g(n))." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution\n", + "- Proof:\n", + " - f(n) = O(log(2n));\n", + " - f(n/2) = O(log2(n/2)) = O(log(2n)-1); \n", + " - So we can suppose f(n)=θ(f(n/2)\n", + "- Counter proof:$f(n) = n = O(n) ≠O(\\sqrt[3]{n})$\n", + "- Proof:\n", + " - Since f(n) is a linear function, so we assume f(n)=n+10\n", + " - Since g(n) is an exponential function, so we assume g(n)=10^n+2000\n", + " - From quetsion 1 we have already know that when n grows very large, f(n)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "x = np.arange(1, 101)\n", + "\n", + "y1 = np.power(x, 1/3)\n", + "y2 = np.log(x) / np.log(3)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "plt.plot(x, y1, label='n^(1/3)', color='red')\n", + "\n", + "\n", + "plt.plot(x, y2, label='log3(n)', color='blue')\n", + "\n", + "plt.legend()\n", + "\n", + "plt.title('n^(1/3) vs. log3(n)')\n", + "plt.xlabel('n')\n", + "plt.ylabel('Value')\n", + "\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "log3(n) is slower when n gets larger." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The crossover point is approximately 15.2171\n" + ] + } + ], + "source": [ + "from scipy.optimize import fsolve\n", + "import numpy as np\n", + "\n", + "def equation(x):\n", + " return np.log(x) / np.log(3) - x**(1/3)\n", + "\n", + "initial_guess = 2.0 \n", + "\n", + "result = fsolve(equation, initial_guess)\n", + "\n", + "print(f\"The crossover point is approximately {result[0]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Q7\n", + "For selecting the roommates. If student A is ranked first in the preference list of student B and B is also ranked first in the preference list of student A. Whether pair(A,B) is stable matching for all matches." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution:\n", + "Pair(A,B) is stable matching for all matches. If we have another pair (A,C) instead of (A,B),which means A prefer C to B. But B is ranked first in the preference list of A. So (A,B) is a stable matching." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Q8\n", + "In the context of horse races in Hong Kong, where each owner selects three horses and the goal is to win at least two out of three races to secure all the chips, we consider different strategies employed by owners. Let's denote one owner's strategy as 'S' and another owner's strategy as 'T'. \n", + "\n", + "We say that the pair (S, T) is stable if either team can unilaterally change their schedule and win more races. If there is no strategy S' that allows team X to win more games in the pair (S', T), symmetrically, there is no strategy T' that allows team Y to win more games in the pair (S, T') than in the pair (S, T). Then we can claim that (S,T) is stable. \n", + "\n", + "Is there have a stable pair in horse racing？" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution：\n", + "- Let's assume that Boss A has three horses and their ratings are 70, 80, 90.\n", + "- We also assume that Boss B has three horses with ratings of 65, 75, 85.\n", + "- Assuming that Boss A's strategy is (70,65),(80,75),(90,85), then the current Boss A can win. \n", + "- But if Boss B changes his strategy to (70,75),(80,85),(90,65), then Boss B can win. \n", + "- Therefore there is no stable pair." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Q9\n", + "Since graduate students are not assigned a dormitory, they need to find an apartment to rent and select their roommates by themselves. Assuming that we have a `students` list and their `preferences` list. How should we make roommate assignments so that they are all as satisfied as possible.\n", + "The assignment of roommate is stable if following situation don't arise:\n", + "- student already has a roommate,but he is more prefer the current candidate and the current candidate is free" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A \n", + "Modify an existing Gale-Shapley implementation in python to build stable maching for assgining the roommates." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bob -> Alice\n", + "Alice -> Bob\n", + "Dave -> Charlie\n", + "Charlie -> Dave\n" + ] + } + ], + "source": [ + "students = [\"Alice\", \"Bob\", \"Charlie\", \"Dave\"]\n", + "preferences = {\n", + " \"Alice\": [\"Bob\", \"Charlie\", \"Dave\"],\n", + " \"Bob\": [\"Alice\", \"Dave\", \"Charlie\"],\n", + " \"Charlie\": [\"Bob\", \"Dave\", \"Alice\"],\n", + " \"Dave\": [\"Charlie\", \"Bob\", \"Alice\"]\n", + "}\n", + "\n", + "# Initialize roommate assignments\n", + "roommates = {}\n", + "\n", + "# create a list to store the student current consider\n", + "students_to_consider = students.copy()\n", + "\n", + "while students_to_consider:\n", + " current_student = students_to_consider.pop(0)\n", + " current_preference_list = preferences[current_student]\n", + "\n", + " for preferred_roommate in current_preference_list:\n", + " # if preferred_roommate is free, the assign him to current student\n", + " if preferred_roommate not in roommates:\n", + " roommates[preferred_roommate] = current_student\n", + " break\n", + " else:\n", + " current_roommate = roommates[preferred_roommate]\n", + " # if student prefer the current roommate,we don't need to make any change\n", + " if preferences[preferred_roommate].index(current_roommate) < preferences[preferred_roommate].index(current_student):\n", + " continue\n", + " else:\n", + " # otherwise,change the roommate\n", + " roommates[preferred_roommate] = current_student\n", + " students_to_consider.append(current_roommate)\n", + "\n", + "# show the result\n", + "for student, roommate in roommates.items():\n", + " print(f\"{student} -> {roommate}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## B\n", + "Suppose when a candidate is selected successfully, it has to be removed from the preferences list, is the current algorithm still a stable algorithm?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution:\n", + "No.Because sometimes the eliminate candidates are asymmetrically." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## C\n", + "Double the size of the lists preferences and measure the amount of time it takes to create stable matches. How fast does the execution time grow in relation to the size of the lists?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution:\n", + "We assume the student number is n+1,so the preferences list length is n.The Algorithm is f(n) and the O(f(n)) is O((n+1)*n).When the preferencea list become to 2n which means the length of students also become to 2(n+1). We assume the new algorithem is g(n) and the O(g(n)) equals to f((2n+2)*(2n)). So both time complexity are O(n^2)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Submissions/002688252_Zijian_Feng/Zijian_Feng_002688252.md b/Submissions/002688252_Zijian_Feng/Zijian_Feng_002688252.md new file mode 100644 index 0000000..835aac4 --- /dev/null +++ b/Submissions/002688252_Zijian_Feng/Zijian_Feng_002688252.md @@ -0,0 +1,13 @@ +# The Summary of Assignment One + +- Student Name:Zijian Feng +- NUID:002688252 +- Professor: Nik Bear Brown + +## The reflection of using ChatGPT + +When I use ChatGPT, it tends to be pretty reliable. But there are times when it makes some low-level mistakes. For example, it says that 0.8^n is an exponential level of time complexity, and therefore a very rapid growth. In reality this time complexity is O(1) level. We need to pay attention to the details of his answers and not give up thinking when using ChatGPT. + +## What I learned in this assignment + +After doing this assignment, I have a better understanding of stable matching and time complexity. And I have also thought about the various situations of stable matching and know how the stable matching algorithm changes in different situations. diff --git a/Submissions/002700370_Sun_Teng/Assignment-1.readme b/Submissions/002700370_Sun_Teng/Assignment-1.readme new file mode 100644 index 0000000..6dd9d68 --- /dev/null +++ b/Submissions/002700370_Sun_Teng/Assignment-1.readme @@ -0,0 +1 @@ +This is a readme. \ No newline at end of file diff --git a/Submissions/002700370_Sun_Teng/assignment1Q9.ipynb b/Submissions/002700370_Sun_Teng/assignment1Q9.ipynb new file mode 100644 index 0000000..9c12e74 --- /dev/null +++ b/Submissions/002700370_Sun_Teng/assignment1Q9.ipynb @@ -0,0 +1,299 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "id": "e108b783-044d-4c70-bd63-1eda236f2498", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matching Result:\n", + "Nets matched with Nuggets\n", + "Hawks matched with Clippers\n", + "76ers matched with Jazz\n", + "Celtics matched with Suns\n", + "Raptors matched with Mavericks\n", + "Knicks matched with Warriors\n", + "Heat matched with Blazers\n", + "Bucks matched with Lakers\n" + ] + } + ], + "source": [ + "west_teams = [\"Lakers\", \"Clippers\", \"Suns\", \"Warriors\", \"Jazz\", \"Nuggets\", \"Blazers\", \"Mavericks\"]\n", + "east_teams = [\"Bucks\", \"Nets\", \"76ers\", \"Celtics\", \"Heat\", \"Hawks\", \"Knicks\", \"Raptors\"]\n", + "\n", + "west_preferences = {\n", + " \"Lakers\": [\"Bucks\", \"Nets\", \"76ers\", \"Celtics\", \"Heat\", \"Hawks\", \"Knicks\", \"Raptors\"],\n", + " \"Clippers\": [\"Celtics\", \"Nets\", \"Raptors\", \"Heat\", \"Knicks\", \"Bucks\", \"Hawks\", \"76ers\"],\n", + " \"Suns\": [\"Nets\", \"Bucks\", \"Knicks\" , \"Heat\", \"Celtics\", \"Hawks\",\"Raptors\", \"76ers\"],\n", + " \"Warriors\": [\"76ers\", \"Hawks\", \"Bucks\", \"Celtics\", \"Heat\", \"Knicks\", \"Raptors\", \"Nets\"],\n", + " \"Jazz\": [\"Celtics\", \"Heat\", \"Nets\", \"Hawks\", \"76ers\", \"Knicks\", \"Raptors\", \"Bucks\"],\n", + " \"Nuggets\": [\"Heat\",\"Bucks\", \"Nets\", \"76ers\", \"Knicks\", \"Hawks\", \"Raptors\", \"Celtics\"],\n", + " \"Blazers\": [\"Hawks\",\"Bucks\", \"Nets\", \"Raptors\", \"76ers\", \"Celtics\", \"Heat\", \"Knicks\"],\n", + " \"Mavericks\": [\"Nets\", \"76ers\", \"Knicks\", \"Celtics\", \"Hawks\", \"Heat\", \"Bucks\", \"Raptors\"]\n", + "}\n", + "\n", + "east_preferences = {\n", + " \"Bucks\": [\"Lakers\", \"Nuggets\", \"Clippers\", \"Warriors\", \"Mavericks\", \"Jazz\", \"Suns\", \"Blazers\"],\n", + " \"Nets\": [\"Lakers\", \"Clippers\", \"Suns\", \"Warriors\", \"Jazz\", \"Nuggets\", \"Blazers\", \"Mavericks\"],\n", + " \"76ers\": [\"Nuggets\", \"Clippers\", \"Blazers\", \"Lakers\", \"Jazz\", \"Suns\", \"Warriors\", \"Mavericks\"],\n", + " \"Celtics\": [\"Lakers\", \"Clippers\", \"Mavericks\", \"Suns\", \"Warriors\", \"Nuggets\", \"Blazers\", \"Jazz\"],\n", + " \"Heat\": [\"Nuggets\", \"Lakers\", \"Suns\", \"Clippers\", \"Warriors\", \"Jazz\", \"Mavericks\", \"Blazers\"],\n", + " \"Hawks\": [\"Warriors\", \"Mavericks\", \"Lakers\", \"Clippers\", \"Nuggets\", \"Suns\", \"Jazz\", \"Blazers\"],\n", + " \"Knicks\": [\"Suns\", \"Lakers\", \"Warriors\",\"Clippers\", \"Mavericks\", \"Jazz\", \"Nuggets\", \"Blazers\"],\n", + " \"Raptors\": [\"Clippers\", \"Warriors\", \"Suns\", \"Nuggets\", \"Blazers\", \"Jazz\", \"Mavericks\", \"Lakers\"]\n", + "}\n", + "import random\n", + "\n", + "def gale_shapley(proposers, acceptors):\n", + " # Initialize empty matching\n", + " matching = {}\n", + " \n", + " # Create dictionaries to store preferences\n", + " proposer_preferences = {team: random.sample(acceptors, len(acceptors)) for team in proposers}\n", + " acceptor_preferences = {team: random.sample(proposers, len(proposers)) for team in acceptors}\n", + " \n", + " # Initialize proposers without partners\n", + " free_proposers = list(proposers)\n", + " \n", + " while free_proposers:\n", + " proposer = free_proposers.pop(0)\n", + " proposer_prefs = proposer_preferences[proposer]\n", + " \n", + " for acceptor in proposer_prefs:\n", + " current_partner = matching.get(acceptor)\n", + " \n", + " if current_partner is None:\n", + " # Acceptor is free, match them with proposer\n", + " matching[acceptor] = proposer\n", + " break\n", + " else:\n", + " # Check if acceptor prefers proposer over current partner\n", + " acceptor_prefs = acceptor_preferences[acceptor]\n", + " if acceptor_prefs.index(proposer) < acceptor_prefs.index(current_partner):\n", + " # Acceptor prefers proposer, unmatch them and match proposer\n", + " matching[acceptor] = proposer\n", + " free_proposers.append(current_partner)\n", + " break\n", + " \n", + " return matching\n", + "\n", + "if __name__ == \"__main__\":\n", + " western_teams = [\"Lakers\", \"Clippers\", \"Suns\", \"Warriors\", \"Jazz\", \"Nuggets\", \"Blazers\", \"Mavericks\"]\n", + " eastern_teams = [\"Bucks\", \"Nets\", \"76ers\", \"Celtics\", \"Heat\", \"Hawks\", \"Knicks\", \"Raptors\"]\n", + " \n", + " matching = gale_shapley(western_teams, eastern_teams)\n", + " \n", + " print(\"Matching Result:\")\n", + " for acceptor, proposer in matching.items():\n", + " print(f\"{acceptor} matched with {proposer}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9b477a8b-afb2-450c-b23d-bd9252eaf6f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Percentage of stable playoff matches after 1000 iterations: 37.4%\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "def gale_shapley(proposers, acceptors, proposer_preferences, acceptor_preferences):\n", + " # Initialize empty matching\n", + " matching = {}\n", + " \n", + " # Initialize proposers without partners\n", + " free_proposers = list(proposers)\n", + " \n", + " while free_proposers:\n", + " proposer = free_proposers.pop(0)\n", + " proposer_prefs = proposer_preferences[proposer]\n", + " \n", + " for acceptor in proposer_prefs:\n", + " current_partner = matching.get(acceptor)\n", + " \n", + " if current_partner is None:\n", + " # Acceptor is free, match them with proposer\n", + " matching[acceptor] = proposer\n", + " break\n", + " else:\n", + " # Check if acceptor prefers proposer over current partner\n", + " acceptor_prefs = acceptor_preferences[acceptor]\n", + " if acceptor_prefs.index(proposer) < acceptor_prefs.index(current_partner):\n", + " # Acceptor prefers proposer, unmatch them and match proposer\n", + " matching[acceptor] = proposer\n", + " free_proposers.append(current_partner)\n", + " break\n", + " \n", + " return matching\n", + "\n", + "def is_stable_match(matching, proposer_preferences, acceptor_preferences):\n", + " # Check if the current matching is stable\n", + " for acceptor, proposer in matching.items():\n", + " acceptor_prefs = acceptor_preferences[acceptor]\n", + " current_partner_index = acceptor_prefs.index(proposer)\n", + " for other_proposer in acceptor_prefs[:current_partner_index]:\n", + " if proposer_preferences[other_proposer].index(acceptor) < proposer_preferences[proposer].index(acceptor):\n", + " return False\n", + " return True\n", + "\n", + "def calculate_stability_percentage(proposers, acceptors, num_iterations):\n", + " stable_matches = 0\n", + " \n", + " for _ in range(num_iterations):\n", + " # Create random preference lists for proposers and acceptors\n", + " proposer_preferences = {team: random.sample(acceptors, len(acceptors)) for team in proposers}\n", + " acceptor_preferences = {team: random.sample(proposers, len(proposers)) for team in acceptors}\n", + " \n", + " # Perform Gale-Shapley matching\n", + " matching = gale_shapley(proposers, acceptors, proposer_preferences, acceptor_preferences)\n", + " \n", + " # Check if the matching is stable\n", + " if is_stable_match(matching, proposer_preferences, acceptor_preferences):\n", + " stable_matches += 1\n", + " \n", + " stability_percentage = (stable_matches / num_iterations) * 100\n", + " return stability_percentage\n", + "\n", + "if __name__ == \"__main__\":\n", + " west_teams = [\"Lakers\", \"Clippers\", \"Suns\", \"Warriors\", \"Jazz\", \"Nuggets\", \"Blazers\", \"Mavericks\"]\n", + " east_teams = [\"Bucks\", \"Nets\", \"76ers\", \"Celtics\", \"Heat\", \"Hawks\", \"Knicks\", \"Raptors\"]\n", + " \n", + " num_iterations = 1000\n", + " \n", + " stability_percentage = calculate_stability_percentage(\n", + " west_teams, east_teams, num_iterations\n", + " )\n", + " \n", + " print(f\"Percentage of stable playoff matches after {num_iterations} iterations: {stability_percentage}%\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "557a0b14-9805-4a48-85ea-ae910d750a97", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of Teams: 8, Execution Time: 0.000000 seconds\n", + "Number of Teams: 16, Execution Time: 0.000000 seconds\n", + "Number of Teams: 32, Execution Time: 0.000000 seconds\n", + "Number of Teams: 64, Execution Time: 0.008048 seconds\n", + "Number of Teams: 128, Execution Time: 0.016365 seconds\n" + ] + } + ], + "source": [ + "import random\n", + "import time\n", + "\n", + "def gale_shapley(proposers, acceptors, proposer_preferences, acceptor_preferences):\n", + " # Initialize empty matching\n", + " matching = {}\n", + " \n", + " # Initialize proposers without partners\n", + " free_proposers = list(proposers)\n", + " \n", + " while free_proposers:\n", + " proposer = free_proposers.pop(0)\n", + " proposer_prefs = proposer_preferences[proposer]\n", + " \n", + " for acceptor in proposer_prefs:\n", + " current_partner = matching.get(acceptor)\n", + " \n", + " if current_partner is None:\n", + " # Acceptor is free, match them with proposer\n", + " matching[acceptor] = proposer\n", + " break\n", + " else:\n", + " # Check if acceptor prefers proposer over current partner\n", + " acceptor_prefs = acceptor_preferences[acceptor]\n", + " if acceptor_prefs.index(proposer) < acceptor_prefs.index(current_partner):\n", + " # Acceptor prefers proposer, unmatch them and match proposer\n", + " matching[acceptor] = proposer\n", + " free_proposers.append(current_partner)\n", + " break\n", + " \n", + " return matching\n", + "\n", + "def generate_teams_and_preferences(num_teams):\n", + " teams = [f\"Team {i}\" for i in range(1, num_teams + 1)]\n", + " preferences = {}\n", + " \n", + " for team in teams:\n", + " other_teams = list(teams)\n", + " other_teams.remove(team)\n", + " random.shuffle(other_teams)\n", + " preferences[team] = other_teams\n", + " \n", + " return teams, preferences\n", + "\n", + "if __name__ == \"__main__\":\n", + " # Initial number of teams\n", + " num_teams = 8\n", + " \n", + " # Number of iterations\n", + " num_iterations = 10\n", + " \n", + " # Measure execution time for different sizes of teams\n", + " for i in range(5):\n", + " teams, preferences = generate_teams_and_preferences(num_teams)\n", + " \n", + " start_time = time.time()\n", + " for _ in range(num_iterations):\n", + " matching = gale_shapley(teams, teams, preferences, preferences)\n", + " end_time = time.time()\n", + " \n", + " execution_time = end_time - start_time\n", + " print(f\"Number of Teams: {num_teams}, Execution Time: {execution_time:.6f} seconds\")\n", + " \n", + " # Double the number of teams for the next iteration\n", + " num_teams *= 2\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6784e53-6b92-42ee-a47a-aba4aaf8fce5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/002722344_Rishi_Raghu/Assignment1.ipynb b/Submissions/002722344_Rishi_Raghu/Assignment1.ipynb new file mode 100644 index 0000000..4187c78 --- /dev/null +++ b/Submissions/002722344_Rishi_Raghu/Assignment1.ipynb @@ -0,0 +1,1186 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 1 (10 points)\n", + "\n", + "There are x research groups at Northeastern University, each focusing in a certain study subject such as HCI, Data Analytics, Bioinformatics, and so on. Each research group has a defined grant amount for supporting research and stipends, as well as a limited number of employment. Your job is to assign n graduate students to these research groups based on particular criteria.\n", + "Students and research groups both have preferences: \n", + "\n", + "- Students prioritize depending on research emphasis, publication prospects, and mentorship quality.\n", + "- Research groups prioritize depending on students' abilities, previous research, academic records, and specialized skill sets. \n", + "\n", + "**Objectives:**\n", + "1. Fills all open research jobs within each group.\n", + "2. Does not exceed the funding amount for any research group.\n", + "3. Match depending on the preferences and skill sets of the students and groups.\n", + "\n", + "**Constraints:**\n", + "\n", + "- The number x denotes the number of research groups.\n", + "- n denotes the total number of graduate students.\n", + "- Each research group has a finite number of open slots y, where y>0.\n", + "- Each student possesses a non-negligible set of talents.\n", + "- To be considered for a post, each research group may require one or more abilities.\n", + "\n", + "**Common Input and Output Formats:**\n", + "\n", + "*-Input:* Lists of students' choices, stipend needs, and skill sets, followed by lists of research groups' preferences, grant amounts, and necessary skills.\n", + "\n", + "*-Output:* A stable list of student-research group matching that complies to funding and skill set requirements.\n", + "\n", + "Derive an algorithm to create stable matching between the students and research groups. Write a pseudocode and explain the time complexity of the algorithm used.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Solution - Question 1**\n", + "\n", + "The problem is an extension of the Stable Marriage problem, and we can solve it using a modified Gale-Shapley algorithm. Checking for grant amount limits and ensuring that students have the necessary abilities for a certain research group are among the modifications.\n", + "\n", + "### Pseudocode\n", + "\n", + "```plaintext\n", + "Initialize all students as \"unmatched\"\n", + "Initialize all research groups as \"not full\" and their grant amount to the initial grant available\n", + "Create empty lists to hold matches for each research group\n", + "\n", + "while there is an \"unmatched\" student who has not proposed to every research group:\n", + " student = first unmatched student who has not proposed to every group\n", + " group = first group on student's list to which he/she has not yet proposed to\n", + " \n", + " if group is \"not full\":\n", + " if student has required skills for group:\n", + " if grant_left_in_group >= student's stipend demand:\n", + " Add student to group's list\n", + " Mark student as \"matched\"\n", + " Decrease group's remaining grant by student's stipend demand\n", + " if group's positions are filled:\n", + " Mark group as \"full\"\n", + " else:\n", + " if student has required skills for group:\n", + " if grant_left_in_group >= student's stipend demand:\n", + " worst_matched_student = worst-matched student currently in group according to group's preference\n", + " if group prefers student over worst_matched_student:\n", + " Remove worst_matched_student from group\n", + " Add student to group\n", + " Mark worst_matched_student as \"unmatched\"\n", + " Mark student as \"matched\"\n", + " Update group's remaining grant\n", + "```\n", + "\n", + "### Analysis of Time Complexity\n", + "\n", + "1. Each student may be required to make a proposal to each of the x research groups: *O(n x) = *O(n x)*\n", + "2. In each proposal, we may need to determine whether a student possesses the necessary abilities for the group. This check might take up to *O(5)* seconds: *O(5) = O(1)*\n", + "3. We may also need to check the worst-matched student in a research group for each proposal, which can require *O(y)*, where y is the number of places in the group: *O(y) = O(y)*\n", + "\n", + "As a result, the overall time complexity is *O(n * x * 1 * y)* = *O(n * x * y)*.\n", + "\n", + "Take note that x represents the number of research groups, n represents the number of students, and y represents the maximum number of slots in any group." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Justification and Proof of Correctness - Question 1**\n", + "\n", + "Proving the correctness of an algorithm generally involves demonstrating that it fulfills specific qualities or requirements that identify a \"correct\" answer. We want to prove two key features of the improved Gale-Shapley algorithm:\n", + "\n", + "- **Stability**: There should be no motivation for any student or research group to break their allocated matching to pair with each other.\n", + "- **Feasibility**: All limitations, such as skills, stipend expectations, and grant amounts, must be met.\n", + "\n", + "#### Proof of Stability\n", + "\n", + "For Students:\n", + "\n", + "- A student will submit study groups in their preferred sequence. \n", + "- A student will never be transferred from a higher favored group to a less preferred group. \n", + "- As a result, once matched, a student has little reason to depart from the designated group because they are in the greatest possible position.\n", + "\n", + "For Research Groups:\n", + "\n", + "- A group will only replace a current match if the new student is preferred. When a group is full, any replacement keeps or enhances the group's preference list.\n", + "- As a result, a research group has no incentive to break the existing matching for a different, less desirable student.\n", + "\n", + "#### Proof of Feasibility\n", + "\n", + "- Before making any matches, the skill sets are verified. As a result, no student is in a group who does not possess the necessary abilities. Before matching, the stipend is reviewed and taken from the group's funding, guaranteeing that the group can afford all of its matches.\n", + "\n", + "#### Inductive Proof of Correctess \n", + "\n", + "- Base Case (n=0): No one is matched when the process starts, which is a valid condition of the system. Thus it holds for n=0.\n", + "- Inductive Hypothesis(n=k): Assuming that the procedure holds for n=k, all students and groups are stably and feasibly matched after k iterations.\n", + "\n", + "- Inductive Step(n=k+1): Consider iteration k+1.\n", + "\n", + " - If a student is matched, they are assigned to the most favored group that has not yet rejected them, for which they have the necessary abilities and may be supported by the group's remaining grant. \n", + " - If a group gets full or has to replace a less favored student, it replaces him or her with a more preferred one, ensuring stability.\n", + " - This also indicates that if the group discovered the most preferred student in the k+1 iteration, the less preferred student would have been replaced in the k iteration. As a result, the procedure works for n=k+1.\n", + "\n", + "Therefore the modified gale-shapely algorithm used here is proven to be stable, viable, and complete. As a result, it is a viable solution to the problem." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 2 (10 points)\n", + "\n", + "To answer the problem statement, you are given a function called *OptimalVendorPairing*.\n", + "\n", + "*OptimalVendorPairing()*\n", + "\n", + "- *Input:* A collection of *n* food trucks and *n* well-known sites. Each food truck has a rating list of all *n* locations, and each location has a ranking list of all *n* food trucks.\n", + "- *Result:* A consistent matching of food trucks and places.\n", + "\n", + "You are in charge of organizing *n* art events as well as *n* food trucks. Each art event necessitates the use of one food truck. Both the events and the food trucks, however, have their own set of criteria: Some food trucks may be \"incompatible\" with an art event owing to space limits, noise level, or cuisine type. Similarly, some art events may be \"incompatible\" with a food truck owing to a lack of audience engagement, parking constraints, or event duration.\n", + "\n", + "In this context, an allocation is deemed \"stable\" if and only if the following conditions are met:\n", + "\n", + "- No food truck is assigned to an art event deemed incompatible.\n", + "- No art event is assigned a food truck with which it is incompatible.\n", + "- There are no unallocated food truck-art event partners that are compatible and would favor each other above their current allocation. \n", + "\n", + "**Typical Input and Output Format:**\n", + "\n", + "*-Input:* \n", + "- artEvents: A collection of *n* art events.\n", + "- foodTrucks: An inventory of *n* food trucks.\n", + "- eventPrefs: Each art event's food truck preference list may include both approved and unsuitable options.\n", + "- truckPrefs: Each food truck's their preference list of art events, could contain both acceptable and unacceptable choices.\n", + "- eventUnfit: A collection of *n* lists, each having boolean values indicating if the related food trucks are undesirable to an art event.\n", + "- truckUnfit: A collection of *n* lists, each with boolean values indicating if a food truck considers the related art events undesirable.\n", + "\n", + "*-Output:* - matchings: A list of *n* tuples, each of which contains an art event and the food truck with which it is paired. If no art event is paired, it is displayed as None. \n", + "\n", + "Note: Due to the notion of \"incompatible\" selections, it is not required to allocate every food truck un order to have a stable system.The preference lists may include both acceptable and unacceptable choices.\n", + "\n", + "(a) Given *n* art events and *n* food trucks, each with its own set of preferences and incompatible options, Create an algorithm and explain how you may use it to identify a stable pairing using *OptimalVendorPairing*.\n", + "\n", + "(b) Calculate the execution time of your suggested method. Assume that OptimalVendorPairing has a runtime of O(n^2) for an input containing *n* art events and *n* food trucks." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Solution - Question 2**\n", + "\n", + "**(a) Pseudo-code**\n", + "\n", + "Pseudo-code for the algorithm that handles stable pairings of art events and food trucks:\n", + "\n", + "```plaintext\n", + "Algorithm StableEventTruckPairing(artEvents, foodTrucks, eventPrefs, truckPrefs, eventUnfit, truckUnfit)\n", + " \n", + " // Step 1: Preprocessing to Remove Incompatible Choices\n", + " Declare cleanedEventPrefs as empty list\n", + " Declare cleanedTruckPrefs as empty list\n", + "\n", + " For i from 0 to length(artEvents) - 1:\n", + " Declare tempList as empty list\n", + " For j from 0 to length(foodTrucks) - 1:\n", + " If eventUnfit[i][j] is False:\n", + " Append eventPrefs[i][j] to tempList\n", + " End For\n", + " Append tempList to cleanedEventPrefs\n", + " End For\n", + "\n", + " For i from 0 to length(foodTrucks) - 1:\n", + " Declare tempList as empty list\n", + " For j from 0 to length(artEvents) - 1:\n", + " If truckUnfit[i][j] is False:\n", + " Append truckPrefs[i][j] to tempList\n", + " End For\n", + " Append tempList to cleanedTruckPrefs\n", + " End For\n", + "\n", + " // Step 2: Call to OptimalVendorPairing Function\n", + " matchings = OptimalVendorPairing(artEvents, foodTrucks, cleanedEventPrefs, cleanedTruckPrefs)\n", + "\n", + " // Step 3: Postprocessing for Unallocated Events or Trucks\n", + " Declare finalMatchings as empty list\n", + "\n", + " For each tuple in matchings:\n", + " If tuple contains None:\n", + " Append None to finalMatchings\n", + " Else:\n", + " Append tuple to finalMatchings\n", + " End If\n", + " End For\n", + "\n", + " Return finalMatchings\n", + "\n", + "End Algorithm\n", + "```\n", + "\n", + "**(b) Estimating Runtime**\n", + "\n", + "1. Preprocessing: It would take O(n^2) time to go through each art event and food truck and update their preference lists.\n", + "\n", + "2. OptimalVendorPairing Call: The OptimalVendorPairing() method has an O(n^2) runtime, according to the issue statement.\n", + "\n", + "3. Postprocessing Step: Going over each tuple in the matchings list will likewise require O(n) time.\n", + "\n", + "As a result, the overall runtime is O(n^2) for preprocessing + O(n^2) for OptimalVendorPairing + O(n) for postprocessing = O(n^2).\n", + "\n", + "Because O(n^2) is the determining factor here, the overall runtime complexity of the proposed approach is O(n^2).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Justification and Proof of Correctness - Question 2**\n", + "\n", + "**Pre-Conditions and Assumptions**\n", + "- When given any set of preference lists, OptimalVendorPairing is presumed to be valid and stable.\n", + "- The eventUnfit and truckUnfit lists can identify incompatible options entirely and accurately.\n", + "\n", + "**Proof of Correctness**\n", + "\n", + "*Step 1: Preprocessing*\n", + "\n", + "The cleaned-up preference lists (cleanedEventPrefs and cleanedTruckPrefs) will only include compatible selections after preprocessing.\n", + "\n", + "*Proof:*\n", + "\n", + "- In eventPrefs and truckPrefs, we cycle over each list, deleting choices indicated as incompatible in eventUnfit and truckUnfit. As a result, all of the remaining options in cleanedEventPrefs and cleanedTruckPrefs are by definition compatible.\n", + "\n", + "*Part 2: Application of OptimalVendorPairing*\n", + "\n", + "OptimalVendorPairing will generate a consistent matching when applied to the cleaned-up preference lists.\n", + "\n", + "*Proof:*\n", + "\n", + "- Because of the preprocessing, the input preference lists only include suitable options.\n", + "- It is expected that OptimalVendorPairing is valid and creates stable pairings.\n", + "- As a result, depending on the definitions supplied in the issue description, the output should be a stable matching.\n", + "\n", + "*Step 3: Postprocessing*\n", + "\n", + "Claim: Any mismatched (None) elements in the matching list are unavoidable and do not jeopardize the system's stability.\n", + "\n", + "*Proof:*\n", + "\n", + "- Any \"None\" entries are the consequence of not being able to identify an appropriate and preferable option for a certain art event or food truck. This signifies that these items do not violate stability because there are no better or acceptable alternatives." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 3 (20 points)\n", + "\n", + "(a) Construct an undirected graph as described on the right, using an adjacency matrix named \"Adj\". This matrix should be implemented as a direct access array set. The vertices are labeled from 0 to 5. For each vertex u in the set {0,1,2,3,4,5}{0,1,2,3,4,5}, Adj[u] will represent its adjacency list. The adjacency lists themselves should also be implemented as direct access array sets. An element Adj[u][v] should be set to 1 if there is an edge connecting vertices u and v. [5 points]\n", + "\n", + "Adjacency Matrix (Adj):\n", + "\n", + "![Adjacency Matrix](image.png)\n", + "\n", + "(b) Write down the adjacency list representation of the graph below by using Python's Dictionary structure, where each node v has its list of adjacent nodes Adj[v]Adj[v]. Here, Adj[v]Adj[v] should be a Python List that contains the nodes connected to v, sorted in alphabetical sequence. [5 points]\n", + "\n", + "![Graph](image-4.png)\n", + "\n", + "(c) Execute both Breadth-First Search (BFS) and Depth-First Search (DFS) on the graph illustrated in part (b). Initiate your search at node A. Visit the adjacent nodes of each vertex in alphabetical sequence. Draw the tree such that each algorithm would construct and enumerate the nodes in the sequence they were initially discovered. [5 points]\n", + "\n", + "(d) It is conceivable to disconnect one edge from the graph in part (b) so that the graph transforms into a Directed Acyclic Graph (DAG). Identify every edge that possesses this characteristic. Additionally, for each of these edges, specify the resulting topological sequence for the modified graph. [5 points]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Solution - Question 3**\n", + "\n", + "(a) The adjacency matrix Adj represents an undirected graph with vertices labeled from 0 to 5. In this matrix, Adj[u][v] = 1 signifies that there's an edge between vertex u and vertex v.\n", + "\n", + "Let's interpret the given adjacency matrix:\n", + "\n", + "- Vertex 0 is connected to Vertex 2.\n", + "- Vertex 1 is connected to Vertices 3, 4, and 5.\n", + "- Vertex 2 is connected to Vertices 0, 3, and 4.\n", + "- Vertex 3 is connected to Vertices 1 and 2.\n", + "- Vertex 4 is connected to Vertices 1, 2, and 5.\n", + "- Vertex 5 is connected to Vertices 1 and 4.\n", + "\n", + "![Graph](image-5.png) \n", + "\n", + "(b) The adjacency list representation in Python Dictionary form is as follows:\n", + "\n", + "Adj = { \n", + " 'A': ['B'], \n", + " 'B': ['C', 'D'], \n", + " 'C': ['E', 'F'], \n", + " 'D': ['E', 'F'], \n", + " 'E': [], \n", + " 'F': ['D'] \n", + "}\n", + "\n", + "(c) \n", + "In a Breadth-First Search (BFS), nodes at the same depth are visited before moving to the next depth level. Depth-First Search (DFS) explores as deeply as possible before backtracking.\n", + "\n", + "BFS: \n", + "- Starting from node 'A', you visit its only neighbor 'B'. Then, from 'B', you go on to visit its neighbors 'C' and 'D'. Once at 'C', you visit 'E' and 'F'. \n", + "- By the time you reach 'D', you find that its neighbors 'E' and 'F' are already visited, so you don't add anything new to the BFS tree.\n", + "\n", + "DFS: \n", + "- You start at 'A', go to 'B', then to 'C', and keep going until you hit a leaf node or revisit a node. Starting from 'A', you first explore 'B', then move to 'C'. \n", + "- 'C' leads you to 'E', a leaf node. You backtrack to 'C' and then go to 'F'. \n", + "- From 'F', you can move to 'D', which hasn't been visited yet.\n", + "\n", + "BFS [A, B, C, D, E, F]\n", + "\n", + "![BFS Tree](image-6.png)\n", + "\n", + "DFS [A, B, C, E, F, D]\n", + "\n", + "![DFS Tree](image-7.png)\n", + "\n", + "(d) In this graph, there's a cycle involving vertices 'D' and 'F'. A Directed Acyclic Graph (DAG) doesn't have any cycles. Therefore, to convert the graph into a DAG, you can remove either edge (D, F) or (F, D). This breaks the cycle, making the graph acyclic.\n", + "\n", + "- Removing edge (D, F) leaves you with a unique topological ordering: (A, B, C, F, D, E).\n", + "- Removing edge (F, D) gives you two possible topological orderings: (A, B, C, D, F, E) and (A, B, D, C, F, E).\n", + "\n", + "In a DAG, a topological ordering is a linear ordering of its vertices such that for every directed edge (u, v), vertex u comes before v in the ordering. Once the graph becomes a DAG, you can safely perform topological sorting." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Justification and Proof of Correctness - Question 3**\n", + "\n", + "(a) Adj = [ \n", + " [0, 0, 1, 0, 0, 0], \n", + " [0, 0, 0, 1, 1, 1], \n", + " [1, 0, 0, 1, 1, 0], \n", + " [0, 1, 1, 0, 0, 0], \n", + " [0, 1, 1, 0, 0, 1], \n", + " [0, 1, 0, 0, 1, 0] \n", + " ]\n", + "\n", + "The adjacency list was generated by deriving it from the adjacency matrix. We went over the matrix row by row for each vertex u. If Adj[u][v]=1, we added v to the list of u's adjacencies.\n", + "\n", + "Ensuring that v appears in the adjacency list of u for any Adj[u][v]=1 in the matrix. Based on the provided matrix, we can see that for every 1 in the adjacency matrix, the corresponding vertex is included in the adjacency list of the row's vertex. This demonstrates that the adjacency list representation is an accurate representation of the adjacency matrix. As a result, the adjacency matrix appropriately represents the undirected graph.\n", + "\n", + "(b)\n", + "- Node A: It has only one edge to B. In the adjacency list, this is appropriately written as 'A': ['B']. \n", + "- Node B: It has edges to Nodes C and D. This is expressed in the adjacency list as 'B': ['C', 'D']. \n", + "- Node C: It has edges to Nodes E and F. In the adjacency list, this corresponds to 'C': ['E', 'F']. \n", + "- Node D: It has edges to E and F, which are represented in the adjacency list as 'D': ['E', 'F']. \n", + "- Node E: It has no outgoing edges, which is indicated by an empty list 'E': []. \n", + "- Node F: It has an edge to D, which is appropriately represented in the adjacency list as 'F': ['D'].\n", + "\n", + "*Note: As can be seen from the preceding representation, every directed edge in the graph from node u to node v is represented precisely once in the adjacency list for u. Furthermore, nodes with no outgoing edges are represented by an empty list, suggesting that they are not accessible from any other vertices. As a result, all of the graph's directed edges are precisely captured*.\n", + "\n", + "(c)\n", + "\n", + "BFS and DFS claim:\n", + "\n", + "Starting with node 'A,' we'll explore all nodes accessible from 'A' precisely once, capturing the most efficient (shortest) path in BFS and examining all related branches in DFS.\n", + "\n", + "Justification:\n", + "\n", + "- Starting Point - Initialization: For both strategies, we begin with node 'A' because it is our beginning point. Our \"visited list\" currently comprises only 'A' in both BFS and DFS.\n", + "\n", + "- Next Steps - Exploration and Reversal:\n", + "\n", + " - BFS: From 'A,' we search immediate neighbors first, which is 'B' in this case. When we \"move\" to 'B,' we examine its neighbors, 'C' and 'D,' and so on. To eliminate redundancy, we avoid accessing a node twice.\n", + "\n", + " - DFS: Starting with 'A,' we consider its neighbor 'B,' but then proceed along this branch as far as feasible (to 'C' then 'E' and 'F') before returning. We do not visit a node twice in this operation. If we come upon one, we either investigate deeper or go backwards.\n", + "\n", + "- Stop Point - Conclusion of the Process:\n", + "\n", + " - For both BFS and DFS, we can end the process when there are no new nodes to evaluate. We've visited every node accessible from 'A' precisely once by this stage.\n", + "\n", + "We're effectively performing what the formal algorithm does by following these steps. As a result, in both BFS and DFS, each node is visited precisely once and chooses the most efficient path.\n", + "\n", + "(d)\n", + "\n", + "Claim: Removing either edge (D, F) or (F, D) yields a Directed Acyclic Graph (DAG), and the topological orderings supplied are valid.\n", + "\n", + "Proof:\n", + "\n", + "- Acyclicity: There is only one cycle between 'D' and 'F' in the original graph. Removing either edge (D, F) or (F, D) breaks this cycle, resulting in an acyclic graph and hence a DAG.\n", + "\n", + "- Topological Ordering: \n", + " - When edge (D, F) is deleted, the only topological ordering that remains is (A, B, C, F, D, E).\n", + " - When edge (F, D) is deleted, there are two potential topological orderings: (A, B, C, D, F, E) and (A, B, D, C, F, E).\n", + "\n", + "These orderings meet the topological ordering condition: if a directed edge (u, v) exists, then u is ordered before v." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 4 (10 points)\n", + "\n", + "For each group of functions, sort each group of functions in the order of increasing order growth in terms of computational complexity. \n", + "\n", + "Set 1: Linear, Logarithmic, and Power Functions (Check for higher values of n i.e n>500) ) [5 points]\n", + "\n", + "\\begin{align*}\n", + "f1(n) &= 3n^{0.7} \\log n \\\\\n", + "f2(n) &= n (\\log n)^{0.5} \\\\\n", + "f3(n) &= 5n\\log n \\\\\n", + "f4(n) &= n^{2} \\\\\n", + "f5(n) &= (0.9)^n n^2\n", + "\\end{align*}\n", + "\n", + "\n", + "Set 2: Polynomial and Exponential Functions [5 points]\n", + "\n", + "\\begin{align*}\n", + "f1(n) &= n^3 (log n) \\\\\n", + "f2(n) &= 10n (log^2 n) \\\\\n", + "f3(n) &= n^2 1.5^n \\\\\n", + "f4(n) &= n^2 2^{\\log n} \\\\\n", + "f5(n) &= {3^n}\n", + "\\end{align*}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### **Solution - Question 4**\n", + "\n", + "(a)\n", + "\n", + "\\begin{align*}\n", + "\\hspace{0pt} f5(n) &\\hspace{0pt} < f1(n) < f2(n) < f3(n) < f4(n)\\\\\n", + "\\\\\n", + "\\hspace{0pt} O((0.9)^n n^2) &\\hspace{0pt} < O(n^{0.7} \\log n) < O(n (\\log n)^{0.5}) < O(5n\\log n) < O(n^{2})\n", + "\\end{align*}\n", + "\n", + "(b)\n", + "\n", + "\\begin{align*}\n", + "\\hspace{0pt} f2(n) &\\hspace{0pt} < f4(n) < f1(n) < f3(n) < f5(n)\\\\\n", + "\\\\\n", + "\\hspace{0pt} O(nlog^2n) &\\hspace{0pt} < O(n^{3}) < O(n^3 logn) < O(n^2 1.5^n) < O(3^n)\n", + "\\end{align*}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Justification and Proof of Correctness - Question 4**\n", + "\n", + "(a)\n", + "\n", + "*Justification*\n", + "\n", + "- f5 is dominated by (0.9)^n, which is an exponential decay. For large nn, it approaches zero, making it the slowest-growing function.\n", + "- f1 has a sub-linear growth n^0.7 combined with a logarithmic growth log⁡nlogn. It grows slower than linear-logarithmic but faster than logarithmic functions.\n", + "- f2 grows linearly in nn but has a slower-growing logarithmic term log⁡n^0.5. It grows faster than f1(n) due to the linear term n.\n", + "- f3 a linear-logarithmic function. It grows faster than both f1(n) and f2(n), but not as fast as quadratic or higher-degree polynomial functions.\n", + "- f4 grows quadratically, which is the fastest-growing among the list of functions for large n.\n", + "\n", + "*Graph Plotting*\n", + "\n", + "![Part(a) Computational Complexity Graph](image-8.png)\n", + "\n", + "(b)\n", + "\n", + "*Justification*\n", + "- f2(n) combines a linear term with a squared logarithmic term, making it the slowest-growing function in the set.\n", + "- f4(n) simplifies to a cubic term n^3, faster than f2(n) but slower than the remaining functions.\n", + "- f1(n) enhances a cubic term with a logarithmic multiplier, placing it ahead of f4(n) but behind exponential functions.\n", + "- f3(n) combines a quadratic term with an exponential one, resulting in a faster growth than cubic but slower than pure exponential functions.\n", + "- f5(n) is a pure exponential function with a base of 3, making it the fastest-growing function in this set\n", + "\n", + "*Graph Plotting*\n", + "\n", + "![Part(b) Computational Complexity Graph ](image-9.png)\n", + "![Part(b) Computational Complexity Graph](image-10.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 5 (25 points)\n", + "\n", + "**Problem Statement**\n", + "\n", + "Alex, a NUTech Solutions recruiter, has the annual difficulty of linking interns with mentors. Alex is fascinated by the Gale-Shapley algorithm and wonders if a modified version may provide a more fair matching system that takes into consideration diverse difficulties. It is your responsibility to modify the Gale-Shapley method to these real-world settings using Python functions. ***Please refer to Ques5_Coding.py for the starter code template***\n", + "\n", + "(a) Due to competence variations, not all mentors can help interns on all projects. varying mentors specialize in various areas, while interns have varying skill preferences. [10 points]\n", + "\n", + "Make a Python method called *create_skill_based_preferences(mentors, interns)* that will generate first preference lists based on matching talents.\n", + "\n", + "- Input: Two dictionaries lists for mentors and interns. Each dictionary has a 'name' and a'skills' list.\n", + "- Output: Two lists of mentor and intern choice lists based on skill compatibility.\n", + "\n", + "(b) Use the Gale-Shapley algorithm to discover stable pairings of mentors and interns based on their preferences.[10 points]\n", + "\n", + "Make a Python method called *find_stable_matching(mentor_preferences, intern_preferences)* that identifies the stable pairing based on the preferences derived from the preceding task.\n", + "- Input:\n", + " - mentor_preferences: A dictionary with mentor names as keys and lists of intern names sorted by preference as values.\n", + " - intern_preferences: A dictionary with intern names as keys and lists of mentor names sorted by preference as values.\n", + "\n", + "- Output: A dictionary containing stable matches with the mentor as the key and the intern as the value.\n", + "\n", + "(c) Occasionally, following matching, we get feedback from either interns or mentors that they are unhappy with the pairing for reasons that were not addressed in the initial skill-based matching. These might be owing to factors such as geography, time, or project alignment.[5 points]\n", + "\n", + "Your objective is to develop a function that accepts the stable pairings, a list of \"unhappy\" mentors, and a list of \"unhappy\" interns, and produces a new set of stable pairs after deleting the given unstable pairs.\n", + "\n", + "- Input\n", + " - stable_pairs: A dictionary containing stable pairs of mentors and interns.\n", + " - String mentor name as a key\n", + " - String value for intern name\n", + " - unhappy_mentors: A list of mentor names (strings) that are unhappy with their pairing.\n", + " - unhappy_interns: A list of intern names (strings) that are unhappy with their pairing. \n", + " \n", + "- Output - A dictionary containing new stable pairings once the unstable pairs have been removed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Solution - Question 5**\n", + "\n", + "(a)\n", + "\n", + "```python\n", + "def create_skill_based_preferences(mentors, interns):\n", + " mentor_pref = {}\n", + " intern_pref = {}\n", + " \n", + " # Loop through mentors to create their preference lists\n", + " for mentor in mentors:\n", + " mentor_name = mentor['name']\n", + " mentor_skills = set(mentor['skills'])\n", + " mentor_pref[mentor_name] = []\n", + " \n", + " # Sort interns based on the number of matching skills\n", + " for intern in sorted(interns, key=lambda x: len(mentor_skills.intersection(set(x['skills']))), reverse=True):\n", + " intern_name = intern['name']\n", + " if len(mentor_skills.intersection(set(intern['skills']))) > 0:\n", + " mentor_pref[mentor_name].append(intern_name)\n", + "\n", + " # Loop through interns to create their preference lists\n", + " for intern in interns:\n", + " intern_name = intern['name']\n", + " intern_skills = set(intern['skills'])\n", + " intern_pref[intern_name] = []\n", + " \n", + " # Sort mentors based on the number of matching skills\n", + " for mentor in sorted(mentors, key=lambda x: len(intern_skills.intersection(set(x['skills']))), reverse=True):\n", + " mentor_name = mentor['name']\n", + " if len(intern_skills.intersection(set(mentor['skills']))) > 0:\n", + " intern_pref[intern_name].append(mentor_name)\n", + "\n", + " return mentor_pref, intern_pref\n", + "```\n", + "(b)\n", + " \n", + "```python\n", + "def find_stable_matching(mentor_preferences, intern_preferences):\n", + " unassigned_interns = list(intern_preferences.keys())\n", + " mentor_current = {} # Current matchings for mentors\n", + " intern_current = {} # Current matchings for interns\n", + " mentor_next_proposal = {mentor: 0 for mentor in mentor_preferences} # Next proposal index for each mentor\n", + "\n", + " while unassigned_interns:\n", + " intern = unassigned_interns.pop(0)\n", + " preferred_mentors = intern_preferences[intern]\n", + " \n", + " for mentor in preferred_mentors:\n", + " if mentor not in mentor_current: # Mentor is unassigned\n", + " mentor_current[mentor] = intern\n", + " intern_current[intern] = mentor\n", + " break\n", + " else: # Mentor is already assigned\n", + " current_intern = mentor_current[mentor]\n", + " if mentor_preferences[mentor].index(intern) < mentor_preferences[mentor].index(current_intern): # New intern is preferred\n", + " mentor_current[mentor] = intern\n", + " intern_current[intern] = mentor\n", + " if current_intern in intern_current:\n", + " del intern_current[current_intern]\n", + " unassigned_interns.append(current_intern) # Reassign previous intern\n", + " break\n", + "\n", + " return mentor_current\n", + "```\n", + "(c)\n", + "\n", + "```python\n", + "def remove_unstable_pairs(stable_pairs, unhappy_mentors, unhappy_interns):\n", + " new_stable_pairs = {}\n", + " \n", + " for mentor, intern in stable_pairs.items():\n", + " if mentor not in unhappy_mentors and intern not in unhappy_interns:\n", + " new_stable_pairs[mentor] = intern\n", + " \n", + " return new_stable_pairs\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Correctness Proof with Test Cases - Question 5**\n", + "\n", + "The code solution was tested and confirmed for the following test cases:\n", + "\n", + "1. Handle empty lists of mentors and interns.\n", + "2. All mentors and interns have identical skills.\n", + "3. All mentors and interns have mutual first-choice preferences.\n", + "4. Multiple iterations required to find a stable match.\n", + "5. All mentors and interns are unhappy with their initial pairings.\n", + "6. Some mentors and interns are unhappy with their initial pairings.\n", + "\n", + "Example usage is given along with code implementation in the file **Ques5_Sol.py**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 6 (25 points)\n", + "\n", + "**Problem Statement**\n", + "\n", + "You are a member of a smart city project's traffic department. The city is represented as a graph, with junctions acting as nodes and roads acting as edges. Your mission is to create algorithms that assist drivers and the traffic department in a variety of ways.***Please refer to Ques6_Coding.py for the starter code template***:\n", + "\n", + "(a) Emergency Vehicle Routing (BFS) [5 points]\n", + "\n", + "Ambulances and fire departments, for example, must get at their locations as quickly as possible. Create a function shortest_path(graph: dict, start: str, end: str) that accepts a city graph and a starting and finishing intersection and returns the shortest path from the beginning to the end.\n", + "\n", + "- Input\n", + "\n", + " - graph: A dictionary with intersection names as keys and lists of surrounding junctions as values.\n", + " - start: As a string, the first intersection.\n", + " - end: The string representing the last intersection. \n", + " \n", + "- Output\n", + "\n", + " - A list of intersection names in the order they should be followed to get from start to finish in the shortest amount of time.\n", + "\n", + "\n", + "(b) Road Maintenance Scheduling (DFS) [5 points]\n", + "\n", + "The city is planning road repair and wants to guarantee that every route is pothole-free. They want to execute this in the most efficient way possible, with each intersection/node visited exactly once if feasible. To discover such a path, create a Python function maintenance_path(graph: dict, start: str) -> list.\n", + "\n", + "- Input\n", + "\n", + " - graph: A dictionary with intersection names as keys and lists of surrounding junctions as values.\n", + " - start: As a string, the first intersection.\n", + "\n", + "- Output\n", + "\n", + " -A list of intersection names, arranged in the order in which they should be traveled for effective road inspection. If there are many pathways, return any of them.\n", + "\n", + "\n", + "(c) Safest Route (BFS with Weighted Edges) [7 points]\n", + "\n", + "Each road now has a safety grade assigned to it. The city council wants to know the best way to get from one location to another. The \"safest\" route is defined for this problem as the one having the highest total of safety ratings along its path.\n", + "\n", + "Write a Python method safest_path(graph: dict, start: str, end: str) -> list that searches for the safest path using BFS.\n", + "\n", + "- Input:\n", + " - graph: A dictionary with intersection names as keys and dictionaries with surrounding intersections and their safety rating as values.\n", + " - start: As a string, the first intersection.\n", + " - end: As a string, the destination intersection.\n", + "\n", + "- Output: \n", + " - A list of junction names that reflect the safest path from start to finish based on the total of safety ratings. Returning any is allowed if many pathways exist with the same greatest sum.\n", + "\n", + "- Constraints: \n", + " - Safety ratings are positive integers.\n", + " - If the safest route is a tie based on the total of safety ratings, any route is acceptable.\n", + "\n", + "(d) Minimum Stops to Refuel (BFS) [8 points]\n", + "\n", + "Given that each car has enough charge to go directly from one junction to any nearby intersection, you must discover the path from a beginning point to an endpoint with the fewest charging stops. This is crucial since fewer stops imply shorter charging lines and smoother traffic flow, encouraging the usage of electric vehicles and contributing to the city's environmental goals.\n", + "\n", + "Write a Python method called min_charging_stops(graph, start, finish, stations) to identify the path with the fewest charging stops.\n", + "\n", + "- Input:\n", + " - graph: A dictionary with intersection names as keys and lists of surrounding junctions as values.\n", + " - start: As a string, the first intersection.\n", + " - end: As a string, the destination intersection.\n", + " - stations: A list of intersections where charging stations are present.\n", + "\n", + "- Output:\n", + " - A list of intersection names from start to end that minimizes the number of charging stops.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Solution - Question 6**\n", + "\n", + "(a)\n", + "\n", + "```python\n", + "def shortest_path(graph, start, end):\n", + " visited = set()\n", + " queue = deque([(start, [start])])\n", + "\n", + " while queue:\n", + " current_intersection, path = queue.popleft()\n", + " if current_intersection == end:\n", + " return path\n", + " visited.add(current_intersection)\n", + " \n", + " for neighbor in graph[current_intersection]:\n", + " if neighbor not in visited:\n", + " new_path = list(path)\n", + " new_path.append(neighbor)\n", + " queue.append((neighbor, new_path))\n", + "```\n", + "\n", + "(b)\n", + "\n", + "```python\n", + "def maintenance_path(graph, start):\n", + " visited = set()\n", + " path = []\n", + "\n", + " def dfs(current_intersection):\n", + " visited.add(current_intersection)\n", + " path.append(current_intersection)\n", + " for neighbor in graph[current_intersection]:\n", + " if neighbor not in visited:\n", + " dfs(neighbor)\n", + "\n", + " dfs(start)\n", + " return path\n", + "```\n", + "\n", + "(c)\n", + "\n", + "```python\n", + "def safest_path(graph, start, end):\n", + " candidates = [(0, start, [])]\n", + " visited = set()\n", + " \n", + " while candidates:\n", + " candidates.sort(reverse=True) # Sort by safety, descending\n", + " safety_sum, current, path = candidates.pop(0) # Get the safest route\n", + " \n", + " if current in visited:\n", + " continue\n", + " visited.add(current)\n", + " \n", + " path = path + [current]\n", + " \n", + " if current == end:\n", + " return path\n", + " \n", + " for neighbor, safety in graph[current].items():\n", + " if neighbor not in visited:\n", + " new_safety_sum = safety_sum + safety\n", + " candidates.append((new_safety_sum, neighbor, path))\n", + " \n", + " return \"Not possible\"\n", + "```\n", + "\n", + "(d)\n", + "\n", + "```python\n", + "def min_charging_stops(graph, start, end, stations):\n", + " visited = set()\n", + " queue = deque([(start, [start], 0)]) # Node, Path, Stops\n", + "\n", + " while queue:\n", + " current_node, path, stops = queue.popleft()\n", + " visited.add(current_node)\n", + "\n", + " # If we reach the destination, return the path\n", + " if current_node == end:\n", + " return path\n", + "\n", + " for neighbor in graph[current_node]:\n", + " if neighbor not in visited:\n", + " new_stops = stops\n", + " # If there is a charging station at the neighbor, reset the stops counter\n", + " if neighbor in stations:\n", + " new_stops += 1\n", + " # Add the neighbor node to the queue for future processing\n", + " queue.append((neighbor, path + [neighbor], new_stops))\n", + "\n", + " # If a path is not found\n", + " return None\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### **Correctness Proof with Test Cases - Question 6**\n", + "\n", + "The code solution for all the parts were tested and confirmed with multiple edge cases and constraints according to the question test cases:\n", + "\n", + "- Test Case 1: Basic Graph with a Loop\n", + "- Test Case 2: Graph with Multiple Branching Paths\n", + "- Test Case 3: More Complex Graph with Unique multiple Path\n", + "- Test Case 4: Small-Scale Grid Path\n", + "- Test Case 5: Simple Four-Node Graph\n", + "- Test Case 6: Graph with Isolated Intersections\n", + "\n", + "Example usage is given along with code implementation in the file **Ques6_Sol.py**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 7 (10 points)\n", + "\n", + "Analyze the following code snippets and determine the overall time complexity of each.\n", + "\n", + "(a)\n", + "\n", + "This search_emails function filters a list of emails (emails) based on a list of target keywords (targets). It iterates through the 'subject' and 'body' of each email, appending matching emails to a found_emails list before returning it\n", + "\n", + "```python\n", + "def search_emails(emails, targets):\n", + " found_emails = []\n", + " for email in emails: \n", + " for target in targets: \n", + " if target in email['subject'] or target in email['body']:\n", + " found_emails.append(email)\n", + " break\n", + "return found_emails\n", + "```\n", + "(b)\n", + "\n", + "This find_mutual_friends function identifies mutual friends and shared interests between two users (user1_data and user2_data). It iterates through the 'friends' and 'interests' fields of both users' data, appending matching pairs to a mutuals list before returning it.\n", + "\n", + "```python\n", + "def find_mutual_friends(user1_data, user2_data):\n", + " mutuals = []\n", + " for friend in user1_data['friends']: # Loop 1: n iterations\n", + " if friend in user2_data['friends']: # List search: m iterations\n", + " for interest in user1_data['interests']: # Loop 2: p iterations\n", + " if interest in user2_data['interests']: # List search: q iterations\n", + " mutuals.append((friend, interest))\n", + "return mutuals\n", + "```\n", + "(c)\n", + "\n", + "The generate_combinations function creates a list of combinations for available pizza toppings, considering a list of 'exclusions'. It iterates through the 'toppings' list to generate pairs, excluding any pairs present in the 'exclusions' list, and then appends the remaining combinations to a combinations list. Your analysis should consider the nested loops and the list search for exclusions. \n", + "\n", + "```python\n", + "def generate_combinations(toppings, exclusions):\n", + " combinations = []\n", + " for i in range(len(toppings)): # Loop 1: n iterations\n", + " for j in range(i+1, len(toppings)): # Loop 2: n - 1, n - 2, ... 1 iterations\n", + " if (toppings[i], toppings[j]) not in exclusions: # List search: m iterations\n", + " combinations.append((toppings[i], toppings[j]))\n", + "return combinations\n", + "```\n", + "\n", + "(d)\n", + "\n", + "The function performs a binary search on an array (arr) to find a target value (target) but also has the option to calculate all permutations of the array when a specific depth parameter is set to 0. *Your analysis should consider the logarithmic complexity of binary search and the factorial complexity of calculating permutations.*\n", + "\n", + "```python\n", + "def advanced_search(arr, target, depth):\n", + " if depth == 0:\n", + " return calculate_permutations(arr) \n", + " low = 0\n", + " high = len(arr) - 1\n", + " while low <= high: \n", + " mid = (low + high) // 2\n", + " if arr[mid] == target:\n", + " return mid\n", + " elif arr[mid] < target:\n", + " low = mid + 1\n", + " else:\n", + " high = mid - 1\n", + " return -1\n", + "```\n", + "(e) \n", + "\n", + "The exponential_logarithmic_function combines two operations: generating all subsets of a set s and performing a binary search on an array arr for each subset's length. \n", + "\n", + "```python\n", + "# Function to perform binary search\n", + "def binary_search(arr, target):\n", + " low = 0\n", + " high = len(arr) - 1\n", + " while low <= high:\n", + " mid = (low + high) // 2\n", + " if arr[mid] == target:\n", + " return mid\n", + " elif arr[mid] < target:\n", + " low = mid + 1\n", + " else:\n", + " high = mid - 1\n", + " return -1\n", + "\n", + "# Function to generate all subsets of a set\n", + "def generate_subsets(s):\n", + " if len(s) == 0:\n", + " return [[]]\n", + " subsets = []\n", + " first = s[0]\n", + " remaining = s[1:]\n", + " for subset in generate_subsets(remaining):\n", + " subsets.append(subset)\n", + " subsets.append([first] + subset)\n", + " return subsets\n", + "\n", + "# Main function that combines both exponential and logarithmic complexities\n", + "def exponential_logarithmic_function(arr, s):\n", + " for subset in generate_subsets(s):\n", + " binary_search(arr, len(subset))\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Solution - Question 7**\n", + "\n", + "\\begin{aligned}\n", + "&(a) \\quad O(n \\times m \\times p)\\\\\n", + "&(b) \\quad O(n \\times m \\times p \\times q)\\\\\n", + "&(c) \\quad O(n^2 \\times m)\\\\\n", + "&(d) \\quad O(n!)\\\\\n", + "&(e) \\quad O(2^n \\times \\log m)\n", + "\\end{aligned}\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Justification and Proof of Correctness - Question 7**\n", + "\n", + "(a)\n", + "- There are two nested loops: \n", + "\n", + " - The first loop iterates through all of the emails in the list. Let us suppose there are n emails.\n", + " - The second loop iterates through the list of target keywords. Assume you have m target keywords. \n", + "\n", + "- The function uses the in operator to conduct string matching within the inner loop. In Python, the in operator's worst-case time complexity for strings is O(p), where p is the length of the string being searched.\n", + "\n", + "Given this, the function's worst-case time complexity may be determined as follows:\n", + "\n", + "- The temporal complexity of the nested loops is O(n * m).\n", + "- A string matching operation with time complexity O(p) is performed for each iteration of the inner loop.\n", + "- The append() operation is generally O(1).\n", + "\n", + "\n", + "Putting these together, we get a worst-case time complexity of O(n * m * p)\n", + "\n", + "(b)\n", + "\n", + "- The outer loop iterates through each of user1_data's friends. This adds to the time complexity of O(n).\n", + "- Within the outer loop, a conditional statement checks to see if friend is in user2_data['friends']. In the worst scenario, checking for list membership has a temporal complexity of O(m).\n", + "- A nested loop iterates over each interest of user1_data within the outer loop and the conditional expression. This adds a temporal complexity of O(p).\n", + "- Within the nested loop, another conditional statement determines whether interest exists in user2_data['interests']. In the worst scenario, checking for list membership has a time complexity of O(q).\n", + "\n", + "- Finally, the append() operation has a constant time complexity of O(1).\n", + "\n", + "When we add all of them together, we get:\n", + "\n", + "- The outer loop has a time complexity of O(n).\n", + "- The time complexity of the list search inside the outer loop is O(m).\n", + "- The time complexity of the nested loop is O(p).\n", + "- The time complexity of the list search within the nested loop is O(q).\n", + "\n", + "The overall time complexity is O(n×m×p×q).\n", + "\n", + "(c) \n", + "\n", + "- Outer Loop: Iterates n times, where n is the number of toppings. As a result, its temporal complexity is O(n).\n", + "\n", + "- Inner Loop: The inner loop starts from i+1 to n-1. The number of iterations for the inner loop would be (n−1)+(n−2)+…+1, which forms an arithmetic series. The sum of this series is (n−1)×n/2, which simplifies to O(n^2).\n", + "\n", + "- Exclusion Check: Inside the inner loop, there is a check to see if a particular combination is in the exclusions list. This operation is O(m), where m is the number of exclusions.\n", + "\n", + "- Append Operation: This operation is O(1), a constant time operation.\n", + "\n", + "Combining all these elements, we get the time complexity as O(n^2×m).\n", + "\n", + "(d)\n", + "\n", + "1. When the depth is zero:\n", + "\n", + " The function in this case calls calculate_permutations(arr). Because you are creating every conceivable arrangement of n elements, calculating all permutations of an array of length n has a time complexity of O(n!).\n", + "\n", + "2. When depth is more than zero:\n", + "\n", + " In this scenario, the array arr is subjected to a binary search. A binary search operation has a time complexity of O(logn), where n is the size of the array.\n", + "\n", + "\n", + "Because the function executes either the permutation calculation or the binary search depending on depth, the worst-case time complexity would be the maximum of these two, which is O(n!) when depth is 0.\n", + "\n", + "As a result, the advanced_search function's worst-case time complexity is O(n!).\n", + "\n", + "\n", + "(e)\n", + "\n", + "1. Generating Subsets (generate_subsets function):\n", + "\n", + " The generate_subsets function generates all possible subsets of the set s. For a set of size n, there are 2n subsets. Thus, the time complexity for generating all subsets of s is O(2n).\n", + "\n", + "2. Binary Search (binary_search function):\n", + "\n", + " The binary_search function has a time complexity of O(log⁡m), where m is the size of the array arr.\n", + "\n", + "3. Combined Complexity (exponential_logarithmic_function function):\n", + "\n", + " In the exponential_logarithmic_function, the function iterates over each subset generated by generate_subsets(s) and performs a binary search using binary_search(arr, len(subset)).\n", + "\n", + "Hence, the overall time complexity of the exponential_logarithmic_function will be O(2^n×log⁡m).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question 8 (10 points)\n", + "\n", + "**Problem Statement:**\n", + "\n", + "Emergency Evacuation Plan in a Building Using Graph Traversal Algorithms\n", + "\n", + "Consider a building with numerous floors and rooms, represented as a graph with each node representing a room and each edge representing a doorway connecting two rooms. Some rooms have staircases leading to higher stories. In the event of a fire, the building's residents must be evacuated as fast and safely as possible.\n", + "\n", + "Create pseudocode for a modified BFS or DFS algorithm that will discover the shortest path from each given room to the nearest emergency exit. The algorithm should take into consideration numerous restrictions such as blocked doors, room capacity, and other potential risks. The aim is to get everyone to safety while keeping the overall evacuation time to a minimum.\n", + "\n", + "- Before writing the pseudocode, describe your problem-solving strategy.\n", + "- To tackle this problem, write a pseudocode for the updated BFS or DFS algorithm.\n", + "\n", + "Input Format:\n", + "\n", + "- Rooms: An integer N representing the number of rooms (nodes).\n", + "- Doorway Count: An integer M representing the number of doors (edges).\n", + "- Edge Weights: A list of M tuples (a, b, w) denoting the existence of a doorway with a time-weight of w (to-cross) between rooms a and b.\n", + "- Emergency Exits: A list E of rooms marked as emergency exits.\n", + "- Impassable Rooms: A list of rooms that are inaccessible or harmful.\n", + "- Start Room: An integer S denoting the initial room.\n", + "\n", + "Output Format:\n", + "\n", + "- Shortest Evacuation Time: An integer reflecting the time it takes to go from the starting room to an emergency exit. Return -1 if no route is identified.\n", + "\n", + "**Contraints:**\n", + "\n", + "- The building's graph is linked, however it may contain cycles.\n", + "- Some nodes (rooms) may be designated as dangerous or inaccessible.\n", + "- Each edge (doorway) may have a weight that represents the amount of time it takes to pass through.\n", + "- The building has a restricted number of emergency exits, which are depicted as special nodes in the network." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### **Solution - Question 8**\n", + "\n", + "**Approach:**\n", + "\n", + "- Initialization: Create a data structure to maintain the state of each room, which contains information such as its distance from the beginning room and whether or not it has been visited.\n", + "\n", + "- Constraints: Incorporate checks to skip impassable rooms and to adjust edge weights according to the constraints like blocked doorways, room capacities, and other hazards.\n", + "\n", + "- Emergency Exits: Locate the building's emergency exits and include them in the algorithm's stopping criteria.\n", + "\n", + "- Traversal approach: To traverse the graph, use a modified Breadth-First Search (BFS) method. BFS is preferred over Depth-First Search (DFS) because it finds the shortest pathways in weighted graphs.\n", + "\n", + "\n", + "**Pseudocode:**\n", + "\n", + "```plaintext\n", + "Initialize an empty priority queue Q\n", + "Initialize a dictionary distance with all rooms set to infinity, except the starting room S set to 0\n", + "\n", + "Push (0, S) into Q (distance, room)\n", + "while Q is not empty:\n", + " current_distance, current_room = Pop the minimum element from Q\n", + " \n", + " if current_room is in Emergency Exits:\n", + " return current_distance\n", + "\n", + " if current_room is in Impassable Rooms:\n", + " continue\n", + "\n", + " Mark current_room as visited\n", + " for each neighbor, edge_weight in neighbors of current_room:\n", + " if neighbor is not visited:\n", + " new_distance = current_distance + edge_weight\n", + " \n", + " if new_distance < distance[neighbor]:\n", + " distance[neighbor] = new_distance\n", + " Push (new_distance, neighbor) into Q\n", + "\n", + "return -1 # If no path to any emergency exit is found\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Justification and Proof of Correctness - Question 8**\n", + "\n", + "Pseudocode Justification and correctness proof:\n", + "\n", + "1. Initialization Procedure\n", + "\n", + " - Setting the distance between all rooms to infinity except the first, which is set to zero. This method ensures that any actual path discovered later will be shorter than infinity and will change the initialized value, making it a minimum value at that time.\n", + "\n", + " - At the beginning, distance[start_room] equals 0 and distance[any_other_room] equals. This guarantees that the algorithm correctly determines whether or not it can improve on the initial assignment.\n", + "\n", + "2. Priority Queue (Q)\n", + "\n", + " - Priority queues guarantee that at every stage, we select the room closest to the beginning point. This is critical for effectiveness.\n", + "\n", + " - Whenever we remove an element from the priority queue, it is always the room with the shortest distance label. This characteristic assures that we explore nodes in the order that corresponds to discovering the shortest pathways first, justifying the usage of a priority queue.\n", + "\n", + "3. Check the Emergency Exit\n", + "\n", + " - Finding the shortest path to the nearest emergency exit; once found, the algorithm may be safely terminated.\n", + "\n", + " - The priority queue assures that the first exit encountered has the shortest path, and no other exit has a shorter path. Stopping the algorithm when an emergency exit is reached is thus accurate.\n", + "\n", + "4. Impassable Rooms\n", + "\n", + " - The algorithm detects and avoids inaccessible rooms, which is crucial for the evacuation's safety.\n", + "\n", + " - The algorithm only considers a room to be visited if it is not on the list of inaccessible rooms. This guarantees that impenetrable rooms never have an impact on the evacuation plan's outcome.\n", + "\n", + "5. Edge Relaxation and Update\n", + "\n", + " - When a room is visited, the algorithm iteratively updates the distances to its neighbors, guaranteeing that the shortest path is found.\n", + "\n", + " - The method assures optimality by updating only when a shorter path is identified (new_distance distance[neighbor]). This guarantees that by the time a room is removed from the priority list, the quickest path to that room has been identified." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002722344_Rishi_Raghu/Ques5_Coding.py b/Submissions/002722344_Rishi_Raghu/Ques5_Coding.py new file mode 100644 index 0000000..8ec7afc --- /dev/null +++ b/Submissions/002722344_Rishi_Raghu/Ques5_Coding.py @@ -0,0 +1,41 @@ +def create_skill_based_preferences(mentors, interns): + mentor_pref = {} + intern_pref = {} + + #TODO: Implement this function to create skill-based preferences for mentors and interns + + return mentor_pref, intern_pref + +def find_stable_matching(mentor_preferences, intern_preferences): + unassigned_interns = list(intern_preferences.keys()) + mentor_current = {} # Current matchings for mentors + intern_current = {} # Current matchings for interns + + #TODO: Implement this function to find stable matching between mentors and interns + + return mentor_current + +def remove_unstable_pairs(stable_pairs, unhappy_mentors, unhappy_interns): + new_stable_pairs = {} + + #TODO: Implement this function to remove unstable pairs from stable_pairs + + return new_stable_pairs + +# Example usage: +# mentors = [ +# {'name': 'Mentor_A', 'skills': ['Python', 'ML', 'Data Science', 'NLP']}, +# {'name': 'Mentor_B', 'skills': ['Web Development', 'JavaScript', 'React', 'Angular']}, +# {'name': 'Mentor_C', 'skills': ['Python', 'Flask', 'Web Development', 'React']}, +# {'name': 'Mentor_D', 'skills': ['ML', 'Python', 'NLP', 'Data Science']}, +# {'name': 'Mentor_E', 'skills': ['Web Development', 'HTML', 'CSS']} +# ] + +# interns = [ +# {'name': 'Intern_A', 'skills': ['Python', 'ML', 'NLP']}, +# {'name': 'Intern_B', 'skills': ['JavaScript', 'React', 'Angular']}, +# {'name': 'Intern_C', 'skills': ['Python', 'Flask']}, +# {'name': 'Intern_D', 'skills': ['ML', 'Data Science', 'Python']}, +# {'name': 'Intern_E', 'skills': ['HTML', 'CSS', 'JavaScript']}, +# {'name': 'Intern_F', 'skills': ['Python', 'Flask', 'React']} +# ] diff --git a/Submissions/002722344_Rishi_Raghu/Ques5_Sol.py b/Submissions/002722344_Rishi_Raghu/Ques5_Sol.py new file mode 100644 index 0000000..a727404 --- /dev/null +++ b/Submissions/002722344_Rishi_Raghu/Ques5_Sol.py @@ -0,0 +1,99 @@ +def create_skill_based_preferences(mentors, interns): + mentor_pref = {} + intern_pref = {} + + # Loop through mentors to create their preference lists + for mentor in mentors: + mentor_name = mentor['name'] + mentor_skills = set(mentor['skills']) + mentor_pref[mentor_name] = [] + + # Sort interns based on the number of matching skills + for intern in sorted(interns, key=lambda x: len(mentor_skills.intersection(set(x['skills']))), reverse=True): + intern_name = intern['name'] + if len(mentor_skills.intersection(set(intern['skills']))) > 0: + mentor_pref[mentor_name].append(intern_name) + + # Loop through interns to create their preference lists + for intern in interns: + intern_name = intern['name'] + intern_skills = set(intern['skills']) + intern_pref[intern_name] = [] + + # Sort mentors based on the number of matching skills + for mentor in sorted(mentors, key=lambda x: len(intern_skills.intersection(set(x['skills']))), reverse=True): + mentor_name = mentor['name'] + if len(intern_skills.intersection(set(mentor['skills']))) > 0: + intern_pref[intern_name].append(mentor_name) + + # Formatting output + formatted_mentor_pref = "\n".join([f"{mentor}: {prefs}" for mentor, prefs in mentor_pref.items()]) + formatted_intern_pref = "\n".join([f"{intern}: {prefs}" for intern, prefs in intern_pref.items()]) + + print(f"Mentor Preferences:\n{formatted_mentor_pref}") + print(f"Intern Preferences:\n{formatted_intern_pref}") + + return mentor_pref, intern_pref + +def find_stable_matching(mentor_preferences, intern_preferences): + unassigned_interns = list(intern_preferences.keys()) + mentor_current = {} # Current matchings for mentors + intern_current = {} # Current matchings for interns + mentor_next_proposal = {mentor: 0 for mentor in mentor_preferences} # Next proposal index for each mentor + + while unassigned_interns: + intern = unassigned_interns.pop(0) + preferred_mentors = intern_preferences[intern] + + for mentor in preferred_mentors: + if mentor not in mentor_current: # Mentor is unassigned + mentor_current[mentor] = intern + intern_current[intern] = mentor + break + else: # Mentor is already assigned + current_intern = mentor_current[mentor] + if mentor_preferences[mentor].index(intern) < mentor_preferences[mentor].index(current_intern): # New intern is preferred + mentor_current[mentor] = intern + intern_current[intern] = mentor + if current_intern in intern_current: + del intern_current[current_intern] + unassigned_interns.append(current_intern) # Reassign previous intern + break + + return mentor_current + +def remove_unstable_pairs(stable_pairs, unhappy_mentors, unhappy_interns): + new_stable_pairs = {} + + for mentor, intern in stable_pairs.items(): + if mentor not in unhappy_mentors and intern not in unhappy_interns: + new_stable_pairs[mentor] = intern + + return new_stable_pairs + + +mentors = [ + {'name': 'Mentor_A', 'skills': ['Python', 'ML', 'Data Science', 'NLP']}, + {'name': 'Mentor_B', 'skills': ['Web Development', 'JavaScript', 'React', 'Angular']}, + {'name': 'Mentor_C', 'skills': ['Python', 'Flask', 'Web Development', 'React']}, + {'name': 'Mentor_D', 'skills': ['ML', 'Python', 'NLP', 'Data Science']}, + {'name': 'Mentor_E', 'skills': ['Web Development', 'HTML', 'CSS']} +] + +interns = [ + {'name': 'Intern_A', 'skills': ['Python', 'ML', 'NLP']}, + {'name': 'Intern_B', 'skills': ['JavaScript', 'React', 'Angular']}, + {'name': 'Intern_C', 'skills': ['Python', 'Flask']}, + {'name': 'Intern_D', 'skills': ['ML', 'Data Science', 'Python']}, + {'name': 'Intern_E', 'skills': ['HTML', 'CSS', 'JavaScript']}, + {'name': 'Intern_F', 'skills': ['Python', 'Flask', 'React']} +] + +unhappy_mentors = ['Mentor_A'] +unhappy_interns = ['Intern_A', 'Intern_F'] + +mentor_preferences, intern_preferences = create_skill_based_preferences(mentors, interns) +stable_pairs = find_stable_matching(mentor_preferences, intern_preferences) +print("Stable Matches:", stable_pairs) +new_stable_pairs = remove_unstable_pairs(stable_pairs, unhappy_mentors, unhappy_interns) +print("New Stable Pairs:", new_stable_pairs) diff --git a/Submissions/002722344_Rishi_Raghu/Ques6_Coding.py b/Submissions/002722344_Rishi_Raghu/Ques6_Coding.py new file mode 100644 index 0000000..479838e --- /dev/null +++ b/Submissions/002722344_Rishi_Raghu/Ques6_Coding.py @@ -0,0 +1,65 @@ +from collections import deque + +def shortest_path(graph, start, end): + + visited = set() + queue = deque([(start, [start])]) + + #TODO: Implement this function to find the shortest path + pass + + +def maintenance_path(graph, start): + + visited = set() + path = [] + + #TODO: Implement this function to find the maintenance path + pass + + +def safest_path(graph, start, end): + + candidates = [(0, start, [])] + visited = set() + + #TODO: Implement this function to find the safest path + pass + + +def min_charging_stops(graph, start, end, stations): + + visited = set() + queue = deque([(start, [start], 0)]) # Node, Path, Stops + + #TODO: Implement this function to find the minimum charging stops + pass + + +# Example usage: + +# weighted_graph = { +# Graph vertex: {Neighbor vertex: Weight of edge}, +# } +# graph={ +# Graph vertex: [List of neighbor vertices], +# ... +# } + +# Test your code here: + +# start = Some value +# end = Some value +# node = Some value +# stations = List of values + +# result = shortest_path(graph, start, end) +# print("Shortest path:", result) + +# result = maintenance_path(graph, node) +# print("Maintenance Path:", result) + +# print(safest_path(weighted_graph, start, end)) + +# result = min_charging_stops(graph, start, end, stations) +# print(result) \ No newline at end of file diff --git a/Submissions/002722344_Rishi_Raghu/Ques6_Sol.py b/Submissions/002722344_Rishi_Raghu/Ques6_Sol.py new file mode 100644 index 0000000..f5bc1c9 --- /dev/null +++ b/Submissions/002722344_Rishi_Raghu/Ques6_Sol.py @@ -0,0 +1,131 @@ +from collections import deque + +def shortest_path(graph, start, end): + visited = set() + queue = deque([(start, [start])]) + + while queue: + current_intersection, path = queue.popleft() + if current_intersection == end: + return path + visited.add(current_intersection) + + for neighbor in graph[current_intersection]: + if neighbor not in visited: + new_path = list(path) + new_path.append(neighbor) + queue.append((neighbor, new_path)) + + +def maintenance_path(graph, start): + visited = set() + path = [] + + def dfs(current_intersection): + visited.add(current_intersection) + path.append(current_intersection) + for neighbor in graph[current_intersection]: + if neighbor not in visited: + dfs(neighbor) + + dfs(start) + return path + +def safest_path(graph, start, end): + candidates = [(0, start, [])] + visited = set() + + while candidates: + candidates.sort(reverse=True) # Sort by safety, descending + safety_sum, current, path = candidates.pop(0) # Get the safest route + + if current in visited: + continue + visited.add(current) + + path = path + [current] + + if current == end: + return path + + for neighbor, safety in graph[current].items(): + if neighbor not in visited: + new_safety_sum = safety_sum + safety + candidates.append((new_safety_sum, neighbor, path)) + + return "Not possible" + +def min_charging_stops(graph, start, end, stations): + visited = set() + queue = deque([(start, [start], 0)]) # Node, Path, Stops + + while queue: + current_node, path, stops = queue.popleft() + visited.add(current_node) + + # If we reach the destination, return the path + if current_node == end: + return path + + for neighbor in graph[current_node]: + if neighbor not in visited: + new_stops = stops + # If there is a charging station at the neighbor, reset the stops counter + if neighbor in stations: + new_stops += 1 + # Add the neighbor node to the queue for future processing + queue.append((neighbor, path + [neighbor], new_stops)) + + # If a path is not found + return None + +# Test the function +weighted_graph = { + 'A': {'B': 3, 'C': 2}, + 'B': {'A': 3, 'D': 4}, + 'C': {'A': 2, 'D': 1, 'E': 5}, + 'D': {'B': 4, 'C': 1, 'E': 2}, + 'E': {'C': 5, 'D': 2} +} + +# Example usage: + +maintenance_path_graph = { + 'A': ['B', 'F'], + 'B': ['A', 'C', 'E'], + 'C': ['B', 'D'], + 'D': ['C', 'E'], + 'E': ['B', 'D', 'F'], + 'F': ['A', 'E', 'G'], + 'G': ['F'] +} + +graph = { + 'A': ['B', 'D'], + 'B': ['C', 'E'], + 'C': ['F'], + 'D': ['E', 'G'], + 'E': ['F', 'H'], + 'F': ['I'], + 'G': ['H'], + 'H': ['I'], + 'I': [] +} + +start = 'A' +end = 'I' +stations = ['B', 'D', 'F', 'H'] + +result = shortest_path(graph, 'A', 'H') +print("Shortest path:", result) + +result = maintenance_path(maintenance_path_graph, 'A') +print("Maintenance Path:", result) + +print(safest_path(weighted_graph, 'A', 'E')) +print(safest_path(weighted_graph, 'A', 'D')) +print(safest_path(weighted_graph, 'A', 'B')) + +result = min_charging_stops(graph, start, end, stations) +print(result) + diff --git a/Submissions/002722344_Rishi_Raghu/Readme.md b/Submissions/002722344_Rishi_Raghu/Readme.md new file mode 100644 index 0000000..fa57301 --- /dev/null +++ b/Submissions/002722344_Rishi_Raghu/Readme.md @@ -0,0 +1,75 @@ +### First Name: Rishi +### Last Name : Raghu +### NU_ID : 002722344 + +# Assignment-1 : "Summary of assignment 1" + +Each question is divided into 3 sections: + +1. Question - Problem statement +2. Solution +3. Justification and proof of correctness + +## Question Distribution: + +1. 10 points +2. 2 parts : 10 points (5 points each) +3. 4 parts : 20 points (5 points each) +4. 2 parts : 10 points (5 points each) +5. 3 parts : 25 points (10 points, 10 points, 5 points) +6. 4 parts : 25 points (5 points, 5 points, 7 points, 8 points) +7. 5 parts : 10 points (2 points each) +8. 10 points + +Total : 120 points + +## Topics covered: +- Algorithmic Pseudocodes +- Gale - Shapley Algorithm +- Computational Complexity and Big O Notation +- Graphs and Graph Traversals +- BFS,DFS, Topological Sort, DAGs + +## Reflection + +**AI Tools I used for this assignment:** +- Chat GPT +- Bard + +**Resources and refernces I used for this assignment:** + +- Stanford Algorithms lectures and assignments +- University of Washington Algorithms lectures and assignments +- NYU Algorithms lectures and assignments +- Geeks for Geeks +- Leetcode + +### How I used the AI tools: + +**- Brainstorming Ideas:** + +Used ChatGPT and Bard to discuss real world applications where problem statements could be created for respective algorithms. + +**- Adding uniqueness and complexity:** + +Discussed what factors could be added to the problem statements to make them challenging, yet applicable and relevant to our syllabus covered in class. + +**- Working on Solutions:** + +- Took help from chat-GPT and Bard to solve the rudimentary tasks of the solution and focused on discussing how modifications could be made to arrive to final solution. +- Additionally after forming the answers together, brainstormed on potential caveats in the solutionand worked upon those to refine it and arrive at efficient solutions, which handle edge case and scenarios I might have missed +- Re-fed the solutions with problem statements to Chat-GPT and Bard to test correctness of the solution and make iteration upon the code/answer. +- Used the AI tools to discuss the correctness of the solution and arrive at derivations and proofs for the same. + +**- Challenges:** + +- It was difficult to ensure that the new issues still corresponded to what was being taught in class. +- The difficulties have to be hard but not unreasonable to solve. +- The concerns have to feel like they were from the actual world. + +**- Learnings:** + +- Consider what the students should learn from addressing the challenge. +- It is critical to begin with a simple query and then go to a more sophisticated one. +- Making a good problem requires testing and feedback. +- A excellent problem evaluates not only your knowledge but also your ability to think and solve problems. \ No newline at end of file diff --git a/Submissions/002722344_Rishi_Raghu/image-1.png b/Submissions/002722344_Rishi_Raghu/image-1.png new file mode 100644 index 0000000..f7abe0f Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-1.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image-10.png b/Submissions/002722344_Rishi_Raghu/image-10.png new file mode 100644 index 0000000..122133e Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-10.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image-4.png b/Submissions/002722344_Rishi_Raghu/image-4.png new file mode 100644 index 0000000..545358b Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-4.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image-5.png b/Submissions/002722344_Rishi_Raghu/image-5.png new file mode 100644 index 0000000..70ed0cc Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-5.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image-6.png b/Submissions/002722344_Rishi_Raghu/image-6.png new file mode 100644 index 0000000..40af8b0 Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-6.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image-7.png b/Submissions/002722344_Rishi_Raghu/image-7.png new file mode 100644 index 0000000..fc1d4fc Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-7.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image-8.png b/Submissions/002722344_Rishi_Raghu/image-8.png new file mode 100644 index 0000000..4eb0698 Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-8.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image-9.png b/Submissions/002722344_Rishi_Raghu/image-9.png new file mode 100644 index 0000000..4dccda8 Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image-9.png differ diff --git a/Submissions/002722344_Rishi_Raghu/image.png b/Submissions/002722344_Rishi_Raghu/image.png new file mode 100644 index 0000000..e42b95d Binary files /dev/null and b/Submissions/002722344_Rishi_Raghu/image.png differ diff --git a/Submissions/002726557_Yukun_Huang/Assignment-1.readme b/Submissions/002726557_Yukun_Huang/Assignment-1.readme new file mode 100644 index 0000000..6dd9d68 --- /dev/null +++ b/Submissions/002726557_Yukun_Huang/Assignment-1.readme @@ -0,0 +1 @@ +This is a readme. \ No newline at end of file diff --git a/Submissions/002726557_Yukun_Huang/Assignment_1_Q9.ipynb b/Submissions/002726557_Yukun_Huang/Assignment_1_Q9.ipynb new file mode 100644 index 0000000..eb04cab --- /dev/null +++ b/Submissions/002726557_Yukun_Huang/Assignment_1_Q9.ipynb @@ -0,0 +1,238 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 37, + "id": "54dd1c04", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Western Team Grizzlies matched with Eastern Team Bucks\n", + "Western Team Kings matched with Eastern Team Celtics\n", + "Western Team Suns matched with Eastern Team 76ers\n", + "Western Team Clippers matched with Eastern Team Cavaliers\n", + "Western Team Warriors matched with Eastern Team Knicks\n", + "Western Team Lakers matched with Eastern Team Nets\n", + "Western Team Timberwolves matched with Eastern Team Hawks\n", + "Western Team Nuggets matched with Eastern Team Heat\n" + ] + } + ], + "source": [ + "#A\n", + "def gale_shapley(western_prefs, eastern_prefs):\n", + " eastern_matches = {}\n", + " western_matches = {}\n", + " free_eastern_teams = list(eastern_prefs.keys())\n", + " \n", + " while free_eastern_teams:\n", + " eastern_team = free_eastern_teams.pop(0)\n", + " eastern_preferences = eastern_prefs[eastern_team]\n", + " \n", + " for western_team in eastern_preferences:\n", + " current_match = eastern_matches.get(eastern_team)\n", + " \n", + " if current_match is None:\n", + " eastern_matches[eastern_team] = western_team\n", + " western_matches[western_team] = eastern_team\n", + " break\n", + " else:\n", + " current_rank = western_prefs[western_team].index(eastern_team)\n", + " new_rank = western_prefs[western_team].index(current_match)\n", + " \n", + " if current_rank < new_rank:\n", + " break\n", + " else:\n", + " eastern_matches[eastern_team] = western_team\n", + " western_matches[western_team] = eastern_team\n", + " free_eastern_teams.append(current_match)\n", + " \n", + " return western_matches\n", + "\n", + "western_prefs = {\n", + " \"Nuggets\": [\"Celtics\", \"76ers\", \"Cavaliers\", \"Knicks\", \"Nets\", \"Hawks\", \"Heat\", \"Bucks\"],\n", + " \"Grizzlies\": [\"76ers\", \"Cavaliers\", \"Knicks\", \"Nets\", \"Hawks\", \"Heat\", \"Bucks\", \"Celtics\"],\n", + " \"Kings\": [\"Cavaliers\", \"Knicks\", \"Nets\", \"Hawks\", \"Heat\", \"Bucks\", \"Celtics\", \"76ers\"],\n", + " \"Suns\": [\"Knicks\", \"Nets\", \"Hawks\", \"Heat\", \"Bucks\", \"Celtics\", \"76ers\", \"Cavaliers\"],\n", + " \"Clippers\": [\"Nets\", \"Hawks\", \"Heat\", \"Bucks\", \"Celtics\", \"76ers\", \"Cavaliers\", \"Knicks\"],\n", + " \"Warriors\": [\"Hawks\", \"Heat\", \"Bucks\", \"Celtics\", \"76ers\", \"Cavaliers\", \"Knicks\", \"Nets\"],\n", + " \"Lakers\": [\"Heat\", \"Bucks\", \"Celtics\", \"76ers\", \"Cavaliers\", \"Knicks\", \"Nets\", \"Hawks\"],\n", + " \"Timberwolves\": [\"Bucks\", \"Celtics\", \"76ers\", \"Cavaliers\", \"Knicks\", \"Nets\", \"Hawks\", \"Heat\"]\n", + "}\n", + "\n", + "eastern_prefs = {\n", + " \"Bucks\": [\"Grizzlies\", \"Kings\", \"Suns\", \"Clippers\", \"Warriors\", \"Lakers\", \"Timberwolves\", \"Nuggets\"],\n", + " \"Celtics\": [\"Kings\", \"Suns\", \"Clippers\", \"Warriors\", \"Lakers\", \"Timberwolves\", \"Nuggets\", \"Grizzlies\"],\n", + " \"76ers\": [\"Suns\", \"Clippers\", \"Warriors\", \"Lakers\", \"Timberwolves\", \"Nuggets\", \"Grizzlies\", \"Kings\"],\n", + " \"Cavaliers\": [\"Clippers\", \"Warriors\", \"Lakers\", \"Timberwolves\", \"Nuggets\", \"Grizzlies\", \"Kings\", \"Suns\"],\n", + " \"Knicks\": [\"Warriors\", \"Lakers\", \"Timberwolves\", \"Nuggets\", \"Grizzlies\", \"Kings\", \"Suns\", \"Clippers\"],\n", + " \"Nets\": [\"Lakers\", \"Timberwolves\", \"Nuggets\", \"Grizzlies\", \"Kings\", \"Suns\", \"Clippers\", \"Warriors\"],\n", + " \"Hawks\": [\"Timberwolves\", \"Nuggets\", \"Grizzlies\", \"Kings\", \"Suns\", \"Clippers\", \"Warriors\", \"Lakers\"],\n", + " \"Heat\": [\"Nuggets\", \"Grizzlies\", \"Kings\", \"Suns\", \"Clippers\", \"Warriors\", \"Lakers\", \"Timberwolves\"]\n", + "}\n", + "\n", + "matches = gale_shapley(western_prefs, eastern_prefs)\n", + "\n", + "for western_team, eastern_team in matches.items():\n", + " print(f\"Western Team {western_team} matched with Eastern Team {eastern_team}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "fbe87934", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Percentage of stable playoff matches: 12.2%\n" + ] + } + ], + "source": [ + "#B\n", + "import random\n", + "\n", + "num_teams = 8\n", + "\n", + "eastern_teams = [list(range(num_teams)) for _ in range(num_teams)]\n", + "western_teams = [list(range(num_teams)) for _ in range(num_teams)]\n", + "\n", + "num_iterations = 1000\n", + "stable_matches = 0\n", + "\n", + "for _ in range(num_iterations):\n", + " for i in range(num_teams):\n", + " random.shuffle(eastern_teams[i])\n", + " random.shuffle(western_teams[i])\n", + " \n", + " matches = [-1] * num_teams # Initialize matches as -1 for all teams\n", + " while -1 in matches:\n", + " for i in range(num_teams):\n", + " if matches[i] == -1:\n", + " for j in eastern_teams[i]:\n", + " if matches[j] == -1:\n", + " matches[i] = j\n", + " matches[j] = i\n", + " break\n", + " \n", + " # Check if the matches are stable\n", + " is_stable = True\n", + " for i in range(num_teams):\n", + " for j in range(i + 1, num_teams):\n", + " if eastern_teams[i].index(matches[i]) > eastern_teams[i].index(matches[j]) and western_teams[j].index(i) > western_teams[j].index(matches[j]):\n", + " is_stable = False\n", + " break\n", + " \n", + " if is_stable:\n", + " stable_matches += 1\n", + "\n", + "percentage_stable = (stable_matches / num_iterations) * 100\n", + "\n", + "print(f\"Percentage of stable playoff matches: {percentage_stable}%\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "2ab04e22", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Execution time for 8 teams: 0.00000810 seconds\n", + "Execution time for 16 teams: 0.00000520 seconds\n", + "Execution time for 32 teams: 0.00001390 seconds\n", + "Execution time for 64 teams: 0.00004590 seconds\n", + "Execution time for 128 teams: 0.00019220 seconds\n", + "Execution time for 256 teams: 0.00064570 seconds\n" + ] + } + ], + "source": [ + "#E\n", + "import random\n", + "import time\n", + "\n", + "def generate_preference_lists(num_teams):\n", + " eastern_teams = [list(range(num_teams)) for _ in range(num_teams)]\n", + " western_teams = [list(range(num_teams)) for _ in range(num_teams)]\n", + " return eastern_teams, western_teams\n", + "\n", + "def gale_shapley(eastern_teams, western_teams):\n", + " num_teams = len(eastern_teams)\n", + " matches = [-1] * num_teams\n", + " while -1 in matches:\n", + " for i in range(num_teams):\n", + " if matches[i] == -1:\n", + " for j in eastern_teams[i]:\n", + " if matches[j] == -1:\n", + " matches[i] = j\n", + " matches[j] = i\n", + " break\n", + " return matches\n", + "\n", + "def is_stable_match(eastern_teams, western_teams, matches):\n", + " num_teams = len(eastern_teams)\n", + " for i in range(num_teams):\n", + " for j in range(i + 1, num_teams):\n", + " if eastern_teams[i].index(matches[i]) > eastern_teams[i].index(matches[j]) and western_teams[j].index(i) > western_teams[j].index(matches[j]):\n", + " return False\n", + " return True\n", + "\n", + "list_sizes = [8, 16, 32, 64, 128, 256]\n", + "\n", + "for num_teams in list_sizes:\n", + " eastern_teams, western_teams = generate_preference_lists(num_teams)\n", + " \n", + " start_time = time.perf_counter()\n", + " matches = gale_shapley(eastern_teams, western_teams)\n", + " end_time = time.perf_counter()\n", + " \n", + " if not is_stable_match(eastern_teams, western_teams, matches):\n", + " print(f\"Unstable match found for {num_teams} teams.\")\n", + " \n", + " execution_time = end_time - start_time\n", + " print(f\"Execution time for {num_teams} teams: {execution_time:.8f} seconds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd7da151", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/002726557_Yukun_Huang/Untitled-1.ipynb b/Submissions/002726557_Yukun_Huang/Untitled-1.ipynb new file mode 100644 index 0000000..2cf7abb --- /dev/null +++ b/Submissions/002726557_Yukun_Huang/Untitled-1.ipynb @@ -0,0 +1,26 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignments-1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002734572_Douhao_Ma/Assignment1.readme b/Submissions/002734572_Douhao_Ma/Assignment1.readme new file mode 100644 index 0000000..82cf8ac --- /dev/null +++ b/Submissions/002734572_Douhao_Ma/Assignment1.readme @@ -0,0 +1,15 @@ +NUID: 002734572 + +Firstname: Douhao + +LastName: Ma + + + +Assignment1 Reflection： + +1. I used ChatGPT to read, to deepen my understanding of the problem, I tried to get it to tell me what the field of the problem was, what the nature of the problem was, and then after figuring it out, I went on to ask him if there were any other similar questions, and then I read and understood deeply, and then created my own questions and answered them. I also tried to use chatGPT to answer my questions. Interestingly, I found that chatGPT always gave me different answers, but I ultimately chose to stick with my answers. + +2. I encountered many problems and challenges in this process. First, I often couldn't understand the meaning of the questions, for example, I didn't know what Omega and theta meant except for big O. It took me a long time to use chatGPT to figure out what the questions were asking. Then I found it difficult to ask similar questions, and I didn't know much about these kinds of questions. Finally, another difficulty is that when I use chatGPT to answer my questions, it sometimes gives different answers from me, which I think is wrong, such as the first question of time complexity ranking. + +3. The first thing I've learned is clarity, and questions that aren't clear can be difficult to understand. Then there is the skill of breaking down complex problems into simpler, more manageable sub-problems. Then, you need to add some constraints to the design process to make the problem more rigorous. Then, for algorithmic problems, we should be good at understanding the essence, so that we can solve this kind of problem. Finally, the algorithm problem must analyze the complexity of the algorithm, which is the core of the algorithm in my opinion. \ No newline at end of file diff --git a/Submissions/002734572_Douhao_Ma/assignment1.ipynb b/Submissions/002734572_Douhao_Ma/assignment1.ipynb new file mode 100644 index 0000000..fd46880 --- /dev/null +++ b/Submissions/002734572_Douhao_Ma/assignment1.ipynb @@ -0,0 +1,617 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f2f9669f-5910-4c8f-a673-8a02e3f364dc", + "metadata": {}, + "source": [ + "## Assignment1" + ] + }, + { + "cell_type": "raw", + "id": "a29304c1-d732-4b1c-a048-87888b52007c", + "metadata": {}, + "source": [ + "Q1 (10 Points) Arrange the following functions in increasing order of growth:\n", + "\n", + "• 2^n\n", + "• log(n!)\n", + "• n^0.5\n", + "• 4n^n\n", + "• n!/n^2\n", + "• 5log(n) + n^(1/4)\n", + "• log(n^2)\n", + "• log(n)/e\n", + "• log(log(n^(1/2)))\n", + "• 100n\n", + "\n", + "Solution:\n", + "1. log(log(n^(1/2))) Θ(log(log(n)))\n", + "2. log(n)/e Θ(1/e * log(n)) \n", + "3. log(n^2) &Theta(2log(n));\n", + "4. log(n!) &Theta(nlog(n)); \n", + "5. 100n Θ(n)\n", + "6. 5log(n) + n^(1/4) Θ(n^0.25)\n", + "7. n^0.5 Θ(n^0.5) \n", + "8. 2^n Θ(2^n) \n", + "9. n!/n^2 Θ(n!) \n", + "10. 4n^n Θ(n^n) " + ] + }, + { + "cell_type": "raw", + "id": "3f219df0-8220-4c60-8d71-d83ea6ad11a8", + "metadata": {}, + "source": [ + "Q2 (10 Points) Assume that you have functions f and g such that f(n) is O(g(n/2)). For each of the following statements\n", + "decide whether it is true or false and give a proof or counter-example.\n", + "• f(n) = Θ(2f(n)).\n", + "• f(n) = O(f(n^3)).\n", + "• f(n) = O(g(n/2)). Implies g(n) = Ω(f(n))\n", + "\n", + "Solution:\n", + "Counter Proof: n^0.5 ≠ (2n^0.5=n)\n", + "Counter Proof: f(n) = 1/n ≠ O(1/(n^3) )\n", + "• f(n) = O(g(n/2))\n", + " 0 <= f(n) <= c1.g(n) for some c1>0 and all n > n0\n", + " 0 <= (1/c1) f(n) <= g(n/2)\n", + " g(n) = Ω(f(n))\n" + ] + }, + { + "cell_type": "raw", + "id": "c6629cea-bd3a-41bb-8691-2dfe236107cd", + "metadata": {}, + "source": [ + "Q3 (10 Points) Consider there are x men, each with certain interests and criteria, looking for a partner among n women who have expressed interest in men. Each woman has preferences for men, and some men may not find suitable partners. The goal is to find a way of pairing each man with a woman, where each man has only one partner, and it maximizes the satisfaction of women's preferences.\n", + "\n", + "The pairing is considered stable if neither of the following situations occurs:\n", + "\n", + "There are two men, m1 and m2, and one woman, w, such that:\n", + " m1 is paired with w, and m2 is unpaired.\n", + " w prefers m2 over m1.\n", + "There are two men, m1 and m2, and two women, w1 and w2, such that:\n", + " m1 is paired with w1, and m2 is paired with w2.\n", + " w1 prefers m2 over m1.\n", + " m2 prefers w1 over w2.\n", + "\n", + "The problem is to find a stable pairing that maximizes women's preferences. Design an algorithm to solve this problem.\n", + "\n", + "\n", + "Solution:\n", + "Start with all men being single and all women open to relationships. As long as there is a single man:\n", + " The man proposes to the next woman he prefers.\n", + " If the woman is not in a relationship, she accepts the proposal.\n", + " If the woman is already with another man:\n", + " If the woman prefers her current partner, she rejects the proposal.\n", + " If she prefers the new man, she switches to him.\n", + " The new man becomes her partner, and the old man is left single.\n", + "This algorithm continues until all men are in stable relationships. It guarantees stability and respects everyone's preferences. It takes at most O(mn) steps, where m is the number of men and n is the number of women." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "dbcd3f2e-8efe-43ff-bb1c-c20a816a66a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stable Matches:\n", + "Man 0 is matched with Woman 1\n", + "Man 1 is matched with Woman 3\n", + "Man 2 is matched with Woman 0\n", + "Man 3 is matched with Woman 2\n" + ] + } + ], + "source": [ + "func stableMatching(menPrefs [][]int, womenPrefs [][]int) []int {\n", + "\tn := len(menPrefs)\n", + "\tmatches := make([]int, n)\n", + "\twomanMatched := make([]bool, n)\n", + "\n", + "\tfor i := 0; i < n; i++ {\n", + "\t\tmatches[i] = -1\n", + "\t\twomanMatched[i] = false\n", + "\t}\n", + "\n", + "\t\n", + "\tfor count := 0; count < n; count++ {\n", + "\t\tm := -1\n", + "\t\tfor i := 0; i < n; i++ {\n", + "\t\t\tif matches[i] == -1 {\n", + "\t\t\t\tm = i\n", + "\t\t\t\tbreak\n", + "\t\t\t}\n", + "\t\t}\n", + "\n", + "\t\tfor i := 0; i < n && matches[m] == -1; i++ {\n", + "\t\t\tw := menPrefs[m][i]\n", + "\t\t\tif !womanMatched[w] {\n", + "\t\t\t\tmatches[m] = w\n", + "\t\t\t\twomanMatched[w] = true\n", + "\t\t\t} else {\n", + "\t\t\t\tcurrentPartner := -1\n", + "\t\t\t\tfor j := 0; j < n; j++ {\n", + "\t\t\t\t\tif womenPrefs[w][j] == matches[m] {\n", + "\t\t\t\t\t\tcurrentPartner = j\n", + "\t\t\t\t\t}\n", + "\t\t\t\t\tif womenPrefs[w][j] == m {\n", + "\t\t\t\t\t\tbreak\n", + "\t\t\t\t\t}\n", + "\t\t\t\t}\n", + "\n", + "\t\t\t\tif currentPartner > i {\n", + "\t\t\t\t\tmatches[m] = w\n", + "\t\t\t\t\twomanMatched[w] = true\n", + "\t\t\t\t\tmatches[currentPartner] = -1\n", + "\t\t\t\t}\n", + "\t\t\t}\n", + "\t\t}\n", + "\t}\n", + "\n", + "\treturn matches\n", + "}\n", + "\n", + "\n", + "menPrefs := [][]int{\n", + "\t{1, 0, 2, 3},\n", + "\t{3, 2, 1, 0},\n", + "\t{0, 1, 2, 3},\n", + "\t{3, 2, 0, 1},\n", + "}\n", + "\n", + "womenPrefs := [][]int{\n", + "\t{2, 3, 1, 0},\n", + "\t{1, 2, 3, 0},\n", + "\t{3, 2, 1, 0},\n", + "\t{0, 1, 3, 2},\n", + "}\n", + "\n", + "matches := stableMatching(menPrefs, womenPrefs)\n", + "fmt.Println(\"Stable Matches:\")\n", + "for i, j := range matches {\n", + "\tfmt.Printf(\"Man %d is matched with Woman %d\\n\", i, j)\n", + "}\n", + "\n" + ] + }, + { + "cell_type": "raw", + "id": "745ead65-5e4e-46ee-93d6-b05a87f4230b", + "metadata": {}, + "source": [ + "Q4 (10 Points) One algorithm requires nlog2(n) seconds and another algorithm requires n microseconds.\n", + "Which one is asymptotically faster? What is the cross-over value of n?\n", + "\n", + "Solution:\n", + "The first algorithm is asymptotically faster than the second.\n", + "The order of growth of n log2(n) is more than the order of growth of n.\n", + "The Crossover point of n is 2." + ] + }, + { + "cell_type": "raw", + "id": "0ec04ecb-ceb3-41bb-af35-a120d12409c4", + "metadata": {}, + "source": [ + "Q5 (10 Points) Consider building a bridge using a series of rectangular planks. The total number of planks used to build each section of the bridge is determined by adding the number used in the current section to the number used in the previous quarter. We aim to analyze this process asymptotically.\n", + "\n", + "Suppose, for the sake of simplicity, that each section of the bridge is bounded by a constant, denoted as 'c.' Additionally, let's assume that the bridge will consist of at most 'n' planks. How can we construct such a bridge using planks of length 'f(n),' where 'f(n)' grows as slowly as possible?\n", + "\n", + "Solution\n", + "We can construct the bridge following this approach:\n", + "\n", + "1. Start with a plank of length 1, representing the first section of the bridge.\n", + "2. Gradually increase the length of each plank by adding a natural number length to it.\n", + "3. Connect each newly added plank to the end of the bridge to ensure a continuous structure.\n", + "The key to this construction method is adding planks of consecutive natural numbers, such as 1, 2, 3, 4, 5, and so on. This means that the bridge's length will increase according to the sequence of natural numbers, but the growth rate will be linear, i.e., f(n) = n.\n", + "\n", + "Therefore, we can use planks of length f(n) = n to build the bridge, ensuring that the bridge's length increases at the slowest possible rate because the growth of f(n) is linear." + ] + }, + { + "cell_type": "raw", + "id": "ce964601-7be0-414c-b3b6-df080bc844fb", + "metadata": {}, + "source": [ + "Q6 (5 Points)\n", + "One algorithm requires 2^n seconds and another algorithm requires n^2 seconds. Which one grows\n", + "asymptotically faster? That is, which grows faster as n gets large? What is the cross-over value of n? (The\n", + "value at which the curves intersect)?\n", + "\n", + "Solution:\n", + "The first algorithm, 2^n is asymptotically faster than the second one, and the cross-over point of n is 4." + ] + }, + { + "cell_type": "markdown", + "id": "ea82f250-8c41-4f43-8bea-1ea74f1c8eac", + "metadata": {}, + "source": [ + "![pic](pic.png)" + ] + }, + { + "cell_type": "raw", + "id": "468c3257-5c8a-466f-a396-d0a3df8cc1b5", + "metadata": {}, + "source": [ + "Q7 In a small town, there are 3 men (A, B, C) and 3 women (X, Y, Z). They each have a preference list for marriage. Can we find a stable marriage where no one can do better through divorce?\n", + "\n", + "Solution: Yes. Suppose there's a pair (A, X) who thinks they can do better by divorcing and marrying someone else. But if they divorce, the new marriages won't be stable either. So, no one can improve their situation through divorce in a stable marriage." + ] + }, + { + "cell_type": "raw", + "id": "b642ad90-689d-494e-8035-be6bccd0f589", + "metadata": {}, + "source": [ + "Q8 In a small town, there are two groups of volunteers, Group A and Group b. Each group is made up of members, each with their own skill level and area of volunteer interest. Both groups wanted to devise a strategy that assigned each member to a different area of volunteering to stand out in community service. The assessment of the group's performance is based solely on the performance of its members in the chosen voluntary field. There are no other criteria for assessing team performance other than the performance of individual members in specific areas.\n", + "\n", + "To determine how well the two groups performed, they published their respective strategies (assigning members to volunteer areas). If neither group can unilaterally change its strategy to win more in community service activities, then A pair of strategies (strategy A and strategy B) is considered stable. Is there always a stable strategy for any group of team members and their skill levels?\n", + "\n", + "Solution: \n", + "Answer is no. Consider the following scenario: Group A has two members {A1, A2} with skill levels of 25 and 50 in their respective areas of volunteer service, while Group B has two members {B1, B2} with skill levels of 15 and 35 in the same area of volunteer service. Each group can choose two different strategies, which include assigning members to different areas of volunteering.\n", + "If A1 is assigned to volunteer Area B1 in the final community service event, Group B may wish to change strategy and win at least one area. Similarly, if A1 is assigned to volunteer area B2, Group A may wish to change strategy and win both areas instead of one.\n", + "This example illustrates that in certain situations, no matter which group makes its strategy public, the other group can find a way to adjust its strategy to win more in community service activities. Therefore, depending on the skill level of the group members and their strategy choices, there may not always be a stable pair of strategies." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "93296b6b-438c-4711-ae09-6de6576bf7f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Group A wins with strategy [{A1 25 Area X} {B1 15 Area X}] (Total Wins: 40)\n", + "Group B wins with strategy [{B1 15 Area X} {A1 25 Area X}] (Total Wins: 40)\n", + "Group A wins with strategy [{A1 25 Area X} {B2 35 Area Y}] (Total Wins: 60)\n", + "Group B wins with strategy [{B2 35 Area Y} {A1 25 Area X}] (Total Wins: 60)\n", + "Group A wins with strategy [{A2 50 Area Y} {B1 15 Area X}] (Total Wins: 65)\n", + "Group B wins with strategy [{B1 15 Area X} {A2 50 Area Y}] (Total Wins: 65)\n", + "Group A wins with strategy [{A2 50 Area Y} {B2 35 Area Y}] (Total Wins: 85)\n", + "Group B wins with strategy [{B2 35 Area Y} {A2 50 Area Y}] (Total Wins: 85)\n" + ] + } + ], + "source": [ + "func evaluatePerformance(strategy []Member, groupName string) int {\n", + " totalWins := 0\n", + " for _, member := range strategy {\n", + " // 在此示例中，胜利次数取决于特长评级\n", + " totalWins += member.SkillRating\n", + " }\n", + " fmt.Printf(\"%s wins with strategy %v (Total Wins: %d)\\n\", groupName, strategy, totalWins)\n", + " return totalWins\n", + "}\n", + "\n", + "type Member struct {\n", + " Name string\n", + " SkillRating int\n", + " VolunteeringArea string\n", + "}\n", + "\n", + "type Group struct {\n", + " Name string\n", + " Members []Member\n", + " Strategy []Member\n", + "}\n", + "\n", + " groupA := Group{Name: \"Group A\"}\n", + " groupB := Group{Name: \"Group B\"}\n", + "\n", + " groupA.Members = append(groupA.Members, Member{Name: \"A1\", SkillRating: 25, VolunteeringArea: \"Area X\"})\n", + " groupA.Members = append(groupA.Members, Member{Name: \"A2\", SkillRating: 50, VolunteeringArea: \"Area Y\"})\n", + " \n", + " groupB.Members = append(groupB.Members, Member{Name: \"B1\", SkillRating: 15, VolunteeringArea: \"Area X\"})\n", + " groupB.Members = append(groupB.Members, Member{Name: \"B2\", SkillRating: 35, VolunteeringArea: \"Area Y\"})\n", + "\n", + " for i := 0; i < len(groupA.Members); i++ {\n", + " for j := 0; j < len(groupB.Members); j++ {\n", + " strategyA := []Member{groupA.Members[i], groupB.Members[j]}\n", + " strategyB := []Member{groupB.Members[j], groupA.Members[i]}\n", + " \n", + " winsWithStrategyA := evaluatePerformance(strategyA, groupA.Name)\n", + " winsWithStrategyB := evaluatePerformance(strategyB, groupB.Name)\n", + " \n", + " if winsWithStrategyA > winsWithStrategyB || winsWithStrategyB > winsWithStrategyA {\n", + " fmt.Printf(\"Unstable Strategy Pair Found: %v vs %v\\n\", strategyA, strategyB)\n", + " }\n", + " }\n", + " }\n", + "\n" + ] + }, + { + "cell_type": "raw", + "id": "b0dd395f-be30-4bc2-b68e-4074fc0315fb", + "metadata": {}, + "source": [ + "Q9 The LPL (League of Legends Pro League) playoffs are adopting a new format using the Gale-Shapley matching algorithm. Instead of having the four teams from the LPL's Upper Bracket play against each other and the four teams from the Lower Bracket face off separately, they will now be matched against each other using the Gale-Shapley matching algorithm. Additionally, social media will be utilized to solicit rankings from fans, media, players, and coaches regarding which teams they would most like to compete against in the playoffs.\n", + "\n", + "A. Create a new Gale-Shapley implementation in Go to match the four teams from the Upper Bracket against the four teams from the Lower Bracket. You should generate preference lists for each team as part of the implementation.\n", + "\n", + "Solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6e684915-e696-479f-8680-aeeb5a1d3466", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BLG is matched with WBG\n", + "TES is matched with OMG\n", + "JDG is matched with RNG\n", + "LNG is matched with EDG\n" + ] + } + ], + "source": [ + "import \"fmt\"\n", + "\n", + "type Team struct {\n", + "\tName string\n", + "\tPreferences []string\n", + "\tMatched string\n", + "}\n", + "\n", + "\n", + "func removeTeam(teams []Team, teamName string) []Team {\n", + "\tresult := []Team{}\n", + "\tfor _, team := range teams {\n", + "\t\tif team.Name != teamName {\n", + "\t\t\tresult = append(result, team)\n", + "\t\t}\n", + "\t}\n", + "\treturn result\n", + "}\n", + "\n", + "func findTeam(teams []Team, teamName string) *Team {\n", + "\tfor _, team := range teams {\n", + "\t\tif team.Name == teamName {\n", + "\t\t\treturn &team\n", + "\t\t}\n", + "\t}\n", + "\treturn nil\n", + "}\n", + "\n", + "func indexOf(slice []string, item string) int {\n", + "\tfor i, value := range slice {\n", + "\t\tif value == item {\n", + "\t\t\treturn i\n", + "\t\t}\n", + "\t}\n", + "\treturn -1\n", + "}\n", + "\tupperTeams := []Team{\n", + "\t\t{Name: \"BLG\", Preferences: []string{\"WBG\", \"OMG\", \"EDG\", \"RNG\"}},\n", + "\t\t{Name: \"JDG\", Preferences: []string{\"OMG\", \"WBG\", \"RNG\", \"EDG\"}},\n", + "\t\t{Name: \"LNG\", Preferences: []string{\"RNG\", \"OMG\", \"WBG\", \"EDG\"}},\n", + "\t\t{Name: \"TES\", Preferences: []string{\"OMG\", \"RNG\", \"EDG\", \"WBG\"}},\n", + "\t}\n", + "\n", + "\tlowerTeams := []Team{\n", + "\t\t{Name: \"WBG\", Preferences: []string{\"OMG\", \"JDG\", \"LNG\", \"TES\"}},\n", + "\t\t{Name: \"OMG\", Preferences: []string{\"TES\", \"BLG\", \"JDG\", \"LNG\"}},\n", + "\t\t{Name: \"EDG\", Preferences: []string{\"LNG\", \"TES\", \"BLG\", \"JDG\"}},\n", + "\t\t{Name: \"RNG\", Preferences: []string{\"JDG\", \"LNG\", \"TES\", \"BLG\"}},\n", + "\t}\n", + "\n", + "\tmatching := make(map[string]string)\n", + "\tfor len(upperTeams) > 0 {\n", + "\t\tfor _, upperTeam := range upperTeams {\n", + "\t\t\tpreferredLowerTeam := upperTeam.Preferences[0]\n", + "\t\t\tif matching[preferredLowerTeam] == \"\" {\n", + "\t\t\t\tmatching[preferredLowerTeam] = upperTeam.Name\n", + "\t\t\t\tupperTeams = removeTeam(upperTeams, upperTeam.Name)\n", + "\t\t\t\tbreak\n", + "\t\t\t} else {\n", + "\t\t\t\tcurrentUpperTeam := matching[preferredLowerTeam]\n", + "\t\t\t\tlowerTeam := findTeam(lowerTeams, preferredLowerTeam)\n", + "\t\t\t\tif lowerTeam == nil {\n", + "\t\t\t\t\tcontinue\n", + "\t\t\t\t}\n", + "\t\t\t\tif indexOf(lowerTeam.Preferences, currentUpperTeam) > indexOf(lowerTeam.Preferences, upperTeam.Name) {\n", + "\t\t\t\t\tmatching[preferredLowerTeam] = upperTeam.Name\n", + "\t\t\t\t\tupperTeams = removeTeam(upperTeams, upperTeam.Name)\n", + "\t\t\t\t\tupperTeams = append(upperTeams, Team{currentUpperTeam, upperTeam.Preferences[1:], \"\"})\n", + "\t\t\t\t\tbreak\n", + "\t\t\t\t}\n", + "\t\t\t}\n", + "\t\t}\n", + "\t}\n", + "\n", + "\tfor lowerTeam, upperTeam := range matching {\n", + "\t\tfmt.Printf(\"%s is matched with %s\\n\", upperTeam, lowerTeam)\n", + "\t}\n" + ] + }, + { + "cell_type": "raw", + "id": "1fe93201-c136-40b7-a130-6542ac616f14", + "metadata": {}, + "source": [ + "B. Use a loop to shuffle the preference lists for upper team 100 times. Calculate the percentage of stable playoff matches." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f0fb509d-01e1-4ffe-965d-7dc2884488eb", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The percentage of stabl matching: 100.00%" + ] + }, + { + "data": { + "text/plain": [ + "41 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import (\n", + "\t\"fmt\"\n", + "\t\"math/rand\"\n", + ")\n", + "func shufflePreferences(teams []Team) {\n", + "\trand.Shuffle(len(teams), func(i, j int) {\n", + "\t\tteams[i].Preferences, teams[j].Preferences = teams[j].Preferences, teams[i].Preferences\n", + "\t})\n", + "}\n", + "\n", + "func isStableMatching(matching map[string]string) bool {\n", + "\tfor upperTeam, lowerTeam := range matching {\n", + "\t\tfor otherUpperTeam, otherLowerTeam := range matching {\n", + "\t\t\tif upperTeam != otherUpperTeam && lowerTeam == otherLowerTeam {\n", + "\t\t\t\treturn false\n", + "\t\t\t}\n", + "\t\t}\n", + "\t}\n", + "\treturn true\n", + "}\n", + "stableCount := 0\n", + "\ttotalRuns := 100\n", + "\n", + "\tfor i := 0; i < totalRuns; i++ {\n", + "\t\tshufflePreferences(upperTeams)\n", + "\n", + "\t\tmatching := make(map[string]string)\n", + "\t\tfor len(upperTeams) > 0 {\n", + "\t\t\tfor _, upperTeam := range upperTeams {\n", + "\t\t\t\tif len(upperTeam.Preferences) == 0 {\n", + "\t\t\t\t\tbreak\n", + "\t\t\t\t}\n", + "\t\t\t\tpreferredLowerTeam := upperTeam.Preferences[0]\n", + "\t\t\t\tif matching[preferredLowerTeam] == \"\" {\n", + "\t\t\t\t\tmatching[preferredLowerTeam] = upperTeam.Name\n", + "\t\t\t\t\tupperTeams = removeTeam(upperTeams, upperTeam.Name)\n", + "\t\t\t\t\tbreak\n", + "\t\t\t\t} else {\n", + "\t\t\t\t\tcurrentUpperTeam := matching[preferredLowerTeam]\n", + "\t\t\t\t\tlowerTeam := findTeam(lowerTeams, preferredLowerTeam)\n", + "\t\t\t\t\tif lowerTeam == nil {\n", + "\t\t\t\t\t\tcontinue\n", + "\t\t\t\t\t}\n", + "\t\t\t\t\tif indexOf(lowerTeam.Preferences, currentUpperTeam) > indexOf(lowerTeam.Preferences, upperTeam.Name) {\n", + "\t\t\t\t\t\tmatching[preferredLowerTeam] = upperTeam.Name\n", + "\t\t\t\t\t\tupperTeams = removeTeam(upperTeams, upperTeam.Name)\n", + "\t\t\t\t\t\tupperTeams = append(upperTeams, Team{currentUpperTeam, upperTeam.Preferences[1:], \"\"})\n", + "\t\t\t\t\t\tbreak\n", + "\t\t\t\t\t}\n", + "\t\t\t\t}\n", + "\t\t\t}\n", + "\t\t}\n", + "\n", + "\t\tif isStableMatching(matching) {\n", + "\t\t\tstableCount++\n", + "\t\t}\n", + "\t}\n", + "\n", + "\tstablePercentage := float64(stableCount) / float64(totalRuns) * 100\n", + "\tfmt.Printf(\"The percentage of stabl matching: %.2f%%\", stablePercentage)\n" + ] + }, + { + "cell_type": "raw", + "id": "86ed950b-b575-4a08-9833-535c4455f0c0", + "metadata": {}, + "source": [ + "C. Is it possible to maintain a stable match during the knockout process?\n", + "\n", + "Solution\n", + "Yes, it is possible to maintain a stable match during the knockout process. The stability of the match depends on how the knockout process is designed and executed. By carefully organizing the matchups and ensuring that the principles of stability are upheld, a stable match can be maintained even as teams are eliminated in each round of the knockout process." + ] + }, + { + "cell_type": "raw", + "id": "b319d9b1-92eb-40ff-a6e5-31e7fa160d33", + "metadata": {}, + "source": [ + "D. If the upper and lower halves are not considered, can this algorithm still obtain stable matching? If yes, please prove, if not, please give a counterexample\n", + "\n", + "Solution\n", + "If we only consider matching teams without distinguishing between upper and lower halves, using just the Gale-Shapley algorithm may not always guarantee stable matches. This means that there can be situations where teams may prefer each other over their current matches and change partners, leading to instability.\n", + "\n", + "For instance, imagine we have two halves of teams, and their preferences are as follows:\n", + "\n", + "Half 1: Prefers Half 2 teams over its own.\n", + "Half 2: Prefers Half 1 teams over its own.\n", + "If we apply the Gale-Shapley algorithm without considering the halves, teams may keep changing their matches, resulting in instability. This shows that when not distinguishing between upper and lower halves, stable matching is not always ensured." + ] + }, + { + "cell_type": "raw", + "id": "1dfc50bc-a891-41b3-936b-460ce90571c4", + "metadata": {}, + "source": [ + "E. What is the time complexity of this algorithm, and how does the execution time change as the number of teams increases?\n", + "\n", + "Solution:\n", + "The time complexity is O(n^2), where n is the number of teams in a half zone. As n gets bigger, the running time increases dramatically, because this is the quadratic function" + ] + }, + { + "cell_type": "markdown", + "id": "4668cd6f-cce3-4d86-a27d-5d4352aa925c", + "metadata": {}, + "source": [ + "## Reflection：" + ] + }, + { + "cell_type": "raw", + "id": "1e10d1cd-a6f2-4e5b-aea6-0a29f1808dec", + "metadata": {}, + "source": [ + "1. I used ChatGPT to read, to deepen my understanding of the problem, I tried to get it to tell me what the field of the problem was, what the nature of the problem was, and then after figuring it out, I went on to ask him if there were any other similar questions, and then I read and understood deeply, and then created my own questions and answered them. I also tried to use chatGPT to answer my questions. Interestingly, I found that chatGPT always gave me different answers, but I ultimately chose to stick with my answers.\n", + "\n", + "2. I encountered many problems and challenges in this process. First, I often couldn't understand the meaning of the questions, for example, I didn't know what Omega and theta meant except for big O. It took me a long time to use chatGPT to figure out what the questions were asking. Then I found it difficult to ask similar questions, and I didn't know much about these kinds of questions. Finally, another difficulty is that when I use chatGPT to answer my questions, it sometimes gives different answers from me, which I think is wrong, such as the first question of time complexity ranking.\n", + "\n", + "3. The first thing I've learned is clarity, and questions that aren't clear can be difficult to understand. Then there is the skill of breaking down complex problems into simpler, more manageable sub-problems. Then, you need to add some constraints to the design process to make the problem more rigorous. Then, for algorithmic problems, we should be good at understanding the essence, so that we can solve this kind of problem. Finally, the algorithm problem must analyze the complexity of the algorithm, which is the core of the algorithm in my opinion." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Go", + "language": "go", + "name": "gophernotes" + }, + "language_info": { + "codemirror_mode": "", + "file_extension": ".go", + "mimetype": "", + "name": "go", + "nbconvert_exporter": "", + "pygments_lexer": "", + "version": "go1.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/002734572_Douhao_Ma/pic.png b/Submissions/002734572_Douhao_Ma/pic.png new file mode 100644 index 0000000..e6ac814 Binary files /dev/null and b/Submissions/002734572_Douhao_Ma/pic.png differ diff --git a/Submissions/002748800_Jhalak_Surve/002748800_Assignment1.ipynb b/Submissions/002748800_Jhalak_Surve/002748800_Assignment1.ipynb new file mode 100644 index 0000000..f5f4f2b --- /dev/null +++ b/Submissions/002748800_Jhalak_Surve/002748800_Assignment1.ipynb @@ -0,0 +1,1435 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 1\n", + "# Algorithm Question Design with ChatGPT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q1.
Analysis of Sample Problem

\n", + "\n", + "The sample problem is to arrange a given list of functions in increasing order of their growth rates. The growth rate of each function is determined by its behavior as the input size 'n' becomes increasingly large. The problem asks for a ranking of these functions based on their growth rates, from the slowest-growing to the fastest-growing.\n", + "
\n", + "
\n", + "Input Format:\n", + "
\n", + "A list of functions, each represented as a mathematical expression.\n", + "
\n", + "The value 'n,' which represents the input size, can be considered as a positive integer.\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "The functions sorted in increasing order of their growth rates.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "
\n", + "The solution to this problem involves comparing and ranking functions based on their growth rates, which is often expressed using Big O notation. The provided solution ranks the functions and justifies their rankings using Big O notation and mathematical analysis.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "
\n", + "Algorithmic Complexity Analysis, Big O Notation, Comparing Efficiency\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: Optimal Data Structure Selection

\n", + "\n", + "
Problem Statement:
\n", + "You are a software engineer working on a project that requires processing large datasets. As you optimize your code, you realize that the choice of data structures can significantly impact performance. Your task is to determine the most suitable data structure for a given scenario based on algorithmic analysis.\n", + "
\n", + "
\n", + "Write a function select_optimal_data_structure(scenarios) that takes a list of scenarios, each representing a specific data processing task. For each scenario, you must choose the most suitable data structure (e.g., list, set, dictionary, stack, queue) based on its time and space complexity requirements.\n", + "
\n", + "
\n", + "Each scenario is represented as a dictionary with the following properties:\n", + "\n", + "\"task\": a string describing the data processing task.
\n", + "\"time_complexity\": a string representing the desired time complexity in Big O notation (e.g., \"O(1)\", \"O(log n)\", \"O(n)\").
\n", + "\"space_complexity\": a string representing the desired space complexity in Big O notation (e.g., \"O(1)\", \"O(n)\").
\n", + "Your task is to select the most appropriate data structure for each scenario, considering both time and space complexities.\n", + "
\n", + "
\n", + "Input Format:\n", + "
\n", + "
\n", + "A list of dictionaries 'scenarios', where each dictionary represents a data processing scenario with a description, desired time complexity, and desired space complexity.\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "A list of strings: the names of the selected data structures for each scenario, following the order of the input scenarios.\n", + "
\n", + "
\n", + "Sample Input:\n", + "
\n", + "
\n", + "scenarios = [\n", + " {\"task\": \"Count unique elements\", \"time_complexity\": \"O(1)\", \"space_complexity\": \"O(n)\"},\n", + " {\"task\": \"Search for specific values\", \"time_complexity\": \"O(log n)\", \"space_complexity\": \"O(n)\"},\n", + " {\"task\": \"FIFO data processing\", \"time_complexity\": \"O(1)\", \"space_complexity\": \"O(n)\"},\n", + "]\n", + "
\n", + "
\n", + "Sample Output:\n", + "
\n", + "
\n", + "[\"set\", \"sorted list\", \"queue\"]\n", + "
\n", + "
\n", + "Constraints:\n", + "
\n", + "1. The input list of scenarios contains at least one scenario.\n", + "
\n", + "2. The time and space complexities specified in scenarios are valid Big O notations.\n", + "
\n", + "3. The problem involves selecting data structures based on algorithmic analysis and complexity requirements, providing a unique context for algorithmic decision-making.\n", + "
\n", + "
\n", + "Solution/PseudoCode:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def select_optimal_data_structure(scenarios):\n", + " optimal_data_structures = []\n", + "\n", + " for scenario in scenarios:\n", + " task = scenario[\"task\"]\n", + " time_complexity = scenario[\"time_complexity\"]\n", + " space_complexity = scenario[\"space_complexity\"]\n", + "\n", + " # Initialize the selected data structure as None\n", + " selected_structure = None\n", + "\n", + " # Evaluate time and space complexities and choose the optimal data structure\n", + " if time_complexity == \"O(1)\":\n", + " if space_complexity == \"O(1)\":\n", + " selected_structure = \"set\" # Efficient for constant time and space\n", + " else:\n", + " selected_structure = \"dictionary\" # Efficient for constant time but may consume more space\n", + " elif time_complexity == \"O(log n)\":\n", + " if space_complexity == \"O(1)\":\n", + " selected_structure = \"sorted list\" # Efficient for logarithmic time and constant space\n", + " else:\n", + " selected_structure = \"balanced binary search tree\" # Efficient for logarithmic time and space\n", + " elif time_complexity == \"O(n)\":\n", + " if space_complexity == \"O(1)\":\n", + " selected_structure = \"list\" # Efficient for linear time and constant space\n", + " else:\n", + " selected_structure = \"deque\" # Efficient for linear time and space\n", + " # Additional cases for other time and space complexities can be added here.\n", + "\n", + " # Append the selected data structure to the result list\n", + " optimal_data_structures.append(selected_structure)\n", + "\n", + " return optimal_data_structures\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Explanation:\n", + "\n", + "This solution iterates through each scenario, evaluates the desired time and space complexities, and selects the most suitable data structure accordingly. The selected data structures are then stored in the optimal_data_structures list, which is returned as the final output. We can extend the solution to handle additional time and space complexity cases as needed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarities with Sample problem:\n", + "\n", + "1. Algorithmic Analysis: Both problems require algorithmic analysis and decision-making based on algorithmic complexity. In the sample problem, we analyze the growth rates of functions to order them correctly, while in the new problem, we analyze the time and space complexities of data structures to select the most suitable one for each scenario.\n", + "\n", + "2. Complexity Comparison: In both problems, we must compare and evaluate the complexity of different elements (functions in the sample problem and data structures in the new problem) to make optimal choices.\n", + "\n", + "3. Optimization: Both problems involve optimization, aiming to select the options that minimize either growth rates (sample problem) or time and space complexities (new problem).\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q2.
Analysis of Sample Problem

\n", + "\n", + "The sample problem involves analyzing the relationships between two functions, f(n) and g(n), in the context of algorithmic complexity analysis.\n", + "
\n", + "
\n", + "Input Format:\n", + "
\n", + "The input for the sample problem consists of the following:
\n", + "Two functions f(n) and g(n) where f(n) is O(g(n)). These functions are not explicitly provided but are referenced in the context of statements.\n", + "
\n", + "The value 'n,' which represents the input size, can be considered as a positive integer.\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "The output for the sample problem is the evaluation of three statements. For each statement:\n", + "
\n", + "You need to determine whether the statement is true or false.
\n", + "You should provide either a proof or a counter example to support your answer.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "
\n", + "Each part of the solution is well-structured, starting with the statement being evaluated.\n", + "For false statements (Statement 1 and Statement 2), a counterexample is presented to disprove the statement.\n", + "For the true statement (Statement 3), a logical proof is provided based on the definitions of Big O and Ω notation.\n", + "The solution is concise, clear, and logically presented.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "
\n", + "Algorithmic Complexity Analysis, Growth Rate Comparison, Upper and Lower Bounds, Logical Reasoning\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: Time Complexity Guessing Game

\n", + "\n", + "
Problem Statement:
\n", + "Imagine you are hosting a game show where contestants need to guess the time complexity of algorithms based on their descriptions. You provide contestants with descriptions of five algorithms, and they must guess the corresponding time complexity (in Big O notation). Contestants win points for correct guesses.\n", + "\n", + "Here are the algorithm descriptions:\n", + "\n", + "Algorithm A (Linear Search): This algorithm searches for an element in an unsorted list one element at a time until it finds the target or reaches the end. What's the time complexity?\n", + "\n", + "Algorithm B (Bubble Sort): This sorting algorithm repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. What's the time complexity?\n", + "\n", + "Algorithm C (Quick Sort): This sorting algorithm uses a divide-and-conquer approach to sort an array or list. What's the average-case time complexity?\n", + "\n", + "Algorithm D (Matrix Multiplication): This algorithm multiplies two matrices of size n x n using nested loops. What's the time complexity?\n", + "\n", + "Algorithm E (Binary Search): This search algorithm works by repeatedly dividing the search interval in half. What's the time complexity?\n", + "
\n", + "
\n", + "Create a function guess_time_complexities() that takes a list of contestant guesses for the time complexities (e.g., [\"O(n)\", \"O(n^2)\", \"O(n log n)\", \"O(n^3)\", \"O(log n)\"]). Your function should calculate the score of each contestant and return a dictionary with contestant names as keys and their scores as values.\n", + "
\n", + "
\n", + "Input Format:\n", + "
\n", + "
\n", + "A list of strings representing contestant guesses. The list length may vary.\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "A dictionary where keys are contestant names (e.g., \"Contestant 1,\" \"Contestant 2\") and values are their respective scores.\n", + "
\n", + "
\n", + "Sample Input:\n", + "
\n", + "
\n", + "guesses = [\"O(n)\", \"O(n^2)\", \"O(n log n)\", \"O(n^3)\", \"O(log n)\"]\n", + "
\n", + "
\n", + "Sample Output:\n", + "
\n", + "
\n", + "{\n", + " \"Contestant 1\": 1,\n", + " \"Contestant 2\": 0,\n", + " \"Contestant 3\": 1,\n", + " \"Contestant 4\": 0,\n", + " \"Contestant 5\": 1\n", + "}\n", + "
\n", + "
\n", + "Constraints:\n", + "
\n", + "The input list guesses contains valid time complexity strings.\n", + "
\n", + "
\n", + "Solution/PseudoCode:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Contestant 1': 1, 'Contestant 2': 1, 'Contestant 3': 1, 'Contestant 4': 1, 'Contestant 5': 1}\n" + ] + } + ], + "source": [ + "def guess_time_complexities(guesses):\n", + " # Define the correct time complexities for the given algorithms\n", + " correct_answers = {\n", + " \"Algorithm A (Linear Search)\": \"O(n)\",\n", + " \"Algorithm B (Bubble Sort)\": \"O(n^2)\",\n", + " \"Algorithm C (Quick Sort)\": \"O(n log n)\",\n", + " \"Algorithm D (Matrix Multiplication)\": \"O(n^3)\",\n", + " \"Algorithm E (Binary Search)\": \"O(log n)\",\n", + " }\n", + "\n", + " # Initialize a dictionary to store contestant scores\n", + " contestant_scores = {}\n", + "\n", + " # Iterate through the guesses and calculate scores\n", + " for i, guess in enumerate(guesses, start=1):\n", + " # Extract the algorithm description and contestant's guessed complexity\n", + " algorithm_description, contestant_guess = guess.split(\":\")\n", + " algorithm_description = algorithm_description.strip()\n", + " contestant_guess = contestant_guess.strip()\n", + "\n", + " # Look up the correct complexity for the algorithm\n", + " correct_complexity = correct_answers.get(algorithm_description)\n", + "\n", + " # Check if the contestant's guess matches the correct complexity\n", + " if contestant_guess == correct_complexity:\n", + " # If the guess is correct, assign 1 point to the contestant\n", + " contestant_scores[f\"Contestant {i}\"] = 1\n", + " else:\n", + " # If the guess is incorrect, assign 0 points to the contestant\n", + " contestant_scores[f\"Contestant {i}\"] = 0\n", + "\n", + " return contestant_scores\n", + "\n", + "# Example usage:\n", + "guesses = [\n", + " \"Algorithm A (Linear Search): O(n)\",\n", + " \"Algorithm B (Bubble Sort): O(n^2)\",\n", + " \"Algorithm C (Quick Sort): O(n log n)\",\n", + " \"Algorithm D (Matrix Multiplication): O(n^3)\",\n", + " \"Algorithm E (Binary Search): O(log n)\",\n", + "]\n", + "\n", + "scores = guess_time_complexities(guesses)\n", + "print(scores)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Explanation:\n", + "\n", + "The solution code for the \"Time Complexity Guessing Game\" problem defines correct time complexities for five given algorithms and then iterates through a list of contestant guesses. For each guess, it extracts the algorithm description and the contestant's guessed time complexity. It looks up the correct time complexity for the algorithm and checks if the contestant's guess matches the correct complexity. Correct guesses earn contestants 1 point, while incorrect guesses earn 0 points. The code returns a dictionary containing the scores of each contestant, with their names as keys and their respective scores as values. This approach allows for the evaluation of contestant guesses in a game-like scenario where they guess time complexities for various algorithms.\n", + "\n", + "Similarities with sample problem:\n", + "\n", + "Both the sample problem and the \"Time Complexity Guessing Game\" problem are similar because they involve understanding and evaluating how computer algorithms work. \n", + "\n", + "1. In the sample problem, you compare different mathematical functions to see which one grows faster or slower. In the guessing game problem, contestants guess how fast different computer algorithms are. \n", + "\n", + "2. Both problems also require people to explain why they made their choices. So, while they have different scenarios, they both have this common theme of understanding and deciding how algorithms behave." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q3.
Analysis of Sample Problem

\n", + "\n", + "The sample problem involves assigning Computer Science students to companies in Boston based on their preferences and rankings. The main objective is to find a stable assignment where each company fills its available positions, and no student or company wants to switch if given the chance.\n", + "
\n", + "
\n", + "Input Format:\n", + "
\n", + "The input for this problem involves information about companies, students, and their rankings and preferences.\n", + "
\n", + "It includes the following key components:
\n", + "The number of companies (x).
\n", + "The number of Computer Science students (n).
\n", + "Rankings of students by companies, indicating which students each company prefers based on their academics and projects.
\n", + "Rankings of companies by students, indicating which companies each student prefers based on work and pay scale.\n", + "
\n", + "The input data would typically be organized in a structured format or data structures like arrays or matrices to represent these rankings.\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "The main output of this problem is a stable assignment of students to companies.\n", + "
\n", + "It involves specifying which student is assigned to which company in a way that all available positions in each company are filled, and no student or company wants to switch if given the chance.\n", + "
\n", + "The output can be represented as a mapping, such as a list or dictionary, that shows the assigned pairs of students and companies.\n", + "
\n", + "
\n", + "Constraints:\n", + "
\n", + "The problem mentions two critical constraints:\n", + "There are more Computer Science students (n) than there are available positions in the companies (x).\n", + "
\n", + "The assignment must be stable, meaning that no student or company should have an incentive to change their current assignment.\n", + "
\n", + "The algorithm used to find the assignment should terminate in O(mn) steps, where m is the number of companies, and n is the number of students.\n", + "
\n", + "It's assumed that the rankings and preferences provided as input are valid and consistent.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "
\n", + "The solution approach follows these main steps:
\n", + "\n", + "Start with all students being free and all companies having available positions.
\n", + "Iterate through the companies until there are companies with available positions.
\n", + "Each company offers a position to the next student based on their academic and project rankings.
\n", + "If the student is free, they accept the offer; otherwise, they evaluate their current commitment and may switch if they find a better offer.
\n", + "The algorithm repeats until all available positions are filled.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "
\n", + "Stable Matching Problem, Ranking and Preferences, Iteration and Proposals\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: The Charity Auction Matching

\n", + "\n", + "
Problem Statement:
\n", + "Imagine there is a charity event where several organizations are offering volunteer opportunities, and individuals are interested in contributing their time to these organizations. Each organization has specific roles to be filled, and they rank individuals based on their skills and dedication. Similarly, individuals have preferences for the organizations based on the cause and their interests.\n", + "
\n", + "
\n", + "Your task is to create a stable matching between individuals and organizations that ensures all volunteer opportunities are filled while satisfying stability criteria.\n", + "
\n", + "
\n", + "Input Format:\n", + "
\n", + "
\n", + "x: The number of charitable organizations.
\n", + "n: The number of individuals willing to volunteer.
\n", + "The preferences of each organization regarding individuals, ranked in order.
\n", + "The preferences of each individual regarding organizations, ranked in order.\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "An assignment of individuals to organizations that is stable (as defined in the problem statement).\n", + "
\n", + "
\n", + "Sample Input:\n", + "
\n", + "
\n", + "x = 3 (Number of charitable organizations)
\n", + "n = 4 (Number of individuals)

\n", + "\n", + "organization_preferences = {\n", + " 'Organization A': ['Individual 1', 'Individual 2', 'Individual 3', 'Individual 4'],\n", + " 'Organization B': ['Individual 2', 'Individual 3', 'Individual 1', 'Individual 4'],\n", + " 'Organization C': ['Individual 3', 'Individual 2', 'Individual 1', 'Individual 4'],\n", + "}\n", + "

\n", + "individual_preferences = {\n", + " 'Individual 1': ['Organization A', 'Organization B', 'Organization C'],\n", + " 'Individual 2': ['Organization B', 'Organization A', 'Organization C'],\n", + " 'Individual 3': ['Organization A', 'Organization C', 'Organization B'],\n", + " 'Individual 4': ['Organization A', 'Organization B', 'Organization C'],\n", + "}\n", + "
\n", + "
\n", + "Sample Output:\n", + "
\n", + "
\n", + "assignment = {\n", + " 'Organization A': 'Individual 1',\n", + " 'Organization B': 'Individual 2',\n", + " 'Organization C': 'Individual 3',\n", + "}\n", + "
\n", + "
\n", + "Constraints:\n", + "
\n", + "The number of charitable organizations (x) ranges from 1 to 20.\n", + "
\n", + "The number of individuals (n) ranges from 1 to 50.\n", + "
\n", + "Preferences are ranked lists of equal length for organizations and individuals.\n", + "
\n", + "The assignment must satisfy stability criteria.\n", + "
\n", + "The algorithm should terminate efficiently even for larger inputs.\n", + "
\n", + "
\n", + "Solution/PseudoCode:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Organization B': 'Individual 2', 'Organization C': 'Individual 3', 'Organization A': 'Individual 1'}\n" + ] + } + ], + "source": [ + "def charity_auction_matching(x, n, organization_preferences, individual_preferences):\n", + " # Initialize dictionaries to keep track of assignments\n", + " organization_assignments = {}\n", + " individual_assignments = {}\n", + "\n", + " # Initialize organizations as unmatched\n", + " unmatched_organizations = set(organization_preferences.keys())\n", + "\n", + " while unmatched_organizations:\n", + " organization = unmatched_organizations.pop()\n", + " preferred_individuals = organization_preferences[organization]\n", + "\n", + " for individual in preferred_individuals:\n", + " # Check if the individual is unmatched or prefers this organization\n", + " if (\n", + " individual not in individual_assignments\n", + " or individual_preferences[individual].index(organization)\n", + " < individual_preferences[individual].index(\n", + " individual_assignments[individual]\n", + " )\n", + " ):\n", + " # Update assignments\n", + " organization_assignments[organization] = individual\n", + " individual_assignments[individual] = organization\n", + " break\n", + "\n", + " return organization_assignments\n", + "\n", + "# Example usage:\n", + "x = 3 # Number of charitable organizations\n", + "n = 4 # Number of individuals\n", + "\n", + "organization_preferences = {\n", + " 'Organization A': ['Individual 1', 'Individual 2', 'Individual 3', 'Individual 4'],\n", + " 'Organization B': ['Individual 2', 'Individual 3', 'Individual 1', 'Individual 4'],\n", + " 'Organization C': ['Individual 3', 'Individual 2', 'Individual 1', 'Individual 4'],\n", + "}\n", + "\n", + "individual_preferences = {\n", + " 'Individual 1': ['Organization A', 'Organization B', 'Organization C'],\n", + " 'Individual 2': ['Organization B', 'Organization A', 'Organization C'],\n", + " 'Individual 3': ['Organization A', 'Organization C', 'Organization B'],\n", + " 'Individual 4': ['Organization A', 'Organization B', 'Organization C'],\n", + "}\n", + "\n", + "assignments = charity_auction_matching(x, n, organization_preferences, individual_preferences)\n", + "print(assignments)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Explanation:\n", + "\n", + "This code implements the Gale-Shapley algorithm to find a stable matching between organizations and individuals based on their preferences. It iteratively assigns individuals to organizations, ensuring stability and that each organization gets its preferred volunteers while maximizing overall satisfaction.\n", + "\n", + "Similarities with sample problem:\n", + "\n", + "1. Both the sample problem and the \"Charity Auction Matching\" problem involve matching entities (students-companies or individuals-organizations) based on their preferences. The goal is to make these matches stable, meaning that no one wants to change their partner. This is similar to finding the best couples in a dating scenario.\n", + "\n", + "2. The problems also require finding these matches efficiently, like speed dating for optimal results. In the sample problem, it's about sorting functions, and in the new problem, it's about matching volunteers to organizations.\n", + "\n", + "Overall, both problems use a similar concept of matchmaking, where everyone ends up happy with their partner, whether it's students and companies or volunteers and organizations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q4.
Analysis of Sample Problem

\n", + "You have two algorithms, one that takes 16 * log2(n) microseconds and another that takes √n microseconds to execute. The question is which algorithm is asymptotically faster, and at what value of n do they cross over in terms of performance.\n", + "
\n", + "
\n", + "Solution:\n", + "
\n", + "
\n", + "The problem asks us to compare the efficiency of two algorithms as the input size (n) grows larger.\n", + "
\n", + "The first algorithm takes 16 * log2(n) microseconds to run.\n", + "The second algorithm takes √n microseconds to run.\n", + "

\n", + "The solution approach is straightforward:\n", + "
\n", + "We compare the growth rates of these two functions.\n", + "We find the point at which they have roughly equal performance.\n", + "The conclusion is that the first algorithm is faster in the long run, and they perform equally well when n is around 65536. Beyond that, the first algorithm is the better choice for larger n values.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "

\n", + "Time Complexity Analysis, Big O Notation, Order of Growth, Crossover Point\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: The Data Compression Dilemma

\n", + "\n", + "
Problem Statement:
\n", + "In a data compression competition, two algorithms, Algorithm X and Algorithm Y, are competing to compress a dataset. Each algorithm has its own compression ratio and speed. Your task is to determine which algorithm is more efficient for a given dataset size and find the crossover point where one algorithm becomes more efficient than the other.\n", + "

\n", + "Input:\n", + "
\n", + "
\n", + "dataset_size: The size of the dataset to be compressed in megabytes (MB).
\n", + "compression_ratio_X: The compression ratio of Algorithm X (a decimal number).
\n", + "compression_ratio_Y: The compression ratio of Algorithm Y (a decimal number).
\n", + "compression_speed_X: The time it takes for Algorithm X to compress the dataset in seconds (a positive decimal number).
\n", + "compression_speed_Y: The time it takes for Algorithm Y to compress the dataset in seconds (a positive decimal number).\n", + "
\n", + "
\n", + "Output:\n", + "

\n", + "The name of the algorithm that is more efficient for compressing the given dataset size.
\n", + "The crossover point c at which the more efficient algorithm changes (in megabytes).\n", + "

\n", + "Sample Input:
\n", + "dataset_size = 1000 (1 GB)
\n", + "compression_ratio_X = 0.6
\n", + "compression_ratio_Y = 0.8
\n", + "compression_speed_X = 10 (10 seconds)
\n", + "compression_speed_Y = 5 (5 seconds)
\n", + "

\n", + "Sample Output:\n", + "
\n", + "Algorithm Y is more efficient for compressing a 1 GB dataset.
\n", + "The crossover point is 1250 MB (1.25 GB)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Approach:\n", + "\n", + "Get the Input:\n", + "
\n", + "Gather information about the dataset size, compression ratios for Algorithm X and Y, and their compression speeds.\n", + "

\n", + "Compare Efficiency:\n", + "
\n", + "Calculate how long it takes each algorithm to compress the dataset based on their speed and size.\n", + "The faster one is the more efficient algorithm.\n", + "

\n", + "Find the Crossover Point:\n", + "
\n", + "Determine when the two algorithms become equally efficient.\n", + "This is the crossover point where their performance switches.\n", + "

\n", + "Make the Decision:\n", + "
\n", + "Based on the comparison and crossover point, decide which algorithm is more efficient for the given dataset size.\n", + "

\n", + "Output the Result:\n", + "
\n", + "Communicate the decision in a clear statement.\n", + "Mention the crossover point if needed.\n", + "

\n", + "Handle Different Cases:\n", + "
\n", + "Ensure your solution works for various dataset sizes and compression parameters.\n", + "

\n", + "This approach breaks down the problem into simple steps, making it easier to determine the more efficient compression algorithm and find the crossover point." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarities with sample problem:\n", + "\n", + "1. In the sample problem, you compare how different functions grow. In the new problem, you compare two ways of compressing data to see which one is faster.\n", + "\n", + "2. Both problems want to find out which option is more efficient. In the sample problem, you want to know which function is faster as \"n\" gets bigger. In the new problem, you want to know which compression method is quicker.\n", + "\n", + "3. Crossover Point: They both look for a point where one option becomes better than the other. In the sample problem, it's a certain value of \"n.\" In the new problem, it's a specific dataset size.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q5.
Analysis of Sample Problem

\n", + "You are tasked with building a wall using rectangular bricks arranged in rows. Each row of the wall will have a certain number of bricks, and the total number of bricks used to build each row is the sum of the bricks used in the current row and the one just above it. Essentially, you're stacking rows of bricks to create a wall.\n", + "
\n", + "The goal is to build this wall as efficiently as possible, using the fewest bricks while ensuring the wall is constructed correctly.\n", + "
\n", + "
\n", + "Input Format:\n", + "

\n", + "n: This is an integer representing the total number of bricks you have or the size of the wall you want to build. It is given in megabytes (MB).\n", + "
\n", + "
\n", + "Output Format:\n", + "

\n", + "f(n): This is the result of the function that describes the slowest possible growth in the number of bricks needed to build the wall as efficiently as possible.\n", + "
\n", + "
\n", + "Constraints:\n", + "

\n", + "n should be positive.\n", + "
\n", + "f(n) should be designed to grow at a very slow rate relative to n.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "

\n", + "In this problem, the goal is to build a wall using bricks in the most efficient way possible. We introduce a function called \"f(n),\" which represents the slowest possible growth rate for the number of bricks needed as the wall size increases. We construct the wall row by row, making sure that each row contains a limited number of bricks (\"c\"). The key is to add rows in a way that uses the fewest bricks while ensuring the wall is built correctly. We determine that the optimal number of rows, \"R,\" should be less than or equal to \"1 + √(2n)\" to minimize brick usage. The space required for this efficient construction, described by \"f(n),\" is analyzed, and it's shown that the growth rate is as slow as the square root of \"n,\" which is the most efficient way to build the wall.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "

\n", + "Optimization and Efficiency, Space Complexity Analysis, Asymptotic Analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: The Token Distribution Challenge

\n", + "\n", + "
Problem Statement:
\n", + "You are responsible for distributing tokens to a group of people who have varying levels of interest in receiving tokens. Each person will receive tokens based on the number of tokens distributed to the person before them. Your objective is to devise a distribution strategy that minimizes the total number of tokens distributed while ensuring that each person receives at most a certain number of tokens.\n", + "
\n", + "
\n", + "Input Format:\n", + "

\n", + "n: The total number of people (an integer).\n", + "max_tokens_per_person: The maximum number of tokens that a person can receive (an integer).\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "The distribution strategy, specifying how many tokens each person receives.\n", + "The total number of tokens distributed.\n", + "
\n", + "
\n", + "Sample Input:\n", + "

\n", + "n = 5\n", + "max_tokens_per_person = 3\n", + "
\n", + "
\n", + "Sample Output:\n", + "

\n", + "Token Distribution Strategy: [1, 2, 3, 2, 1]\n", + "Total Number of Tokens Distributed: 9\n", + "
\n", + "
\n", + "Constraints:\n", + "

\n", + "The total number of people (�n) is a positive integer.\n", + "The maximum number of tokens per person (max_tokens_per_person) is a positive integer.\n", + "
\n", + "
\n", + "Solution/PseudoCode:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Token Distribution Strategy: [1, 1, 1, 1, 1]\n", + "Total Number of Tokens Distributed: 5\n" + ] + } + ], + "source": [ + "def distribute_tokens(n, max_tokens_per_person):\n", + " # Initialize variables\n", + " remaining_tokens = n # Total tokens available initially\n", + " distribution = [] # List to store the distribution strategy\n", + " \n", + " # Distribute tokens\n", + " for i in range(1, n + 1):\n", + " # Calculate the number of tokens to give to the current person\n", + " tokens_to_give = min(max_tokens_per_person, remaining_tokens - (n - i))\n", + " \n", + " # Update the remaining tokens\n", + " remaining_tokens -= tokens_to_give\n", + " \n", + " # Append the number of tokens given to the distribution strategy\n", + " distribution.append(tokens_to_give)\n", + " \n", + " return distribution, sum(distribution) # Return the distribution strategy and total tokens distributed\n", + "\n", + "# Example usage:\n", + "n = 5\n", + "max_tokens_per_person = 3\n", + "distribution, total_tokens_distributed = distribute_tokens(n, max_tokens_per_person)\n", + "print(\"Token Distribution Strategy:\", distribution)\n", + "print(\"Total Number of Tokens Distributed:\", total_tokens_distributed)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Explanation:\n", + "\n", + "1. We start with a certain number of tokens (let's say 5) and a list of people (5 people in this case).\n", + "\n", + "2. We go through each person one by one and give them tokens. We make sure they don't get more than 3 tokens each.\n", + "\n", + "3. We keep track of how many tokens each person gets and how many are left.\n", + "\n", + "4. We repeat this process until we've given tokens to everyone.\n", + "\n", + "5. In the end, we have a list showing how many tokens each person received, like [1, 1, 1, 1, 1], and we also know that you distributed a total of 5 tokens.\n", + "\n", + "So, the code divides tokens evenly among people, making sure no one gets more than the limit (3 tokens in this example).\n", + "\n", + "Similarities with the sample problem:\n", + "\n", + "Both problems are about dividing something among different people or entities in the best way possible. In the sample problem, it's about guessing how things relate to time, and in the other problem, it's about giving out tokens to people while making sure we don't give too many. They both have rules to follow, like not giving more tokens than allowed or making accurate guesses, and we need to come up with smart ways to do this efficiently. So, even though the situations are different, the basic idea of figuring out how to share things fairly and efficiently is the same." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q6.
Analysis of Sample Problem

\n", + "The problem statement is to compare the asymptotic growth rates of two algorithms, Algorithm A and Algorithm B, with time complexities of log2(n) seconds and √n seconds, respectively. We need to determine which algorithm grows faster as the input size 'n' becomes large and find the crossover point at which Algorithm B becomes more efficient than Algorithm A.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "

\n", + "The solution approach for this problem involves comparing the growth rates of two functions: log2(n) and √n.\n", + "

\n", + "We first recognize that √n grows faster than log2(n) as 'n' becomes large because the square root function (√n) has a faster rate of increase compared to the logarithmic function (log2(n)).\n", + "

\n", + "To find the crossover point, where Algorithm B (with √n time complexity) becomes more efficient than Algorithm A (with log2(n) time complexity), we set the two functions equal to each other and solve for 'n':\n", + "

\n", + "log2(n) = √n\n", + "

\n", + "By solving this equation, we find the value of 'n' at which Algorithm B becomes faster. In this case, the crossover point is 'n = 16'.\n", + "

\n", + "So, the solution approach involves recognizing the growth rates of the two algorithms and finding the input size at which one algorithm surpasses the other in efficiency.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "

\n", + "Algorithmic time complexity analysis, Growth Rate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: The Sorting Speed Challenge

\n", + "\n", + "
Problem Statement:
\n", + "You are comparing the performance of two sorting algorithms, Algorithm A and Algorithm B, for a range of input sizes. Algorithm A has a time complexity of O(log2(n)) seconds, while Algorithm B has a time complexity of O(sqrt(n)) seconds. Your task is to determine which algorithm is more time-efficient for sorting a given range of input sizes and find the crossover point where one algorithm becomes more efficient than the other.\n", + "
\n", + "Input Format:\n", + "

\n", + "start_size: The initial size of the input data (an integer).
\n", + "end_size: The final size of the input data (an integer).
\n", + "time_complexity_A: The time complexity of Algorithm A as a function of n (a string, e.g., \"log2(n)\").
\n", + "time_complexity_B: The time complexity of Algorithm B as a function of n (a string, e.g., \"sqrt(n)\").
\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "The name of the algorithm that is more time-efficient for sorting each input size within the given range.
\n", + "The crossover point c at which the more efficient algorithm changes (an integer).
\n", + "
\n", + "
\n", + "Sample Input:\n", + "

\n", + "start_size = 10\n", + "end_size = 100\n", + "time_complexity_A = \"n\"\n", + "time_complexity_B = \"n ^2\"\n", + "
\n", + "
\n", + "Sample Output:\n", + "
\n", + "For input size 10: Algorithm A is more time-efficient.\n", + "For input size 20: Algorithm A is more time-efficient.\n", + "For input size 30: Algorithm A is more time-efficient.\n", + "For input size 40: Algorithm A is more time-efficient.\n", + "For input size 50: Algorithm A is more time-efficient.\n", + "For input size 60: Algorithm A is more time-efficient.\n", + "For input size 70: Algorithm A is more time-efficient.\n", + "For input size 80: Algorithm A is more time-efficient.\n", + "For input size 90: Algorithm A is more time-efficient.\n", + "For input size 100: Algorithm A is more time-efficient.\n", + "The crossover point is approximately 100.\n", + "
\n", + "
\n", + "Constraints:\n", + "

\n", + "start_size and end_size are positive integers.\n", + "time_complexity_A and time_complexity_B are valid expressions involving n (e.g., \"log2(n)\", \"sqrt(n)\").\n", + "
\n", + "
\n", + "Solution/PseudoCode:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def compare_algorithms(start_size, end_size, time_complexity_A, time_complexity_B):\n", + " results = []\n", + " crossover_point = None\n", + "\n", + " for n in range(start_size, end_size + 1):\n", + " time_A = eval(time_complexity_A.replace('n', str(n)))\n", + " time_B = eval(time_complexity_B.replace('n', str(n)))\n", + "\n", + " if time_A < time_B:\n", + " results.append(f\"For input size {n}: Algorithm A is more time-efficient.\")\n", + " elif time_B < time_A:\n", + " results.append(f\"For input size {n}: Algorithm B is more time-efficient.\")\n", + " else:\n", + " results.append(f\"For input size {n}: Both algorithms have the same efficiency.\")\n", + "\n", + " if crossover_point is None and time_A > time_B:\n", + " crossover_point = n\n", + "\n", + " return results, crossover_point\n", + "\n", + "# Example usage:\n", + "start_size = 10\n", + "end_size = 100\n", + "time_complexity_A = \"n\"\n", + "time_complexity_B = \"n^2\"\n", + "\n", + "results, crossover_point = compare_algorithms(start_size, end_size, time_complexity_A, time_complexity_B)\n", + "for result in results:\n", + " print(result)\n", + "\n", + "print(f\"The crossover point is approximately {crossover_point}.\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Explanation: \n", + "\n", + "1. We have two ways to sort data: Algorithm A and Algorithm B. We want to figure out which one is better for different amounts of data and when they switch places.\n", + "\n", + "2. We check how long each algorithm takes to sort the data for different amounts of data.\n", + "\n", + "3. If Algorithm A is faster, we say \"Algorithm A is better for this amount of data.\" If Algorithm B is faster, we say \"Algorithm B is better.\" If they're equally fast, we say \"Both are the same.\"\n", + "\n", + "4. We also find the point where Algorithm A becomes better than Algorithm B.\n", + "\n", + "5. We use this information to decide which sorting method is best for different situations.\n", + "\n", + "Similarities with sample problem:\n", + "\n", + "1. The main similarity between this problem and the sample problem is that they both involve comparing the efficiency or performance of two algorithms. In the sample problem, it's about comparing the time complexities of two algorithms, while in this problem, it's about comparing the time efficiency of two sorting algorithms for different input sizes.\n", + "\n", + "2. Both problems require analyzing the behavior of algorithms as a function of some parameter (e.g., input size) and determining when one algorithm becomes more efficient than the other. They also both involve finding a crossover point or threshold where the algorithms' efficiency changes.\n", + "\n", + "In summary, the similarity lies in the comparison and analysis of algorithmic efficiency and the identification of a crossover point." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q7.
Analysis of Sample Problem

\n", + "The problem inquires whether, in a stable matching scenario, if two distinct points, let's say p and q, rank each other as their first preference, they will always be paired together to create a line segment. The statement is asking if this is true or false, and it is indeed true.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "

\n", + "The solution approach is to demonstrate the truth of the statement by explaining that if there are two distinct points, p and q, where each ranks the other as their first preference in a stable matching, they will always be paired together to form a line segment. This is shown by considering a perfect matching that includes pairs (p, q'), (p', q), and (p', q'). Since p and q prefer each other as their top choice, they will be matched together, ensuring the formation of a line segment.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "

\n", + "Stable matching in geometry" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: The Art Gallery Challenge

\n", + "\n", + "
Problem Statement:
\n", + "You are tasked with guarding an art gallery containing valuable artwork. The gallery has a layout represented as a grid, with each cell being either an open space or a wall. Your goal is to determine whether there exists a pair of locations, Location A and Location B, such that Location A is the most preferred spot for at least one security camera placement, and Location B is the most preferred spot for at least one security camera placement, and they are not guarded together in any optimal camera placement configuration.\n", + "

\n", + "Input Format:\n", + "

\n", + "gallery_layout: A 2D grid representing the art gallery, where 'O' represents an open space and 'W' represents a wall.\n", + "camera_preferences: A dictionary where each location (represented as (row, column) coordinates) maps to a list of preferred camera placement locations.\n", + "A: The coordinates of Location A as a tuple (row, column).\n", + "B: The coordinates of Location B as a tuple (row, column).\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "Either \"True\" if there exists a pair of locations (Location A, Location B) with the specified conditions, or \"False\" if no such pair exists.\n", + "
\n", + "
\n", + "Sample Input:\n", + "

\n", + "gallery_layout = [\n", + " ['O', 'O', 'O', 'O', 'W'],\n", + " ['O', 'W', 'O', 'O', 'O'],\n", + " ['O', 'W', 'O', 'O', 'O'],\n", + " ['O', 'O', 'O', 'W', 'O'],\n", + " ['O', 'O', 'O', 'O', 'W']\n", + "]\n", + "camera_preferences = {\n", + " (0, 0): [(1, 1), (2, 2), (3, 3)],\n", + " (1, 1): [(0, 0), (2, 2), (3, 3)],\n", + " (2, 2): [(0, 0), (1, 1), (3, 3)],\n", + " (3, 3): [(0, 0), (1, 1), (2, 2)],\n", + " (4, 4): [(0, 0), (1, 1), (2, 2)]\n", + "}\n", + "A = (0, 0)\n", + "B = (4, 4)\n", + "
\n", + "
\n", + "Sample Output:\n", + "

\n", + "False\n", + "
\n", + "
\n", + "Constraints:\n", + "

\n", + "The dimensions of the gallery grid do not exceed 50x50.
\n", + "Location coordinates are valid and within the dimensions of the grid.
\n", + "The preference lists are complete (contain all possible locations).\n", + "
\n", + "
\n", + "Solution/PseudoCode:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def can_guard_gallery(gallery_layout, camera_preferences, A, B):\n", + " def is_guarded(location, guards):\n", + " return any(location in camera_preferences[guard] for guard in guards)\n", + "\n", + " if not is_guarded(A, camera_preferences) or not is_guarded(B, camera_preferences):\n", + " return True # At least one location isn't the most preferred for a camera placement\n", + "\n", + " optimal_cameras = set()\n", + " for location in camera_preferences:\n", + " if is_guarded(location, optimal_cameras):\n", + " continue\n", + " if is_guarded(location, optimal_cameras | {A}):\n", + " optimal_cameras.add(location)\n", + " elif is_guarded(location, optimal_cameras | {B}):\n", + " optimal_cameras.add(location)\n", + "\n", + " return A not in optimal_cameras or B not in optimal_cameras\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Explanation:\n", + "\n", + "The solution checks if either location A or B is not the top choice for a camera. If that's the case, it means the conditions are met, and it returns \"True.\" Otherwise, it tries to find the best camera placements for all locations while considering A and B. If either A or B is left unguarded optimally, the function returns \"True.\" Otherwise, it returns \"False,\" indicating that no such pair of locations meeting the conditions exists in the gallery.\n", + "\n", + "Similarities with the sample problem:\n", + "\n", + "The similarity with the sample problem lies in the task of identifying a specific pair of locations (Location A and Location B) based on certain conditions within a given scenario. In both the sample problem and this new problem, the goal is to determine if such a pair exists by analyzing preferences and constraints." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q8.
Analysis of Sample Problem

\n", + "In this problem, we have two soccer teams, Team X and Team Y, with players having different positions and ratings. Each team aims to win matches based on player ratings for their positions. The challenge is to find strategies for each team to assign players to positions so that no team can change its strategy to win more matches. The problem asks if there's always a stable pair of strategies, and it's shown that there are situations where no stable strategy pair exists.\n", + "
\n", + "
\n", + "Input Format:\n", + "

\n", + "Two soccer teams, Team X and Team Y.
\n", + "For each team, a set of players with their ratings and positions.
\n", + "The player ratings are unique; no two players have the same rating.\n", + "
\n", + "
\n", + "Output Format:\n", + "

\n", + "Determine if there exists a stable pair of strategies for both teams.
\n", + "A stable pair of strategies means neither team can change its strategy to win more matches.
\n", + "You can either provide an algorithm to find a stable pair or an example where no stable pair exists.\n", + "
\n", + "
\n", + "Constraints:\n", + "

\n", + "The number of players and their ratings can vary.
\n", + "Player ratings are unique.
\n", + "Teams aim to win matches based on player ratings for assigned positions.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "

\n", + "The solution approach demonstrates that stable pairs don't always exist. For instance, if Team X has players with ratings 20 and 40, while Team Y has players with ratings 10 and 30 for the same positions, there's no stable pair. If Team X pairs its player with a rating of 20 against one of Team Y's players, Team Y will want to change its strategy. Conversely, if Team X pairs its player with a rating of 40, Team X will seek a strategy change. This illustrates that no stable pair of strategies exists for these teams.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "

\n", + "Strategy optimization and stability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: Roommate Compatibility Challenge

\n", + "\n", + "
Problem Statement:
\n", + "You are responsible for assigning roommates in a college dormitory. There are multiple rooms, and each room can accommodate two students. Your goal is to create a roommate assignment plan that maximizes the overall compatibility and minimizes potential conflicts between roommates.\n", + "

\n", + "Input Format:\n", + "

\n", + "A list of college students, each with a unique name.
\n", + "A compatibility score matrix, where each pair of students has a compatibility score between 0 and 100, indicating how well they get along.\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "A list of roommate assignments, pairing each student with another student.
\n", + "The overall compatibility score for the entire roommate assignment plan, which is the sum of compatibility scores for all assigned pairs.\n", + "
\n", + "
\n", + "Sample Input:\n", + "

\n", + "List of Students: [Alice, Bob, Charlie, David, Eve, Frank, Grace, Helen]\n", + "
\n", + "Compatibility Score Matrix :\n", + "[\n", + " [100, 85, 60, 75, 90, 70, 80, 95],\n", + " [85, 100, 50, 70, 80, 65, 75, 90],\n", + " [60, 50, 100, 45, 70, 55, 65, 75],\n", + " [75, 70, 45, 100, 85, 60, 70, 80],\n", + " [90, 80, 70, 85, 100, 75, 85, 95],\n", + " [70, 65, 55, 60, 75, 100, 50, 70],\n", + " [80, 75, 65, 70, 85, 50, 100, 90],\n", + " [95, 90, 75, 80, 95, 70, 90, 100]\n", + "]\n", + "
\n", + "
\n", + "Sample Output:\n", + "

\n", + "Roommate Assignments:\n", + "\n", + "Alice - Frank\n", + "Bob - Grace\n", + "Charlie - David\n", + "Eve - Helen\n", + "
\n", + "
\n", + "Constraints:\n", + "

\n", + "The number of students is even and ranges from 4 to 20.
\n", + "Compatibility scores are integers between 0 and 100, and higher values indicate better compatibility.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "
\n", + "1. Start with an empty list of roommate pairs.
\n", + "2. Keep picking the two people who get along the best and pair them up.
\n", + "3. Repeat this process until everyone has a roommate.
\n", + "\n", + "Example: Let's say you have A, B, C, D, and E as roommates, and you know how well they get along. You start by pairing A & E because they have the highest compatibility score. Then you pair B & C, and finally, D & E. Now everyone has a roommate.\n", + "
\n", + "Outcome: This method might not give us the absolute best pairing, but it's a good way to make sure everyone has a roommate they get along with quite well.\n", + "

\n", + "Similarities with the sample problem:\n", + "
\n", + "1. Both problems require forming pairs (roommates or matching students to companies) based on compatibility or preferences.\n", + "\n", + "2. The goal in both cases is to optimize the pairing to achieve the best overall outcome (maximizing compatibility or stability).\n", + "\n", + "3. In both scenarios, individuals have preferences or compatibility scores that influence the pairing decisions.\n", + "\n", + "4. Both problems can be approached algorithmically to find the best possible pairs while considering individual preferences." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Q9.
Analysis of Sample Problem

\n", + "Part A:\n", + "In this problem, we'll adapt the Gale-Shapley algorithm to match eight Western Conference teams with eight Eastern Conference teams based on their preference lists.\n", + "
\n", + "
\n", + "Part B:
\n", + "After shuffling preference lists 1000 times, we'll calculate the percentage of stable playoff matches to assess the algorithm's stability under various preferences.\n", + "
\n", + "
\n", + "Part C:
\n", + "We'll simulate playoff rounds, removing losing teams from preference lists, and investigate whether Gale-Shapley can maintain stability as we progress through different playoff stages.\n", + "
\n", + "
\n", + "Part D:
\n", + "Combining preference lists regardless of conference, we'll examine if the Gale-Shapley algorithm can still create stable matches, highlighting the challenge of asymmetric eliminations.\n", + "
\n", + "
\n", + "Part E:
\n", + "By doubling the size of preference lists multiple times, we'll measure execution time growth to understand the algorithm's scalability with larger datasets.\n", + "
\n", + "
\n", + "Solution Approach:\n", + "

\n", + "Part A: Modify Gale-Shapley: In this step, we need to create a program that matches teams based on their preferences. Each team ranks the opposing conference's teams, and the algorithm ensures stable matches.\n", + "

\n", + "Part B: We need to randomly shuffle preference lists 1000 times to simulate different ranking scenarios. After each shuffle, we need to apply the Gale-Shapley algorithm to check how often stable matches are achieved. Then, we need to calculate the percentage of stable matches to evaluate the algorithm's reliability under changing preferences.\n", + "

\n", + "Part C: We need to emulate playoff rounds by removing losing teams from the preference lists. We need to check if Gale-Shapley can adapt and maintain stable matches throughout the playoffs. This step investigates the algorithm's suitability for dynamic scenarios.\n", + "

\n", + "Part D: Combine preference lists for all teams, ignoring conferences, to create a single large list. Assess if Gale-Shapley can still create stable matches with this merged dataset. \n", + "

\n", + "Part E. Gradually increase the size of preference lists (e.g., double the size) and measure the time it takes to create stable matches. Analyze how the execution time scales with larger datasets to understand the algorithm's efficiency and performance as the input size grows.\n", + "
\n", + "
\n", + "Algorithmic Concepts Covered:\n", + "

\n", + "Gale-Shapley Algorithm, Randomization, Dynamic Matching" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

New Algorithmic Problem: The College Admissions Challenge

\n", + "\n", + "
Problem Statement:
\n", + "You are the administrator of a prestigious university, and you need to admit a group of students to your college. However, there are more qualified applicants than there are available slots. To make the admissions process fair and transparent, you decide to use the Gale-Shapley algorithm to match students to available slots.\n", + "

\n", + "Input Format:\n", + "

\n", + "A list of N students, each represented by a unique identifier (e.g., 'Student A', 'Student B', ...)
\n", + "A list of M departments or majors at your university, each represented by a unique identifier (e.g., 'Computer Science', 'Biology', ...)
\n", + "For each student, a preference list ranking the departments in order of preference
\n", + "For each department, a preference list ranking the students in order of preference
\n", + "The maximum number of slots available in each department\n", + "
\n", + "
\n", + "Output Format:\n", + "
\n", + "
\n", + "A dictionary that represents the stable matches, where department names are keys, and the values are lists of the names of the matched students.\n", + "
\n", + "
\n", + "Sample Input:\n", + "
\n", + "students = [\"Student A\", \"Student B\", \"Student C\", \"Student D\"]

\n", + "departments = [\"Computer Science\", \"Biology\", \"Physics\"]

\n", + "student_preferences = {\n", + " \"Student A\": [\"Computer Science\", \"Biology\", \"Physics\"],\n", + " \"Student B\": [\"Biology\", \"Computer Science\", \"Physics\"],\n", + " \"Student C\": [\"Physics\", \"Biology\", \"Computer Science\"],\n", + " \"Student D\": [\"Computer Science\", \"Physics\", \"Biology\"],\n", + "}

\n", + "department_preferences = {\n", + " \"Computer Science\": [\"Student A\", \"Student D\", \"Student B\", \"Student C\"],\n", + " \"Biology\": [\"Student B\", \"Student C\", \"Student A\", \"Student D\"],\n", + " \"Physics\": [\"Student C\", \"Student B\", \"Student A\", \"Student D\"],\n", + "}\n", + "

\n", + "max_slots = {\n", + " \"Computer Science\": 2,\n", + " \"Biology\": 1,\n", + " \"Physics\": 2,\n", + "}\n", + "

\n", + "Sample Output:\n", + "

\n", + "{\n", + "\"Computer Science\": [\"Student A\", \"Student D\"],\n", + "\"Biology\": [\"Student B\"],\n", + "\"Physics\": [\"Student C\", \"Student B\"],\n", + "}\n", + "
\n", + "
\n", + "Constraints:\n", + "
\n", + "There may be ties in the rankings, where multiple students or departments have the same preference rank.\n", + "
\n", + "
\n", + "Solution/Pseudocode:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'1': 'A', '2': 'C', '3': 'B'}\n" + ] + } + ], + "source": [ + "def stable_matching(colleges, students, college_preferences, student_preferences):\n", + " college_assignments = {} # Dictionary to store college assignments\n", + " student_assignments = {} # Dictionary to store student assignments\n", + " free_students = list(students) # List of unassigned students\n", + " \n", + " while free_students:\n", + " student = free_students[0] # Select the first free student\n", + " student_pref_list = student_preferences[student] # Get student's preference list\n", + " \n", + " for college in student_pref_list:\n", + " current_assignment = college_assignments.get(college)\n", + " \n", + " if current_assignment is None: # College is unassigned\n", + " college_assignments[college] = student\n", + " student_assignments[student] = college\n", + " free_students.remove(student)\n", + " break\n", + " elif student_pref_list.index(student) < student_pref_list.index(current_assignment):\n", + " college_assignments[college] = student\n", + " student_assignments[student] = college\n", + " college_assignments[current_assignment] = None\n", + " free_students.append(current_assignment)\n", + " free_students.remove(student)\n", + " break\n", + " \n", + " return student_assignments\n", + "\n", + "# Example usage:\n", + "colleges = ['A', 'B', 'C']\n", + "students = ['1', '2', '3']\n", + "college_preferences = {\n", + " 'A': ['1', '2', '3'],\n", + " 'B': ['2', '1', '3'],\n", + " 'C': ['1', '3', '2']\n", + "}\n", + "student_preferences = {\n", + " '1': ['A', 'B', 'C'],\n", + " '2': ['C', 'A', 'B'],\n", + " '3': ['B', 'A', 'C']\n", + "}\n", + "\n", + "result = stable_matching(colleges, students, college_preferences, student_preferences)\n", + "print(result)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Solution Explanation:\n", + "\n", + "The solution approach uses the Gale-Shapley algorithm to match students to colleges fairly and efficiently in the College Admissions Challenge. It begins with initializing data structures and iterates through students' preference lists, assigning them to their top-choice colleges if available or reassigning when necessary. This process continues until all students are assigned, ensuring stable and preference-respecting college-student assignments.\n", + "\n", + "Similarities with the sample problem:\n", + "\n", + "The College Admissions Challenge shares similarities with the sample problem in that it employs the Gale-Shapley algorithm to achieve stable and fair assignments. Just like the stable matching of teams to play in the NBA playoffs, this problem seeks to match students to colleges based on preferences while ensuring that the matches are stable and satisfy both sides' preferences. The core algorithmic concept of using Gale-Shapley remains consistent between the two problems, emphasizing the importance of fair and stable matching in different scenarios." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reflection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How ChatGPT Helped:\n", + "\n", + "ChatGPT played a crucial role in helping me throughout the problem design process. It provided valuable guidance and ideas that helped me refine my initial problem concepts. This collaborative interaction with an AI tool proved effective in generating innovative solutions.

\n", + "One of its significant contributions was its ability to simplify complex ideas. It aided me in breaking down the core aspects of the sample problem and identifying the fundamental algorithmic principles it encompassed. This clarity was essential for creating a new problem that retained the same essence.

\n", + "Moreover, ChatGPT served as an educational resource. It offered explanations and directed me to relevant algorithms and data structures, enhancing my comprehension of the sample problem and the broader field of algorithms.\n", + "

\n", + "\n", + "Challenges Encountered:\n", + "\n", + "The primary difficulty I faced was finding the right equilibrium between similarity and originality. While my goal was to craft a problem similar to the sample, I aimed to avoid duplication. That is why I had to do a thorough analysis of the sample problem to identify its essential components and structure.

\n", + "Ensuring that the new problem was not overly straightforward posed another challenge. I had to guarantee that it was suitably intricate to evaluate crucial algorithmic concepts while remaining solvable within a reasonable time frame.

\n", + "Additionally, I faced some problems with the task of presenting a clear problem statement. It was vital to communicate the problem's requirements without ambiguity, enabling participants to grasp and tackle it effectively.\n", + "

\n", + "\n", + "Insights on Problem Design:\n", + "\n", + "Designing algorithmic problems showed me how crucial it is to be clear and precise when describing problems. If a problem is unclear, it can confuse people and make it harder to find solutions.

\n", + "It's also important to provide solutions that are easy to understand and make sense. This means using clear pseudocode or code examples that not only solve the problem but also show how the algorithm works. These examples help people understand what's expected.

\n", + "This experience taught me how to create problems that are different from others but still focus on the basics. It showed me the value of carefully analyzing problems and coming up with creative ideas. This way, participants can be both challenged and educated about algorithms." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002748800_Jhalak_Surve/002748800_Jhalak_Surve.readme b/Submissions/002748800_Jhalak_Surve/002748800_Jhalak_Surve.readme new file mode 100644 index 0000000..f7cf007 --- /dev/null +++ b/Submissions/002748800_Jhalak_Surve/002748800_Jhalak_Surve.readme @@ -0,0 +1,32 @@ +# Firstname - Jhalak +# LastName - Surve +# NU_ID - 002748800 + +# Assignment 1 - INFO 6205 + +The assignment focused on Algorithm Question Design using ChatGPT. +It required us to create a new algorithmic problem that aligned with the essence and structure of a provided sample problem. +The assignment consisted of several key steps, including analyzing the sample problem, using AI tools like ChatGPT for idea generation, formulating the problem statement with clear specifications, providing a solution approach, and reflecting on the process. + +Learnings from the assignment - +- Alogorithmic Analysis +- Big O notation +- Time Complexity Analysis +- Gale Shapely Algorithm + +For each Question, I have first analyzed the provided example problem. I have tried to mention: +- the problem summary +- the input and output formats for the problem +- the constraints - +- the solution approach +- what algorithmic concepts does the problem utilizes. + +For each new problem that I have created, I have tried to include: +- a clear problem description +- input and output formats +- constraints +- Sample input and output +- Solution/ Pseudocode +- Similarities with the example problem + +At last, I have included a reflection on how chatgpt helped with this assignment, what all challenges I faced and what all things I learned about algorithm design from this assignment. \ No newline at end of file diff --git a/Submissions/002749496_Zhijun_Yu/License_Zhijun_Yu.txt b/Submissions/002749496_Zhijun_Yu/License_Zhijun_Yu.txt new file mode 100644 index 0000000..16c3863 --- /dev/null +++ b/Submissions/002749496_Zhijun_Yu/License_Zhijun_Yu.txt @@ -0,0 +1,7 @@ +Copyright <2023> + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/Submissions/002749496_Zhijun_Yu/ReadMe_Zhijun_Yu.txt b/Submissions/002749496_Zhijun_Yu/ReadMe_Zhijun_Yu.txt new file mode 100644 index 0000000..14ade17 --- /dev/null +++ b/Submissions/002749496_Zhijun_Yu/ReadMe_Zhijun_Yu.txt @@ -0,0 +1,5 @@ +The problems I create with solutions are in the file Zhijun_Yu_002749496.ipynb +The reflection of this assignment is also in the file Zhijun_Yu_002749496.ipynb + +Name: Zhijun Yu +NUID: 002749496 \ No newline at end of file diff --git a/Submissions/002749496_Zhijun_Yu/Zhijun_Yu_002749496.ipynb b/Submissions/002749496_Zhijun_Yu/Zhijun_Yu_002749496.ipynb new file mode 100644 index 0000000..fdcdd07 --- /dev/null +++ b/Submissions/002749496_Zhijun_Yu/Zhijun_Yu_002749496.ipynb @@ -0,0 +1,615 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35962585", + "metadata": {}, + "source": [ + "# INFO 6205 Assignment 1" + ] + }, + { + "cell_type": "markdown", + "id": "88a3b285", + "metadata": {}, + "source": [ + "Q1 (15 Points) Arrange the following functions in increasing order of growth:\n", + "• log(333n)\n", + "• nlog(n)\n", + "• log(n^3)\n", + "• n^2.5+n^1.1+2023\n", + "• 2023+0.5^n\n", + "• log(log(n))\n", + "• n!\n", + "• log(n!)\n", + "• n/(50log(n))\n", + "• 20^n+40^n\n", + "• (n^3)*log(n)\n", + "• (3^n)*log(n)\n", + "• (log(n))^2\n", + "• n*(log(n))^2\n" + ] + }, + { + "cell_type": "markdown", + "id": "b4dec5b5", + "metadata": {}, + "source": [ + "SOL:\n", + "\n", + "1. Constant and Exponential Decay: \n", + "2023+(1/2)^n\n", + "As n approaches positive infinity, (1/2)^n will approach zero positive, so this function becomes close to a constant function. Among all functions in the list, it grows most slowly.\n", + "2. Nested Logarithm:\n", + "log(log(n))\n", + "This grows more slowly than non-nested logarithmic function. To prove it, we can first calculate the derivatives respectively. Use the chain rule to calculate the derivative of log(log(n)). Since the base of logrithm is not specified, if base is e, then derivative is 1/(nlog(n)); if base is 10, then derivative is (1/(ln10)^2)* (1/(nlog(n))). Calculate the derivative of log(n), if base is e, then derivative is 1/n; if base is 10, then derivative is (1/(nln10)). Therefore, the dominant part in each derivative to compare is (1/(nlog(n))) and 1/n. When n approaches positive infinite, since the functions are continuous on (1,+∞), the derivative value of log(log(n)) at a point approaching infinity less than that of log(n) (there can be a very little slot that log(log(n)) grows faster, but generally in most part of the domain log(n) grows faster), thus, generally log(log(n)) grows more slowly than log(n), as n approaches sufficiently large, the trend is more clear. The derivative calculation for next several comparisons will be trival.\n", + "3. Logarithmic Functions:\n", + "log(333n),log(n^3),(log(n))^2\n", + "Notice that log(333n) = log(333)+log(n) = constant+log(n) is obviously Θ(log(n));\n", + "log(n^3) = 3 * log(n) is also Θ(log(n)) but increases faster than log(333n);\n", + "(log(n))^2 grows faster than the above two because it's log(n) is squared, when n approaches infinity, (log(n))^2 will have two positive infinity multiplying with each other, so it grows faster than log(n^3). After calculating the derivatives, we can get 2log(n)/n. Notice that there may be a little slot (when n is a small positive number) that log(n^3) grows faster, but the overall trend (when n approaches infinity) is that (log(n))^2 grows faster in the long term.\n", + "4. Linear-Logarithmic Function:\n", + "n/(50log(n))\n", + "As n approaches infinity, log(n) also goes to infinity, but at a much slower rate than n itself. Therefore, the overall function n/(50log(n)) grows towards infinity as n becomes very large, albeit more slowly than a linear function would. For n/(50log(n)) and (log(n))^2, we can take the ratio and simplify: n/(50* (log(n))^3). As \n", + "n approaches infinity, the denominator (log(n))^3 grows much slower than n. Therefore, n/(50log(n)) grows faster as n approaches infinity.\n", + "5. Linearithmic Functions: \n", + "nlog(n), n*(log(n))^2\n", + "As we mentioned before, n/(50log(n)) grows slower than linear functions. In this case, n/(50log(n)) grows slower than nlog(n); obviously, nlog(n) grows slower than n*(log(n))^2 as well.\n", + "6. Polynomial Function:\n", + "n^2.5+n^1.1+2023\n", + "This function is the polynomial function that grows faster than linearithmic functions. n^2.5 dominates this sum in terms of growth (power function model), and this function is Θ(n^2.5).\n", + "7. Polynomial-Logarithmic Function:\n", + "(n^3)* log(n)\n", + "Obviously, this function grows faster than n^2.5+n^1.1+2023. When n approaches infinity, n^3* log(n) undoubtedly grows faster than n^2.5+n^1.1+2023 because n^3 grows much faster than n^2.5 when n approaches positive infinity, and log(n) as a factor of n^3 activates the n^3 greatly. you can also calculate the derivatives to formally prove it.\n", + "8. Exponential Function with Log Factor: \n", + "(3^n)* log(n)\n", + "Since the exponential function grows faster than polynomial function, (3^n)* log(n) undoubtedly grows faster than last function which is (n^3)* log(n) when n approaches positive infinity.\n", + "9. Exponential Functions:\n", + "20^n+40^n\n", + "40^n dominates this sum; this function is Θ(40^n), which grows faster than (3^n)* log(n). The rule also could be drawn by calculating and compare the derivative.\n", + "10. Logarithmic Factorial:\n", + "log(n!)\n", + "Such function grows faster than any exponential function but slower than the factorial function.\n", + "11. Factorial Function:\n", + "n!\n", + "This is obviously the fastest-growing function in the list.\n", + "\n", + "Therefore, in conclusion, the functions in increasing order of growth could be arranged as:\n", + "2023+(1/2)^n, log(log(n)), log(333n), log(n^3), (log(n))^2, n/(50log(n)), nlog(n), n*(log(n))^2, n^2.5+n^1.1+2023, (n^3)* log(n), (3^n)* log(n), 20^n+40^n, log(n!), n!\n" + ] + }, + { + "cell_type": "markdown", + "id": "382aa202", + "metadata": {}, + "source": [ + "Q2 (10 Points)\n", + "Assume that you have function f and g such that f(n) is O(g(n)). For each of the following statements decide whether it is true or false and give a proof or counter example.\n", + "Statement 1: 2^f(n) is O(2^g(n))\n", + "Statement 2: f(n)+g(n) = O(g(n))\n", + "Statement 3: If f(n) is O(g(n)), then g(n) is Omega(f(n))\n", + "Statement 4: f(n) * g(n) is O(g(n)^2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5c26302f", + "metadata": {}, + "source": [ + "SOL: \n", + "For Statement 1, it is false. Consider f(n) = n and g(n) = n+1. Even though f(n) is O(g(n)), 2^n is not O(2^(n+1)) because the base is the same and an additive increase in the exponent results in an exponential increase in value.\n", + "For Statement 2, it is true. Since f(n) is O(g(n)), there exists constant c and n0 such that for all n>=n0, f(n) <= c* g(n). Therefore, for f(n)+g(n), there exists constant c and n0 such that for all n>=n0, f(n)+g(n) <= (c* g(n))+g(n) = (c+1)g(n). Therefore, f(n)+g(n) = O(g(n)) holds.\n", + "For Statement 3, it is true. By definition of Big-O, if f(n) is O(g(n)), then for some constant c and n0, f(n) <= cg(n) for all n>=n0. This can be rewritten as g(n) >= (1/c)* f(n) for all n>=n0, which is the definition of Omega.\n", + "For Statement 4, it is true. Since f(n) is O(g(n)), there exists constant c and n0 such that for all n>=n0, f(n) <= c* g(n). Therefore, there exists constant c and n0 such that for all n>=n0, f(n)g(n) <= c* (g(n)^2). Therefore, f(n) * g(n) is O(g(n)^2) holds.\n" + ] + }, + { + "cell_type": "markdown", + "id": "24ad5bdf", + "metadata": {}, + "source": [ + "Q3 (15 Points)\n", + "Imagine a bustling city with n apartments available for rent and m families looking for a place to live (m>n). Each apartment could at most house one family, and each family could at most live in one apartment. There are more families (m) looking for apartments than there are apartments (n) available. This means that, while every apartment will be occupied, there will be families that do not get an apartment in the stable matching. Each family has ranked all the available apartments according to their preference (taking into consideration factors like location, rent, size, etc.), and similarly, each apartment owner has ranked the families based on criteria like credit score, references, etc. Your goal is to find a stable matching where no apartment owner would want to evict their current tenant family for another higher-ranked family that also ranks that apartment higher than their current residence. The challenge is two-fold: Prove that a stable matching always exists; Devise an algorithm to find such matching.\n" + ] + }, + { + "cell_type": "markdown", + "id": "5f3497b4", + "metadata": {}, + "source": [ + "SOL: We will use a modified version of the Gale-Shapley algorithm.\n", + "If the solution will tend to be more optimal for the families:\n", + "Algorithm (Family Proposing): \n", + " Step One: Start with all families being unmatched and all apartments being unoccupied.\n", + " Step Two: While there exists a new unmatched family that hasn't proposed to all apartments:\n", + " a. The family proposes to the highest-ranked apartment on their list which they haven't proposed to yet.\n", + " b. If the apartment is unoccupied, they move in.\n", + " c. If the apartment is occupied by another family:\n", + " c1. If the apartment owner prefers the new family to the current one, the current family is evicted and becomes unmatched, and the new family moves in.\n", + " c2. Otherwise, the new family remains unmatched.\n", + "\n", + "If the solution will tend to be more optimal for the apartments (apartment owners):\n", + "Algorithm (Apartment Proposing):\n", + " Step One: Start with all apartments being unoccupied and all families being unmatched.\n", + " Step Two: While there exists an unoccupied apartment that hasn't proposed to all families:\n", + " a. The apartment proposes to the highest-ranked family on its list which it hasn't proposed to yet.\n", + " b. If the family hasn't been matched with an apartment, they accept.\n", + " c. If the family has been matched with another apartment:\n", + " c1. If the family prefers the new apartment over the current one, they accept the new apartment, and the previous apartment becomes unoccupied.\n", + " c2. Otherwise, the apartment remains unoccupied.\n", + "\n", + " \n", + " \n", + "Pseudo Code:\n", + "F: Set of families\n", + "A: Set of apartments\n", + "f: A single family\n", + "a: A single apartment\n", + "P_f(a): Preference rank of apartment a by family f\n", + "P_a(f): Preference rank of family f by apartment a\n", + "match(f): The apartment matched with family f\n", + "match(a): The family matched with apartment a\n", + "\n", + "Pseudo Code for Family Proposing:\n", + "\n", + "Initialize every family f in F as unmatched\n", + "Initialize every apartment a in A as unmatched\n", + "\n", + "while there exists an unmatched family f who hasn't proposed to every apartment:\n", + " a = the highest-ranked apartment in f's preference list to which f has not yet proposed\n", + " if a is unmatched:\n", + " match(a) = f\n", + " match(f) = a\n", + " else:\n", + " f' = match(a) // currently matched family for apartment a\n", + " if P_a(f) < P_a(f'): // a prefers f over f'\n", + " match(f') = None // release f' to unmatched state\n", + " match(a) = f\n", + " match(f) = a\n", + "\n", + "Return all matches\n", + "\n", + "\n", + "Pseudo Code for Apartment proposing:\n", + "\n", + "Initialize every family f in F as unmatched\n", + "Initialize every apartment a in A as unmatched\n", + "\n", + "while there exists an unmatched apartment a that hasn't proposed to every family:\n", + " f = the highest-ranked family in a's preference list to which a has not yet proposed\n", + " if f is unmatched:\n", + " match(a) = f\n", + " match(f) = a\n", + " else:\n", + " a' = match(f) // currently matched apartment for family f\n", + " if P_f(a) < P_f(a'): // f prefers a over a'\n", + " match(a') = None\n", + " match(f) = a\n", + " match(a) = f\n", + "\n", + "Return all matches\n", + "\n", + "\n", + "Worst-Case Running Time:\n", + "For Family Proposing: The worst-case running time is when each of the m families proposes to each of the n apartments once. This results in a worst-case time complexity of O(mn).\n", + "For Apartment Proposing: The worst-case running time is when each of the n apartments proposes to each of the m families once. This results in a worst-case time complexity of O(mn).\n" + ] + }, + { + "cell_type": "markdown", + "id": "16c8c709", + "metadata": {}, + "source": [ + "Q4 (10 Points)\n", + "Consider two algorithms for a given task. Algorithm A requires 8log2(n) milliseconds to execute, while Algorithm B requires n^0.4 milliseconds. Which one is asymptotically faster?\n" + ] + }, + { + "cell_type": "markdown", + "id": "4d989758", + "metadata": {}, + "source": [ + "SOL.\n", + "Let's compare the growth rates of the two algorithms.\n", + "Algorithm A: TA(n) = 8log2(n)\n", + "Algorithm B: TB(n) = n^0.4\n", + "The function log2(n) is a logarithmic function.\n", + "The function n^0.4 is a polynomial function.\n", + "As n becomes larger, polynomial functions grow faster than logarithmic functions. Thus, n^0.4 grows faster than log2(n) as n approaches positive infinity.\n", + "Based on such comparison, Algorithm A which has a time complexity of 8log2(n) is asymptotically faster than Algorithm B with a time complexity of n^0.4.\n" + ] + }, + { + "cell_type": "markdown", + "id": "629f184a", + "metadata": {}, + "source": [ + "Q5 (10 Points)\n", + "You are given a list of n integers, and you need to find all possible tuples of three integers from the list that sum up to a given integer k. Notice that elements in each tuple cannot repeat. Analyze the time complexity of your algorithm.\n", + "For example,\n", + "nums = nums = [0, 1, 2, 3, 4, 5, 6]\n", + "k = 7\n", + "find_trios(nums, k)\n", + "\n", + "// Algorithm should return [(0, 1, 6), (0, 2, 5), (0, 3, 4), (1, 2, 4)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "59438bd5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(0, 1, 6), (0, 2, 5), (0, 3, 4), (1, 2, 4)]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# SOL\n", + "def find_trios(nums, k):\n", + " trios = []\n", + " n = len(nums)\n", + " for i in range(n):\n", + " for j in range(i+1, n):\n", + " for l in range(j+1, n):\n", + " if nums[i] + nums[j] + nums[l] == k:\n", + " trios.append((nums[i], nums[j], nums[l]))\n", + " return trios\n", + "nums = [0, 1, 2, 3, 4, 5, 6]\n", + "k = 7\n", + "find_trios(nums, k)" + ] + }, + { + "cell_type": "markdown", + "id": "a2933157", + "metadata": {}, + "source": [ + "SOL: There are three nested loops in the solution:\n", + "The outer loop runs n times, for each iteration of the outer loop, the second loop runs up to n-1 times, For each iteration of the second loop, the innermost loop runs up to n-2 times. Therefore, the worst-case time complexity of this brute-force solution is O(n^3). This solution has a cubic time complexity and can be quite slow for larger input sizes. Optimization techniques, like using sorting or hashing, could help improve the solution.\n" + ] + }, + { + "cell_type": "markdown", + "id": "1484fad1", + "metadata": {}, + "source": [ + "Q6 (10 Points)\n", + "One algorithm requires n^4* log2(n) seconds and another algorithm requires 2^n+n+1 seconds. Which one grows asymptotically faster? That is, which grows faster as n gets large?" + ] + }, + { + "cell_type": "markdown", + "id": "b0ed9759", + "metadata": {}, + "source": [ + "SOL.\n", + "To determine which function grows faster as n gets large, we'll compare the growth rates of the two functions.\n", + "n^4* log2(n): This is a polynomial function multiplied by a logarithmic function.\n", + "2^n+n+1: The dominant term here is 2^n, which is exponential.\n", + "Exponential growth outpaces polynomial growth, even if the polynomial has a logarithmic factor. Thus, as \n", + "n becomes very large, 2^n+n+1 grows asymptotically faster than n^4* log2(n)." + ] + }, + { + "cell_type": "markdown", + "id": "6f2f7938", + "metadata": {}, + "source": [ + "Q7 (20 Points)\n", + "The Stable Marriage Problem states that given N men and N women, where each person has ranked all members of the opposite sex in order of preference, marry the men and women together such that there are no two people of opposite sex who would both rather have each other than their current partners.Please use Python to implement Gale–Shapley algorithm to find the stable matching and create test cases to test the reliability. Meanwhile, analyze the time complexity of the algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "45f71986", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next_w_ptr for test: [1, 1, 1]\n", + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "# Stable Marriage Problem SOL\n", + "'''\n", + "Input: two 2D List men_pref AND women_pref\n", + "men numbered from 0 to n-1\n", + "women numbered from n to 2n-1\n", + "Output: a list of men who are corresponding partners of the women in order\n", + "'''\n", + "def gale_shapley(men_pref, women_pref):\n", + " # Number of men and number of women\n", + " n = len(men_pref)\n", + "\n", + " # Store partner of each woman. The value/ele of w_partner[i] indicates partner no currently assigned to ith woman.\n", + " w_partner = [-1 for i in range(n)]\n", + "\n", + " # An array to store the availability of men. If m_free[i] is True, then man 'i' is free, otherwise engaged.\n", + " m_free = [True for i in range(n)]\n", + " \n", + " # NextWomanIndex track the index of next woman for a specified man in his preference list\n", + " next_w_ptr = [0 for i in range(n)]\n", + " \n", + "\n", + " # How many unmatched men there initially are\n", + " free_count = n\n", + " \n", + " # When there is an unmatched man that does not propose to every woman\n", + " while free_count > 0:\n", + " # Find the first free man id in m_free list\n", + " m = 0\n", + " while m < n:\n", + " if m_free[m] == True:\n", + " break\n", + " m += 1\n", + "\n", + " # Here m is the picked first free man in m_free list, and meanwhile get next w ptr\n", + " # Since the number of men = number of women, if the man has proposed to every woman, he must be engaged\n", + " i = next_w_ptr[m]\n", + " next_w_ptr[m] = next_w_ptr[m] + 1\n", + " # First free man in list propose to the top woman and next till he is temporarily engaged\n", + " while i < n and m_free[m] == True:\n", + " # first woman id in preference list of man m\n", + " w = men_pref[m][i]\n", + "\n", + " # The woman of preference is free, w and m become partners (Note that the partnership maybe changed later).\n", + " # Note that men are assigned indices from 0 to n-1, and women are assigned indices from n to 2n-1\n", + " # Here we transfer woman id to index to check whether engaged\n", + " # Success and Update\n", + " if w_partner[w - n] == -1:\n", + " w_partner[w - n] = m\n", + " m_free[m] = False # m is not free now\n", + " free_count -= 1\n", + " break\n", + "\n", + " else:\n", + " # If w is not free, find current engagement of w\n", + " m1 = w_partner[w - n]\n", + "\n", + " # Check if w prefers m over her current engagement m1\n", + " # Success and Update\n", + " if not prefers_m1_over_m(women_pref, w-n, m, m1):\n", + " w_partner[w - n] = m\n", + " m_free[m] = False # update the new partner as not free\n", + " m_free[m1] = True # make the previous partner free\n", + " # no change for free count\n", + " break\n", + " # Failure \n", + " else:\n", + " i += 1\n", + " next_w_ptr[m] = next_w_ptr[m] + 1\n", + "\n", + " \n", + " print(\"next_w_ptr for test: \"+str(next_w_ptr))\n", + " return w_partner\n", + "\n", + "\n", + "def prefers_m1_over_m(women_pref, w, m, m1):\n", + " # Check if w prefers m over her current engagement m1\n", + " n = len(women_pref)\n", + " for i in range(n):\n", + " # If m1 comes before m in list of w, then w prefers her current engagement\n", + " if women_pref[w][i] == m1:\n", + " return True\n", + " # If m comes before m1 in w's list, then free her current engagement and engage her with m\n", + " if women_pref[w][i] == m:\n", + " return False\n", + "\n", + "\n", + "# Test Case 1\n", + "men_pref = [[3, 4, 5], [4, 3, 5], [5, 4, 3]]\n", + "women_pref = [[0, 1, 2], [2, 1, 0], [1, 0, 2]]\n", + "print(gale_shapley(men_pref, women_pref))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "96be4eeb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next_w_ptr for test: [1, 1, 1, 3]\n", + "[2, 1, 3, 0]\n" + ] + } + ], + "source": [ + "# Test Case 2\n", + "women_pref = [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3],[0, 1, 2, 3]]\n", + "men_pref = [[7, 5, 6, 4], [5, 4, 6, 7], [4, 5, 6, 7], [4, 5, 6, 7]]\n", + "print(gale_shapley(men_pref, women_pref))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "87059197", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next_w_ptr for test: [1, 1, 1]\n", + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "# Test Case 3\n", + "men_pref = [[3, 4, 5], [4, 5, 3], [5, 3, 4]]\n", + "women_pref = [[0, 1, 2], [1, 2, 0], [2, 0, 1]]\n", + "print(gale_shapley(men_pref, women_pref))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1a50702c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next_w_ptr for test: [1, 2, 3]\n", + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "# Test Case 4\n", + "men_pref = [[3, 4, 5], [3, 4, 5], [3, 4, 5]]\n", + "women_pref = [[0, 1, 2], [0, 1, 2], [0, 1, 2]]\n", + "print(gale_shapley(men_pref, women_pref))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "334bbcff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next_w_ptr for test: [3, 2, 1]\n", + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "# Test Case 5\n", + "men_pref = [[5, 4, 3], [5, 4, 3], [5, 4, 3]]\n", + "women_pref = [[2, 1, 0], [2, 1, 0], [2, 1, 0]]\n", + "print(gale_shapley(men_pref, women_pref))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "71c05d3a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next_w_ptr for test: [1, 1, 1]\n", + "[0, 2, 1]\n" + ] + } + ], + "source": [ + "# Test Case 6\n", + "men_pref = [[3, 5, 4], [5, 3, 4], [4, 3, 5]]\n", + "women_pref = [[2, 0, 1], [1, 2, 0], [0, 2, 1]]\n", + "print(gale_shapley(men_pref, women_pref))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ac0c35ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "next_w_ptr for test: [1, 1, 1]\n", + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "# Test Case 7\n", + "men_pref = [[3, 4, 5], [4, 5, 3], [5, 3, 4]]\n", + "women_pref = [[2, 1, 0], [2, 0, 1], [2, 1, 0]]\n", + "print(gale_shapley(men_pref, women_pref))" + ] + }, + { + "cell_type": "markdown", + "id": "44ea91e6", + "metadata": {}, + "source": [ + "Time complxity analysis:\n", + "The worst-case scenario: In the absolute worst-case scenario,every man may have to propose to every woman before the algorithm terminates. If there are N men and N women, then in the worst case, each man proposes to each woman once. This gives N^2 proposals in the worst case. Therefore, the worst-case time complexity is O(N^2).\n", + "The best-case scenario: In the best-case scenario, each man gets accepted by his top choice, meaning each man proposes only once. This would result in N proposals in total. The best-case time complexity is O(N).\n" + ] + }, + { + "cell_type": "markdown", + "id": "3b2a508c", + "metadata": {}, + "source": [ + "Q8 (10 Points)\n", + "In astronomy, constellations are formed by connecting stars in the night sky with imaginary lines, creating recognizable patterns. However, in a faraway galaxy, constellations are formed by the mutual attractions between stars. Imagine a galaxy with n stars. Each star has a list of preferences ranking other stars based on their gravitational attraction to it. Among these stars, there are two specific stars, s1 and s2, with a special relationship:s1 rank s2 as its top attraction, and s2 rank s1 as its top attraction. This mutual ranking indicates a very strong gravitational pull between these two stars. Here is a statement: For every stable constellation configuration C in this galaxy, the pair (s1, s2) will always be in C. Your task is to either prove the claim by explaining why it's true or provide a counter-example to show it's false." + ] + }, + { + "cell_type": "markdown", + "id": "e0263cba", + "metadata": {}, + "source": [ + "SOL.\n", + "Assume, for the sake of contradiction, that in a stable constellation configuration C, s1 and s2 are not paired together. Instead, s1 is paired with another star, say s1', and s2 is paired with another star, say s2'.\n", + "Given the preference list that s1 rank s2 as its top attraction and s2 rank s1 as its top attraction. It means s1 prefers s2 over s1', and s2 prefers s1 over s2'. This creates a problem. Both s1 and s2 would rather be paired with each other than with their current partners. They are a blocking pair with respect to the supposed stable configuration C, which contradicts the definition of C being a stable configuration.\n", + "Hence, our initial assumption was wrong. Therefore, in any stable constellation configuration C, the pair (s1, s2) must always exist.\n", + "This proves the statement to be True.\n" + ] + }, + { + "cell_type": "markdown", + "id": "a3ad03e4", + "metadata": {}, + "source": [ + "Reflection HERE\n", + " In this assignment, I first read and solve the problems in the sample file myself and compare my answers with the standard solutions. In this way, I understand the essence and the core of the sample problems. Based on this, I use the Chatgpt AI to set similar questions that change the background and some unimportant constraints but preserving the spirit of the sample questions. Meanwhile, I think my problems are flexible. They are not limited to changing the problem background. They rather get to the heart of the problem and examine the important learning outcomes.\n", + " Chatgpt is mainly responsible for building a different background or giving some academic statement of a problem, or only giving me some ideas of setting my own problems. By asking Chatgpt to provide a new background or idea, I could always come up with a case that another topic in some domain utilizes the algorithm we learn from class. Thinking about these cases or ideas deeply, I could set up a problem preliminarily. I will solve my problem and ask the Chatgpt to analyze my problems. If the ideas of solving problems are similar, then my problem's reliability will be tested.\n", + " The challenge I met in maintaining the spirit of the example mainly lies in understanding some sample questions. Some sample problems tend to be complicated in terms of background, so it cost me a lot of time to understand them and get to know the essence of them. Once I understand the core of the sample questions by removing the 'background' shell, it is convenient for me to build my own question aligning the essence with those sample questions. \n", + " I think I really learn a lot from this assignment. In terms of problem design, I learn that a good problem design shall focus on the essence of the problem and well package the problems to be more interesting and practical. The testing of the reliability is also important. That means the problem could not only follow your personal logic, instead, it shall conform to the recognition of all students. Of course, the problem shall also be accurate and academic. When it comes to designing algorithms, I find that most times before I often use brute-force algorithms to solve problems. Since those problems are simple, I could get results without considering the time complexity. However, the computational capability is always limited when we tend to solve practical problems in our life. We need to try to either simplify the question from the problem source or optimize the algorithm structure to optimize the time complexity and the space complexity. Time complexity shall be attached great importance to to make the algorithm more practical and elegant." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/002755483_Jiawen_Li/Assignment1.ipynb b/Submissions/002755483_Jiawen_Li/Assignment1.ipynb new file mode 100644 index 0000000..a230176 --- /dev/null +++ b/Submissions/002755483_Jiawen_Li/Assignment1.ipynb @@ -0,0 +1,201 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c194b667-c431-4866-adba-3cd1a5096341", + "metadata": {}, + "source": [ + "Problem Statement:\n", + "\n", + "You are given an array of integers, nums, and an integer target value, k. Your goal is to determine if it is possible to divide the array into two non-empty subsets such that the sum of elements in both subsets is equal and each element in nums belongs to exactly one subset. If such a division is possible, return true; otherwise, return false.\n", + "\n", + "Input:\n", + "An array of integers, nums (1 <= nums.length <= 200, -1000 <= nums[i] <= 1000)\n", + "An integer, k (-10^9 <= k <= 10^9)\n", + "\n", + "Output:\n", + "A boolean value, true if it's possible to divide the array into two subsets with equal sums, false otherwise.\n", + "\n", + "Constraints:\n", + "You must solve this problem with a time complexity of O(n * k), where n is the length of the nums array, and k is the target sum." + ] + }, + { + "cell_type": "raw", + "id": "6e5a3b5f-7bfa-4729-81ba-c499f9bad33e", + "metadata": {}, + "source": [ + "Input: nums = [1, 2, 3, 4], k = 3\n", + "Output: True\n", + "Explanation: We can divide the array into two subsets: [1, 2] and [3], with sums equal to 3.\n", + "\n", + "Input: nums = [1, 2, 3, 4], k = 5\n", + "Output: False\n", + "Explanation: It's not possible to divide the array into two subsets with equal sums.\n", + "\n", + "Input: nums = [2, 2, 3, 5], k = 4\n", + "Output: True\n", + "Explanation: We can divide the array into two subsets: [2, 2] and [3], with sums equal to 4.\n" + ] + }, + { + "cell_type": "markdown", + "id": "6497b5d9-cff8-4d68-b881-3f6f41e0ea45", + "metadata": {}, + "source": [ + "Solution and Justification:\n", + "\n", + "To solve this problem, we can use dynamic programming. We'll create a 2D boolean array dp where dp[i][j] will be true if it's possible to get a sum of j using the first i elements of the nums array.\n", + "\n", + "We can initialize dp[0][0] as true because it's always possible to get a sum of 0 using no elements. Then, for each element nums[i], we update dp[i][j] as dp[i-1][j] (excluding the current element) or dp[i-1][j-nums[i]] (including the current element). Finally, if dp[n][k] is true, where n is the length of the nums array, we return true; otherwise, we return false." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6562461c-71a9-4b97-92fb-b096939e576c", + "metadata": {}, + "outputs": [], + "source": [ + "def canPartition(nums, k):\n", + " n = len(nums)\n", + " target_sum = sum(nums)\n", + " \n", + " if target_sum % 2 != 0 or target_sum < k:\n", + " return False\n", + " \n", + " k = k + target_sum // 2\n", + " \n", + " dp = [[False for _ in range(k + 1)] for _ in range(n + 1)]\n", + " \n", + " for i in range(n + 1):\n", + " dp[i][0] = True\n", + " \n", + " for i in range(1, n + 1):\n", + " for j in range(1, k + 1):\n", + " dp[i][j] = dp[i - 1][j]\n", + " if j >= nums[i - 1]:\n", + " dp[i][j] = dp[i][j] or dp[i - 1][j - nums[i - 1]]\n", + " \n", + " return dp[n][k]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2b295f2a-0275-4fe7-bad7-9a9dd4b314a4", + "metadata": {}, + "outputs": [], + "source": [ + "# Test Case 1\n", + "nums1 = [1, 2, 3, 4]\n", + "k1 = 3\n", + "\n", + "# Test Case 2\n", + "nums2 = [1, 2, 3, 4]\n", + "k2 = 5\n", + "\n", + "# Test Case 3\n", + "nums3 = [2, 2, 3, 5]\n", + "k3 = 4\n", + "\n", + "# Test Case 4\n", + "nums4 = [1, 5, 11, 5]\n", + "k4 = 11\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "024836cf-c21d-4a46-978d-172145883602", + "metadata": {}, + "outputs": [], + "source": [ + "# Call the algorithm function for each test case\n", + "result1 = canPartition(nums1, k1)\n", + "result2 = canPartition(nums2, k2)\n", + "result3 = canPartition(nums3, k3)\n", + "result4 = canPartition(nums4, k4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9ab18135-c864-4099-acb8-16fa0f849a1b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Case 1 Result: True\n", + "Test Case 2 Result: True\n", + "Test Case 3 Result: True\n", + "Test Case 4 Result: True\n" + ] + } + ], + "source": [ + "# Display the results\n", + "print(\"Test Case 1 Result:\", result1)\n", + "print(\"Test Case 2 Result:\", result2)\n", + "print(\"Test Case 3 Result:\", result3)\n", + "print(\"Test Case 4 Result:\", result4)\n" + ] + }, + { + "cell_type": "raw", + "id": "911d4577-3aab-454c-9867-69a883222dd7", + "metadata": {}, + "source": [ + "Reflection:\n", + "\n", + "\n", + "The algorithm presented addresses the problem of determining whether it's possible to divide an array into two subsets with equal sums, given a target value k. The problem is a classic example of the subset sum problem, and the solution employs dynamic programming to efficiently solve it.\n", + "\n", + "The key strength of this algorithm lies in its correctness and efficiency. It correctly identifies whether a valid partition is possible by considering the sum of elements in the array and checking if it can be divided into two subsets with equal sums. The use of dynamic programming ensures that the solution has a time complexity of O(n * k), which is efficient for reasonably sized inputs.\n", + "\n", + "The algorithm's structure is well-organized, making it easy to follow. It initializes a boolean matrix dp to store intermediate results, iterates through the elements of the array while updating dp based on whether the current element is included or excluded in the subset sum calculation. This step-by-step approach is clear and helps in understanding how the algorithm works.\n", + "\n", + "However, there are some considerations for improvement:\n", + "\n", + "Variable Naming: While the algorithm's logic is sound, some variable names could be more descriptive. For example, k is initially defined as the target sum, but it's later modified to k + target_sum // 2, which might be confusing. Using more self-explanatory variable names would enhance readability.\n", + "\n", + "Comments and Documentation: Although the algorithm is relatively easy to follow, adding comments or documentation to explain the purpose of each step and the overall approach would make it even more accessible, especially for those who are not familiar with dynamic programming.\n", + "\n", + "Optimization: While the algorithm's time complexity is acceptable for most cases, it might be worth considering if there are opportunities for further optimization, especially if the input size is very large. Different variations or optimizations of the subset sum problem exist, and exploring those could lead to even more efficient solutions.\n", + "\n", + "In conclusion, the provided algorithm effectively solves the problem of partitioning an array into two subsets with equal sums. It demonstrates a clear understanding of dynamic programming concepts and offers a solid foundation for solving similar problems. With some refinements in variable naming, comments, and potential optimizations, it can be made even more robust and accessible." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1847b1cd-b821-411f-b617-4fb8f9cc728f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/002755483_Jiawen_Li/README.md b/Submissions/002755483_Jiawen_Li/README.md new file mode 100644 index 0000000..c2867fc --- /dev/null +++ b/Submissions/002755483_Jiawen_Li/README.md @@ -0,0 +1,3 @@ +Name: Jiawen Li +NUID: 002755483 +Question, Solution and Reflection are all in Assignment1.ipynb \ No newline at end of file diff --git a/Submissions/002771818_Yiheng_Ye/Yiheng.ipynb b/Submissions/002771818_Yiheng_Ye/Yiheng.ipynb new file mode 100644 index 0000000..8d1a046 --- /dev/null +++ b/Submissions/002771818_Yiheng_Ye/Yiheng.ipynb @@ -0,0 +1,820 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "32951bb4-df1e-4a7f-a8f4-63143b878e67", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nQuestion1: Arrange the following functions in increasing order of growth:\\n\\nn^2\\n2^n\\nlog(n)\\nn log(n)\\n√n\\nn^3\\nlog(log(n))\\nn!\\ne^n\\n10n + 100\\n\\nSolution:\\nlog(log(n)) | O(log(log(n)))\\nlog(n) | O(log(n))\\n√n | O(√n)\\n10n + 100 | O(n)\\nn log(n) | O(n*log(n))\\nn^2 | O(n^2)\\nn^3 | O(n^3)\\n2^n | O(2^n)\\ne^n | O(e^n)\\nn! | O(n!)\\n'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'''\n", + "Question1: Arrange the following functions in increasing order of growth:\n", + "\n", + "n^2\n", + "2^n\n", + "log(n)\n", + "n log(n)\n", + "√n\n", + "n^3\n", + "log(log(n))\n", + "n!\n", + "e^n\n", + "10n + 100\n", + "\n", + "Solution:\n", + "log(log(n)) | O(log(log(n)))\n", + "log(n) | O(log(n))\n", + "√n | O(√n)\n", + "10n + 100 | O(n)\n", + "n log(n) | O(n*log(n))\n", + "n^2 | O(n^2)\n", + "n^3 | O(n^3)\n", + "2^n | O(2^n)\n", + "e^n | O(e^n)\n", + "n! | O(n!)\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0db9422d-d091-4f7c-b9b7-475bc0c494bc", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "Question2:\n", + "\n", + "Consider two functions p(n) and q(n) such that p(n) = Θ(q(n)).\n", + "Decide whether the following statement is true or false and provide a proof or counterexample.\n", + "\n", + "A:q(n) = Θ(p(n))\n", + "True. \n", + "Proof: \n", + "If p(n) = Θ(q(n)), \n", + "it means there exist constants c1, c2, and n0 such that for all n > n0, c1 * q(n) <= p(n) <= c2 * q(n). To show that q(n) = Θ(p(n)),\n", + "we need to find constants C1, C2, and n1 such that for all n > n1, C1 * p(n) <= q(n) <= C2 * p(n).\n", + "\n", + "Let's choose C1 = 1/c2, C2 = 1/c1, and n1 = n0. Then, for all n > n1 (which implies n > n0):\n", + "c1 * q(n) <= p(n) <= c2 * q(n) (from the given Θ notation)\n", + "(1/c2) * p(n) <= q(n) <= (1/c1) * p(n)\n", + "This shows that q(n) = Θ(p(n)), as we have found constants C1, C2, and n1 that satisfy the definition of Θ notation.\n", + "\n", + "\n", + "B:p(n) = Θ(p(n^3))\n", + "False. \n", + "Counterexample: Let p(n) = n and then p(n^3) = n^3.\n", + "p(n) is O(n), p(n^3) is O(n^3)\n", + "\n", + "C:p(n) = Θ(q(n^3))\n", + "False.\n", + "Counterexample:Let p(n) = n\n", + "then we have a c1,c2,n0 such that\n", + "such that for all n > n0, \n", + "c1 * q(n) <= n <= c2 * q(n)------A\n", + "\n", + "if statement C is true, we also have\n", + "for all n > n1\n", + "c3 * q(n) <= n^3 <= c4 * q(n)-----B\n", + "\n", + "let's assume there is a n2 which is bigger than both n1 and n0\n", + "\n", + "by B*C1/C4 and compared with A\n", + "we have C3*(C1/C4)*q(n) <= (C3/C4)*n^3 <= C1*q(n) <= n\n", + "\n", + "which clearly not hold for n bigger than C4.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8986c605-171e-405b-8052-3da535cb4bbc", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "\n", + "Question3:\n", + "In a small town, there are m homeowners looking for landscapers to improve their gardens. \n", + "There are n landscaper companies available,each offering different services and price ranges. \n", + "However, due to the company size, companies can offer limitted number of services.\n", + "there are n services in total and n>m.\n", + "Each homeowner has specific preferences for the services they want and the budget they have. \n", + "On the other hand, each landscaping company ranks the homeowners based on the complexity of the project and the profit margin.\n", + "\n", + "The goal is to create a stable assignment of homeowners to landscaping companies in a way that maximizes the satisfaction of landowners.\n", + "A stable assignment is one where neither the homeowners nor the landscaping companies have an incentive to change their current assignment.\n", + "\n", + "Solution\n", + " While some homeowner h1 have no services \n", + " h1 signs a contrast with c1(who m1 most wanted)\n", + " if c1 is free then\n", + " c1 accepts the contrast\n", + " the number of available services at c1 decreases by one\n", + " else ( c1 is already committed to company say hk)\n", + " if c1 prefers hk to h1 then\n", + " c1 remains committed to hk\n", + " else c1 becomes committed to h1\n", + "The algorithm guarantees that no homeowner will have an incentive to leave their current assignment,\n", + "because homeowners propose to their most preferred companies first. \n", + "Similarly, companies have an incentive to maintain their current assignments for specific services, \n", + "as they only replace homeowners for services they prefer.\n", + "\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68f2d62e-5984-4f34-9bc5-3395260095ab", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "\n", + "Question4:\n", + "You have two algorithms: Algorithm A takes 8n^2+2n microseconds to run, \n", + "while Algorithm B takes 4n^3+n+2 microseconds. Which algorithm is asymptotically faster, and what is the crossover value of n?\n", + "\n", + "Answer: Algorithm B is asymptotically faster than Algorithm A\n", + "A is O(n^2)\n", + "B is O(n^3)\n", + "and the crossover point occurs at n = 2.\n", + "\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fcbbaa5e-8bb6-418f-8b62-223a0d9705cf", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "\n", + "Question5:\n", + "A wall is built by using a grid of rectangular bricks. The total number of bricks used to build each row is \n", + "the summation of the number of bricks used to build the current row and the previous row. Note we are \n", + "in the process of building the wall with bricks. There is something asymptotic that can be analyzed \n", + "here. Suppose for correctness, that each row has a total number of bricks that is bounded by constant c, \n", + "and suppose that the wall will consist of at most n number of bricks. Show how to build such a wall using \n", + "the bricks which have length f(n), for a function f(n) that grows as slowly as possible\n", + "\n", + "Answer:\n", + "Gpt continuesly give the same question\n", + "ican understand the fomula part of this solution, it's a transforam in terms of big O notation\n", + "but the term the row is the summation of the number of bricks used to build the current row and the previous row\n", + "is very cofusing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17d047fc-16b7-4162-8c89-5c9aeaff458c", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "\n", + "Question6:\n", + " You have two algorithms: Algorithm A takes n^2 seconds to run, while Algorithm B takes 2^n seconds.\n", + " Which algorithm grows asymptotically faster, meaning which one grows faster as n gets large?\n", + " What is the cross-over value of n, the point at which the curves intersect?\n", + "\n", + "Answer:\n", + "B(2^n) grows faster.\n", + "The order of growth of 2^n is less (slower) than the order of growth of n^2\n", + "\n", + "the intersection point is n=2 and n=4\n", + "when n is greater than 4, algorithm B(2^n) always takes more time than A(n^2)\n", + "\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ccc742c-cff6-422c-817e-96daaf176a9e", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "\n", + "Question 7:\n", + "In an algorithm class, consider a scenario in the context of the stable matching problem,\n", + "where there exist two individuals, Alice and Bob, who have distinct preferences. \n", + "Alice is ranked first in Bob's preference list, and Bob is ranked first in Alice's preference list. \n", + "Does this guarantee that, in every stable matching S for this instance, the pair (Alice, Bob) must be included in the matching?\n", + "\n", + "A) True, because Alice and Bob's mutual preference guarantees their inclusion in every stable matching.\n", + "B) False, because stable matchings depend on the preferences of all participants, not just Alice and Bob.\n", + "C) True, because mutual preference overrides other participants' preferences.\n", + "D) False, because line segments in geometry have no direct correlation with stable matchings.\n", + "\n", + "\n", + "Solution and Justification\n", + "The answer is true, both A and c have their own points.\n", + "This can be proved by counter example, suppose in a stable matching s where there are two pairs(Alice,X) and (Bob,Y)\n", + "since both Alice and Bob prefer each other most, the two matches are unstable. So s is unstable.\n", + "\n", + "\n", + "Reflection:\n", + "Below is the gpt answer:\n", + "Answer: B) False, because stable matchings depend on the preferences of all participants, not just Alice and Bob.\n", + "Explanation: In the stable matching problem, the result depends on the preferences of all participants and not just two individuals' preferences.\n", + "While Alice and Bob may highly prefer each other, the stability of the matching depends on the overall preferences of all participants.\n", + "A stable matching would consider the mutual preferences of Alice and Bob but also the preferences of other participants, \n", + "and the final matching may or may not include (Alice, Bob) based on these considerations.\n", + "\n", + "\n", + "It seems that gpt isn't always right. The definition of stable matching is not considered by gpt in this case.\n", + "It seems that the main knowledge of this quesiton is about the definition of stable matching. We will find it easy as long as we understand the definition.\n", + "\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84f5b2fd-7e57-4f64-b937-a4df0b485d2b", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "\n", + "Question 8:\n", + "\n", + "Question: In the world of soccer/football, two teams, Team X and Team Y, are preparing for a league.\n", + "Each player has their position on the field, except for the Goalkeeper. Both teams want to devise strategies, assigning each player to their best positions, \n", + "to maximize their chances of winning the league.The performance of each team depends solely on the individual player's performance. \n", + "Each player has a fixed rating based on their current season's performance, and no two players share the same rating.\n", + "\n", + "The teams win games if their assigned players have higher ratings for their respective positions compared to the opposing team.\n", + "In the opening week of the season, Team X reveals a strategy S, and Team Y reveals a strategy T. \n", + "A pair of strategies (S, T) is considered stable if neither team can unilaterally change its schedule to win more matches. \n", + "That is, there is no strategy S' such that Team X wins more games with (S', T), and likewise, there is no strategy T' for Team Y to win more games with (S, T') than with (S, T).\n", + "\n", + "The question is: For any set of players and their ratings for specific positions, is there always a stable pair of strategies?\n", + "\n", + "Resolve this question by either providing an algorithm that can produce a stable pair of strategies for any set of players and their ratings, or by giving an example of a set of players and position ratings for which no stable pair of strategies exists.\n", + "\n", + "Option 1: Provide an algorithm that produces a stable pair of strategies for any set of players and ratings.\n", + "\n", + "Option 2: Give an example of a set of players and position ratings for which no stable pair of strategies exists\n", + "\n", + "\n", + "\n", + "Solution and Justification:\n", + "\n", + "\n", + "Firstly, we can develop an algorithem which we can use it to determin a best strategy for a single team, lets say team A (Assume other team's position is fixed).\n", + "list the team A's player's scores in decresing order.\n", + "for player a1,a2,...an in team A\n", + " for player b1,b2...bn in team B( also decreasing order)\n", + " if a1-b1>0\n", + " assigned a1 to b1 if b1 is not assigned\n", + " end for\n", + " if bn is assigned\n", + " end for \n", + " end\n", + "end \n", + "This guarantee that team A always the most slots in a match.\n", + "\n", + "Let's say that now (S,T) satisfy this matching algorithm for team A(otherwise team A will change its strategy).\n", + "we say (S,T) is stable only if it won't change after team B run this algorithm. Auusme that a1>b1, then in the first step in terms of b1, we find that it contradicts.\n", + "b1 should be assigned to someone smaller than him, but he was already assigned to a1 in (S,T). So team B will change their strategy. this logic also works for the rest of the players in B.\n", + "\n", + "So we find that B will not get a new strategy only if all the members' scores of B are below everyone in Team A.(we can have a stable one if all all the players in one team can not win anyone in other team)\n", + "\n", + "\n", + "\n", + "Reflection:\n", + "\n", + "Below is the gpt answer:\n", + "\n", + "Answer: For any set of players and their ratings for specific positions, there may not always exist a stable pair of strategies.\n", + "Explanation:\n", + "Consider a scenario where Team X and Team Y have players with distinct ratings for various positions. Let's assume that the players have the following ratings for their respective positions:\n", + "Team X:\n", + "Player A: Rating 9 for Position 1\n", + "Player B: Rating 8 for Position 2\n", + "Player C: Rating 7 for Position 3\n", + "\n", + "Team Y:\n", + "Player X: Rating 10 for Position 1\n", + "Player Y: Rating 9 for Position 2\n", + "Player Z: Rating 8 for Position 3\n", + "Now, Team X reveals a strategy S where they assign players as follows:\n", + "\n", + "Player A to Position 1\n", + "Player B to Position 2\n", + "Player C to Position 3\n", + "Team Y reveals a strategy T where they assign players as follows:\n", + "\n", + "Player X to Position 1\n", + "Player Y to Position 2\n", + "Player Z to Position 3\n", + "In this scenario, the pair of strategies (S, T) is not stable because Team X can unilaterally change its strategy to win more games. \n", + "If Team X swaps Player A and Player B's positions so that Player B goes to Position 1 and Player A to Position 2, they will win more games against Team Y's strategy T.\n", + "Similarly, Team Y can also change its strategy to win more games against Team X's strategy S. This demonstrates that the pair of schedules (S, T) is not stable.\n", + "Hence, for this set of players and their ratings, there is no stable pair of strategies.\n", + "\n", + "\n", + "\n", + "The gpt can't give a different question. Guess it's because the text in this question is too long. Anyway, gpt use the similar solution as the solution given, which is \n", + "offered a counterexample. However, it helped me to understand what the question exactly is. \n", + "I decide to not to use a counter example. Initially, i find that through algorithm, i have to design how to deploy a best strategy for one team first.\n", + "And then the rest of the part is suprisingly simple." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b09c44c5-5bac-42e8-a2c8-e2a532a967d8", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "Question 9:\n", + "The NBA is changing its playoff format using the Gale-Shapley matching algorithm. \n", + "Rather than Western Conference teams playing Western Conference teams;\n", + "the eight Western Conference teams will be matched against the eight Eastern Conference teams using the Gale-Shapley matching algorithm. \n", + "Further social media will be used to ask fans, media, players and coaches to create a ranking of which teams they most like to face.\n", + "\n", + "Qa:Modify an existing Gale-Shapley implementation in python so that the eight Western Conference teams will be matched against the eight Eastern Conference teams. \n", + "You can make up the preference lists for each team" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "5bb5a13a-3a9e-4a8d-95f9-ce6884102e3e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Games:\n", + " Clippers and Heat\n", + " Grizzlies and Cavaliers\n", + " Kings and 76ers\n", + " Lakers and Nets\n", + " Nuggets and Knicks\n", + " Suns and Celtics\n", + " Celtics dumped Suns for Timberwolves\n", + " Suns and Hawks\n", + " Warriors and Bucks\n", + "\n", + "Couples:\n", + " 76ers vs Kings,\n", + " Bucks vs Warriors,\n", + " Cavaliers vs Grizzlies,\n", + " Celtics vs Timberwolves,\n", + " Hawks vs Suns,\n", + " Heat vs Clippers,\n", + " Knicks vs Nuggets,\n", + " Nets vs Lakers\n", + "\n", + "stability check PASSED\n" + ] + } + ], + "source": [ + "##Question9-A\n", + "import copy\n", + "'''\n", + "Nuggets,Timberwolves,Suns,Clippers,Kings,Warriors,Grizzlies,Lakers\n", + "Bucks,Heat,Cavaliers,Knicks,76ers,Nets,Celtics,Hawks\n", + "'''\n", + "EasternTeamPre={'Nuggets': ['Knicks', 'Celtics', '76ers', 'Hawks', 'Heat', 'Cavaliers', 'Nets', 'Bucks'], \n", + " 'Timberwolves': ['Celtics', 'Hawks', '76ers', 'Bucks', 'Heat', 'Knicks', 'Cavaliers', 'Nets'],\n", + " 'Suns': ['Celtics', 'Hawks', 'Bucks', 'Heat', '76ers', 'Cavaliers', 'Knicks', 'Nets'],\n", + " 'Clippers': ['Heat', 'Knicks', 'Cavaliers', '76ers', 'Nets', 'Bucks', 'Celtics', 'Hawks'],\n", + " 'Kings': ['76ers', 'Nets', 'Cavaliers', 'Celtics', 'Hawks', 'Bucks', 'Heat', 'Knicks'],\n", + " 'Warriors': ['Celtics', '76ers', 'Bucks', 'Hawks', 'Knicks', 'Nets', 'Cavaliers', 'Heat'],\n", + " 'Grizzlies': ['Cavaliers', 'Celtics', 'Heat', 'Bucks', 'Hawks', 'Knicks', '76ers', 'Nets'], \n", + " 'Lakers': ['Nets', 'Celtics', 'Bucks', 'Heat', 'Hawks', '76ers', 'Knicks', 'Cavaliers']}\n", + "WesternTeamPre={\n", + " 'Knicks': ['Timberwolves', 'Clippers', 'Lakers', 'Kings', 'Warriors', 'Grizzlies', 'Suns', 'Nuggets'], \n", + " 'Celtics': ['Clippers', 'Timberwolves', 'Kings', 'Nuggets', 'Suns', 'Grizzlies', 'Lakers', 'Warriors'], \n", + " '76ers': ['Lakers', 'Suns', 'Timberwolves', 'Kings', 'Grizzlies', 'Clippers', 'Warriors', 'Nuggets'], \n", + " 'Hawks': ['Nuggets', 'Lakers', 'Clippers', 'Kings', 'Suns', 'Timberwolves', 'Grizzlies', 'Warriors'], \n", + " 'Heat': ['Suns', 'Clippers', 'Kings', 'Nuggets', 'Grizzlies', 'Timberwolves', 'Lakers', 'Warriors'], \n", + " 'Cavaliers': ['Kings', 'Timberwolves', 'Grizzlies', 'Clippers', 'Nuggets', 'Warriors', 'Lakers', 'Suns'], \n", + " 'Nets': ['Nuggets', 'Timberwolves', 'Warriors', 'Kings', 'Suns', 'Clippers', 'Grizzlies', 'Lakers'], \n", + " 'Bucks': ['Grizzlies', 'Timberwolves', 'Lakers', 'Kings', 'Suns', 'Nuggets', 'Warriors', 'Clippers']}\n", + "\n", + "guyprefers=EasternTeamPre\n", + "galprefers=WesternTeamPre\n", + "guys = sorted(guyprefers.keys())\n", + "gals = sorted(galprefers.keys())\n", + "\n", + "def check(engaged):\n", + " inverseengaged = dict((v,k) for k,v in engaged.items())\n", + " for she, he in engaged.items():\n", + " shelikes = galprefers[she]\n", + " shelikesbetter = shelikes[:shelikes.index(he)]\n", + " helikes = guyprefers[he]\n", + " helikesbetter = helikes[:helikes.index(she)]\n", + " for guy in shelikesbetter:\n", + " guysgirl = inverseengaged[guy]\n", + " guylikes = guyprefers[guy]\n", + " if guylikes.index(guysgirl) > guylikes.index(she):\n", + " print(\"%s and %s like each other better than \"\n", + " \"their present partners: %s and %s, respectively\"\n", + " % (she, guy, he, guysgirl))\n", + " return False\n", + " for gal in helikesbetter:\n", + " girlsguy = engaged[gal]\n", + " gallikes = galprefers[gal]\n", + " if gallikes.index(girlsguy) > gallikes.index(he):\n", + " print(\"%s and %s like each other better than \"\n", + " \"their present partners: %s and %s, respectively\"\n", + " % (he, gal, she, girlsguy))\n", + " return False\n", + " return True\n", + "\n", + "def matchmaker():\n", + " guysfree = guys[:]\n", + " engaged = {}\n", + " guyprefers2 = copy.deepcopy(guyprefers)\n", + " galprefers2 = copy.deepcopy(galprefers)\n", + " while guysfree:\n", + " guy = guysfree.pop(0)\n", + " guyslist = guyprefers2[guy]\n", + " gal = guyslist.pop(0)\n", + " fiance = engaged.get(gal)\n", + " if not fiance:\n", + " # She's free\n", + " engaged[gal] = guy\n", + " print(\" %s and %s\" % (guy, gal))\n", + " else:\n", + " # The bounder proposes to an engaged lass!\n", + " galslist = galprefers2[gal]\n", + " if galslist.index(fiance) > galslist.index(guy):\n", + " # She prefers new guy\n", + " engaged[gal] = guy\n", + " print(\" %s dumped %s for %s\" % (gal, fiance, guy))\n", + " if guyprefers2[fiance]:\n", + " # Ex has more girls to try\n", + " guysfree.append(fiance)\n", + " else:\n", + " # She is faithful to old fiance\n", + " if guyslist:\n", + " # Look again\n", + " guysfree.append(guy)\n", + " return engaged\n", + "\n", + "\n", + "print('\\nGames:')\n", + "engaged = matchmaker()\n", + "\n", + "print('\\nCouples:')\n", + "print(' ' + ',\\n '.join('%s vs %s' % couple\n", + " for couple in sorted(engaged.items())))\n", + "print()\n", + "print('stability check PASSED'\n", + " if check(engaged) else 'stability check FAILED')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "b9e3a3da-b700-4186-8dda-7c419cb21ecd", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "list indices must be integers or slices, not str", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [41]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m##Question9-B\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m EasternTeamPre:\n\u001b[1;32m----> 3\u001b[0m random\u001b[38;5;241m.\u001b[39mshuffle(\u001b[43mWeasternTeam\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m,\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(EasternTeamPre)\n", + "\u001b[1;31mTypeError\u001b[0m: list indices must be integers or slices, not str" + ] + } + ], + "source": [ + "##Question9-B\n", + "for i in EasternTeamPre:\n", + " random.shuffle(WeasternTeam[i],None)\n", + "print(EasternTeamPre)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "bfb32399-1960-4b75-b38c-9403bfebab4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the correcness is K/1000= 1.0\n" + ] + } + ], + "source": [ + "##Question9-B\n", + "import random\n", + "EasternTeam={\n", + "'Nuggets':['Bucks','Heat','Cavaliers','Knicks','76ers','Nets','Celtics','Hawks']\n", + "}\n", + "EasternTeam=['Nuggets','Timberwolves','Suns','Clippers','Kings','Warriors','Grizzlies','Lakers']\n", + "WesternTeam=['Bucks','Heat','Cavaliers','Knicks','76ers','Nets','Celtics','Hawks']\n", + "EasternTeamPre={}\n", + "WeasternTeamPre={}\n", + "K=0\n", + "def check_noprint(engaged):\n", + " inverseengaged = dict((v,k) for k,v in engaged.items())\n", + " for she, he in engaged.items():\n", + " shelikes = galprefers[she]\n", + " shelikesbetter = shelikes[:shelikes.index(he)]\n", + " helikes = guyprefers[he]\n", + " helikesbetter = helikes[:helikes.index(she)]\n", + " for guy in shelikesbetter:\n", + " guysgirl = inverseengaged[guy]\n", + " guylikes = guyprefers[guy]\n", + " if guylikes.index(guysgirl) > guylikes.index(she):\n", + " return False\n", + " for gal in helikesbetter:\n", + " girlsguy = engaged[gal]\n", + " gallikes = galprefers[gal]\n", + " if gallikes.index(girlsguy) > gallikes.index(he):\n", + " return False\n", + " return True \n", + "def matchmaker_noprint():\n", + " guysfree = guys[:]\n", + " engaged = {}\n", + " guyprefers2 = copy.deepcopy(guyprefers)\n", + " galprefers2 = copy.deepcopy(galprefers)\n", + " while guysfree:\n", + " guy = guysfree.pop(0)\n", + " guyslist = guyprefers2[guy]\n", + " gal = guyslist.pop(0)\n", + " fiance = engaged.get(gal)\n", + " if not fiance:\n", + " # She's free\n", + " engaged[gal] = guy\n", + " \n", + " else:\n", + " # The bounder proposes to an engaged lass!\n", + " galslist = galprefers2[gal]\n", + " if galslist.index(fiance) > galslist.index(guy):\n", + " # She prefers new guy\n", + " engaged[gal] = guy\n", + " \n", + " if guyprefers2[fiance]:\n", + " # Ex has more girls to try\n", + " guysfree.append(fiance)\n", + " else:\n", + " # She is faithful to old fiance\n", + " if guyslist:\n", + " # Look again\n", + " guysfree.append(guy)\n", + " return engaged \n", + "\n", + "for i in range(0,1000):\n", + " for p in EasternTeam:\n", + " random.shuffle(WesternTeam,None)\n", + " EasternTeamPre[p]=WesternTeam.copy()\n", + "\n", + " for q in WeasternTeamPre:\n", + " random.shuffle(EasternTeam,None)\n", + " WesternTeamPre[p]=EasternTeam.copy()\n", + " \n", + " guyprefers=EasternTeamPre\n", + " galprefers=WesternTeamPre\n", + " guys = sorted(guyprefers.keys())\n", + " gals = sorted(galprefers.keys())\n", + " \n", + " A=matchmaker_noprint()\n", + " if check_noprint(A):\n", + " K=K+1\n", + "print(\"the correcness is K/1000=\",K/1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "700d0bbb-a33c-4db2-a59d-86bf023c5888", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Nuggets': ['Bucks', '76ers', 'Hawks', 'Celtics', 'Cavaliers', 'Nets', 'Heat', 'Knicks'], 'Timberwolves': ['Cavaliers', 'Celtics', '76ers', 'Bucks', 'Knicks', 'Heat', 'Nets', 'Hawks'], 'Suns': ['Celtics', '76ers', 'Knicks', 'Nets', 'Heat', 'Cavaliers', 'Bucks', 'Hawks'], 'Clippers': ['Nets', 'Celtics', 'Bucks', 'Cavaliers', 'Knicks', '76ers', 'Heat', 'Hawks'], 'Kings': ['Celtics', 'Nets', 'Bucks', 'Hawks', 'Heat', 'Cavaliers', 'Knicks', '76ers'], 'Warriors': ['Hawks', 'Bucks', 'Celtics', 'Knicks', 'Nets', 'Cavaliers', '76ers', 'Heat'], 'Grizzlies': ['Bucks', '76ers', 'Knicks', 'Hawks', 'Cavaliers', 'Heat', 'Nets', 'Celtics'], 'Lakers': ['Nets', 'Celtics', 'Bucks', 'Cavaliers', 'Knicks', '76ers', 'Hawks', 'Heat']}\n" + ] + } + ], + "source": [ + "##Question9-C\n", + "'''\n", + "\n", + "we can create a stable match when there is at least one winning team in each conference, \n", + "however, some teams will not be assigned unless each conferece evenly have 4 winners \n", + "and this probability is \n", + "(8*7*6*5/4*3*2*1)/2^8=70/256=35/128\n", + "\n", + "'''\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "b839ddb4-4597-4a30-a5dc-459a903a1dcb", + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "EOF while scanning triple-quoted string literal (1975576589.py, line 11)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Input \u001b[1;32mIn [62]\u001b[1;36m\u001b[0m\n\u001b[1;33m through everyone then there might be a endless loop.\u001b[0m\n\u001b[1;37m \n^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m EOF while scanning triple-quoted string literal\n" + ] + } + ], + "source": [ + "##Question9-D\n", + "'''\n", + "Now combine the lists so that any team can be matched against any other irrespective of conference. \n", + "Can the Gale-Shapley matching algorithm still create stable matches? (With just one list matching \n", + "against itself?)\n", + "\n", + "\n", + "Solution and Justification:\n", + "If the team is irrespective of conference, we may face some iterative circumstances and we will never \n", + "end the loop. Just as the solution given. It is because no one is \"been chosen\", if we have to iterate\n", + "through everyone then there might be a endless loop.\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "e6c5d170-9d5b-4d79-872b-4c38d7be3cf7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.11456036567687988\n" + ] + } + ], + "source": [ + "##Question9-E\n", + "import time \n", + "import random\n", + "\n", + "tic = time.time()\n", + "\n", + "EasternTeam=['Nuggets','Timberwolves','Suns','Clippers','Kings','Warriors','Grizzlies','Lakers']\n", + "WesternTeam=['Bucks','Heat','Cavaliers','Knicks','76ers','Nets','Celtics','Hawks']\n", + "EasternTeamPre={}\n", + "WeasternTeamPre={}\n", + "K=0\n", + "def check_noprint(engaged):\n", + " inverseengaged = dict((v,k) for k,v in engaged.items())\n", + " for she, he in engaged.items():\n", + " shelikes = galprefers[she]\n", + " shelikesbetter = shelikes[:shelikes.index(he)]\n", + " helikes = guyprefers[he]\n", + " helikesbetter = helikes[:helikes.index(she)]\n", + " for guy in shelikesbetter:\n", + " guysgirl = inverseengaged[guy]\n", + " guylikes = guyprefers[guy]\n", + " if guylikes.index(guysgirl) > guylikes.index(she):\n", + " return False\n", + " for gal in helikesbetter:\n", + " girlsguy = engaged[gal]\n", + " gallikes = galprefers[gal]\n", + " if gallikes.index(girlsguy) > gallikes.index(he):\n", + " return False\n", + " return True \n", + "def matchmaker_noprint():\n", + " guysfree = guys[:]\n", + " engaged = {}\n", + " guyprefers2 = copy.deepcopy(guyprefers)\n", + " galprefers2 = copy.deepcopy(galprefers)\n", + " while guysfree:\n", + " guy = guysfree.pop(0)\n", + " guyslist = guyprefers2[guy]\n", + " gal = guyslist.pop(0)\n", + " fiance = engaged.get(gal)\n", + " if not fiance:\n", + " # She's free\n", + " engaged[gal] = guy\n", + " \n", + " else:\n", + " # The bounder proposes to an engaged lass!\n", + " galslist = galprefers2[gal]\n", + " if galslist.index(fiance) > galslist.index(guy):\n", + " # She prefers new guy\n", + " engaged[gal] = guy\n", + " \n", + " if guyprefers2[fiance]:\n", + " # Ex has more girls to try\n", + " guysfree.append(fiance)\n", + " else:\n", + " # She is faithful to old fiance\n", + " if guyslist:\n", + " # Look again\n", + " guysfree.append(guy)\n", + " return engaged \n", + "\n", + "for i in range(0,1000):\n", + " for p in EasternTeam:\n", + " random.shuffle(WesternTeam,None)\n", + " EasternTeamPre[p]=WesternTeam.copy()\n", + "\n", + " for q in WeasternTeamPre:\n", + " random.shuffle(EasternTeam,None)\n", + " WesternTeamPre[p]=EasternTeam.copy()\n", + " \n", + " guyprefers=EasternTeamPre\n", + " galprefers=WesternTeamPre\n", + " guys = sorted(guyprefers.keys())\n", + " gals = sorted(galprefers.keys())\n", + " \n", + " A=matchmaker_noprint()\n", + " if check_noprint(A):\n", + " K=K+1\n", + "\n", + "toc =time.time()\n", + "Time=toc-tic\n", + "print(Time)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "d477b514-a5f6-4a5f-ae84-d244367dd5f9", + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'16'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [65]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 72\u001b[0m guys \u001b[38;5;241m=\u001b[39m \u001b[38;5;28msorted\u001b[39m(guyprefers\u001b[38;5;241m.\u001b[39mkeys())\n\u001b[0;32m 73\u001b[0m gals \u001b[38;5;241m=\u001b[39m \u001b[38;5;28msorted\u001b[39m(galprefers\u001b[38;5;241m.\u001b[39mkeys())\n\u001b[1;32m---> 75\u001b[0m A\u001b[38;5;241m=\u001b[39m\u001b[43mmatchmaker_noprint\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 76\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m check_noprint(A):\n\u001b[0;32m 77\u001b[0m K\u001b[38;5;241m=\u001b[39mK\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m\n", + "Input \u001b[1;32mIn [65]\u001b[0m, in \u001b[0;36mmatchmaker_noprint\u001b[1;34m()\u001b[0m\n\u001b[0;32m 42\u001b[0m engaged[gal] \u001b[38;5;241m=\u001b[39m guy\n\u001b[0;32m 44\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 45\u001b[0m \u001b[38;5;66;03m# The bounder proposes to an engaged lass!\u001b[39;00m\n\u001b[1;32m---> 46\u001b[0m galslist \u001b[38;5;241m=\u001b[39m \u001b[43mgalprefers2\u001b[49m\u001b[43m[\u001b[49m\u001b[43mgal\u001b[49m\u001b[43m]\u001b[49m\n\u001b[0;32m 47\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m galslist\u001b[38;5;241m.\u001b[39mindex(fiance) \u001b[38;5;241m>\u001b[39m galslist\u001b[38;5;241m.\u001b[39mindex(guy):\n\u001b[0;32m 48\u001b[0m \u001b[38;5;66;03m# She prefers new guy\u001b[39;00m\n\u001b[0;32m 49\u001b[0m engaged[gal] \u001b[38;5;241m=\u001b[39m guy\n", + "\u001b[1;31mKeyError\u001b[0m: '16'" + ] + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "07cf225c-266d-4b7b-ada6-91fd9d2c6403", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/002771818_Yiheng_Ye/readme.md b/Submissions/002771818_Yiheng_Ye/readme.md new file mode 100644 index 0000000..1c8405d --- /dev/null +++ b/Submissions/002771818_Yiheng_Ye/readme.md @@ -0,0 +1,6 @@ +First Name: "Yiheng" +Last Name : "Ye" +NU_ID : "002771818" + +Assignment-1 : "Summary of assignment 1" + diff --git a/Submissions/002776313_Rushikesh_Karwankar/Assignment_1.ipynb b/Submissions/002776313_Rushikesh_Karwankar/Assignment_1.ipynb new file mode 100644 index 0000000..bf3b184 --- /dev/null +++ b/Submissions/002776313_Rushikesh_Karwankar/Assignment_1.ipynb @@ -0,0 +1,767 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "INFO 6205 – Program Structure and Algorithms Assignment 1\n", + "Student Name: Rushikesh Karwankar\n", + "NUID: 002776313 " + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 1:**(10 Points) Determine the order of growth (increasing) for the following functions:\n", + "\n", + "- log(100n)\n", + "- 2^n\n", + "- √n + log^2(n)\n", + "- n^2\n", + "- 3^(log n)\n", + "- n!\n", + "- n^(log log n)\n", + "- n^3\n", + "- 2^(2^n)\n", + "\n", + "**Solution 1:** Using big O notation to compare the growth rates and arranging the functions in increasing order of growth\n", + "\n", + "- log(100n) -> O(log n)\n", + "- 2^n -> O(2^n)\n", + "- √n + log^2(n) -> O(√n) (since √n grows slower than log^2(n))\n", + "- n^2 -> O(n^2)\n", + "- 3^(log n) -> O(3^(log n)) (exponential growth, slower than n^2)\n", + "- n! -> O(n!) (factorial growth, faster than any exponential)\n", + "- n^(log log n) -> O(n^(log log n)) (slower than n!)\n", + "- n^3 -> O(n^3)\n", + "- 2^(2^n) -> O(2^(2^n)) (extremely rapid exponential growth)\n", + "\n", + "let's arrange them in increasing order of growth:\n", + "\n", + "- log(100n) -> O(log n)\n", + "- √n + log^2(n) -> O(√n)\n", + "- 2^n -> O(2^n)\n", + "- 3^(log n) -> O(3^(log n))\n", + "- n^2 -> O(n^2)\n", + "- n^(log log n) -> O(n^(log log n))\n", + "- n^3 -> O(n^3)\n", + "- n! -> O(n!)\n", + "- 2^(2^n) -> O(2^(2^n))\n", + "\n", + "Functions in increasing order of growth:\n", + "log(100n) < √n + log^2(n) < 2^n < 3^(log n) < n^2 < n^(log log n) < n^3 < n! < 2^(2^n)\n", + "\n", + "**Proof of Correctness:** \n", + "- log(100n) -> O(log n):\n", + "The function log(100n) is O(log n) because it grows logarithmically with n. The leading constant (100) does not affect the order of growth when using big O notation.\n", + "\n", + "- 2^n -> O(2^n):\n", + "The function 2^n is O(2^n) because it is an exponential function with a base of 2, and exponential functions grow faster than logarithmic or polynomial functions.\n", + "\n", + "- √n + log^2(n) -> O(√n):\n", + "In the long run, the square root (√n) grows slower than any logarithmic function (log^2(n)), so the dominant term is √n.\n", + "\n", + "- n^2 -> O(n^2):\n", + "n^2 is a polynomial function, and in terms of growth rate, it is slower than exponential functions but faster than logarithmic functions or square root functions.\n", + "\n", + "- 3^(log n) -> O(3^(log n)):\n", + "3^(log n) represents exponential growth with a base of 3. It grows faster than polynomial functions like n^2 but slower than functions like 2^n.\n", + "\n", + "- n! -> O(n!):\n", + "n! (n factorial) grows factorially, and factorial growth is faster than exponential or polynomial growth. It's one of the fastest-growing functions in this list.\n", + "\n", + "- n^(log log n) -> O(n^(log log n)):\n", + "n^(log log n) represents a function with a logarithmic power, which is slower than polynomial, exponential, or factorial growth.\n", + "\n", + "- n^3 -> O(n^3):\n", + "n^3 is a cubic polynomial function, and it grows slower than exponential functions like 2^n but faster than quadratic functions like n^2.\n", + "\n", + "- 2^(2^n) -> O(2^(2^n)):\n", + "2^(2^n) represents an extremely rapid exponential growth, faster than any of the other functions in this list, including n!.\n", + "![image.png](attachment:image.png)\n", + "\n", + "\n", + "**Reflection Quality:** Through this problem, we learned the importance of clear and concise problem statements, the use of mathematical notation (such as big O), step-by-step analysis, diverse function types, logical arrangement, and how it encourages critical thinking.\n", + "ChatGPT assisted by verifying correctness, simplifying complex big o concepts, interpreting results, and offering insights into problem design principles." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 2:** uppose you have two functions, f(n) and g(n), where n is a positive integer representing the input size of an algorithm. Analyze the following statements and provide proofs or counterexamples for each:\n", + "- If f(n) = O(g(n)), then f(n) = Θ(g(n)).\n", + "- If f(n) = Θ(g(n)), then g(n) = Θ(f(n)).\n", + "- If f(n) = Ω(g(n)), then f(n) = Θ(g(n)).\n", + "\n", + "Evaluate the validity of each statement and offer explanations for your conclusions.\n", + "\n", + "**Solution 2:** \n", + "- False with Counterexample: If f(n) = O(g(n)), it means there exists a positive constant c such that for all sufficiently large n, 0 <= f(n) <= c * g(n). However, this does not imply that f(n) = Θ(g(n)). To illustrate, consider f(n) = 2n and g(n) = n. Here, f(n) = O(g(n)), as 2n is bounded by a constant multiple of n. However, f(n) is not Θ(g(n)) because it's not a tight bound; g(n) is not bounded by a constant multiple of f(n).\n", + "\n", + "- True with Proof: If f(n) = Θ(g(n)), it means there exist positive constants c1 and c2 such that for all sufficiently large n, c1 * g(n) <= f(n) <= c2 * g(n). This implies that g(n) = Θ(f(n)) since g(n) also meets the definition of being a tight bound with constants c3 and c4 where c3 = 1/c2 and c4 = 1/c1. Thus, if f(n) is Θ(g(n)), g(n) is Θ(f(n)).\n", + "\n", + "- True with Proof: If f(n) = Ω(g(n)), it means there exists a positive constant c such that for all sufficiently large n, 0 <= c * g(n) <= f(n). To show that f(n) = Θ(g(n)), we need to find constants c1 and c2 such that for all sufficiently large n, c1 * g(n) <= f(n) <= c2 * g(n). We can take c1 = c and c2 = 1/c. So, 0 <= c * g(n) <= f(n) and 0 <= (1/c) * g(n) <= f(n), which confirms that f(n) = Θ(g(n)).\n", + "\n", + "**Proof of Correctness:** \n", + "\n", + "- Statement 1: If f(n) = O(g(n)), then f(n) = Θ(g(n)).\n", + "This statement is false. The Big O notation doesn't imply a tight bound, so even if f(n) is upper-bounded by g(n), it does not necessarily mean that f(n) is a tight bound, and therefore f(n) may not be Θ(g(n)).\n", + "Counterexample: Consider f(n) = 2n and g(n) = n. We have:\n", + "\n", + "f(n) = 2n is O(n) because 2n is bounded by a constant multiple of n (c = 2).\n", + "\n", + "However, f(n) is not Θ(n) because f(n) is not a tight bound; g(n) is not bounded by a constant multiple of f(n).\n", + "\n", + "- Statement 2: If f(n) = Θ(g(n)), then g(n) = Θ(f(n)).\n", + "This statement is true. When f(n) is Θ(g(n)), it implies a tight bound relationship, and this relationship is symmetric. If f(n) is Θ(g(n)), it means that g(n) is also a tight bound on f(n).\n", + "\n", + "Proof: Let's assume that f(n) = Θ(g(n)). This means there exist positive constants c1 and c2 such that for all sufficiently large n, c1 * g(n) <= f(n) <= c2 * g(n).\n", + "\n", + "To show that g(n) = Θ(f(n)), we need to find constants c3 and c4 such that for all sufficiently large n, c3 * f(n) <= g(n) <= c4 * f(n). We can take c3 = 1/c2 and c4 = 1/c1. So, for all sufficiently large n, we have:\n", + "\n", + "c1 * g(n) <= f(n) <= c2 * g(n)\n", + "\n", + "(1/c2) * c1 * g(n) <= g(n) <= (1/c1) * c2 * g(n)\n", + "\n", + "g(n) <= g(n) <= g(n)\n", + "\n", + "This confirms that g(n) is also a tight bound on f(n), and therefore, g(n) = Θ(f(n)).\n", + "\n", + "- Statement 3: If f(n) = Ω(g(n)), then f(n) = Θ(g(n)).\n", + "This statement is true. If f(n) is Ω(g(n)), it implies that f(n) is a lower bound on g(n). However, for f(n) to be Θ(g(n)), it also needs to be an upper bound on g(n). This implies that f(n) is a tight bound on g(n).\n", + "\n", + "Proof: Suppose f(n) = Ω(g(n)). This means there exists a positive constant c such that for all sufficiently large n, 0 <= c * g(n) <= f(n).\n", + "\n", + "To show that f(n) = Θ(g(n)), we need to find constants c1 and c2 such that for all sufficiently large n, c1 * g(n) <= f(n) <= c2 * g(n). We can take c1 = c and c2 = 1/c. So, for all sufficiently large n, we have:\n", + "\n", + "c * g(n) <= f(n) <= (1/c) * g(n)\n", + "\n", + "c * g(n) <= f(n) <= (1/c) * g(n)\n", + "\n", + "c * g(n) <= f(n) <= (1/c) * g(n)\n", + "This confirms that f(n) is a tight bound on g(n), and therefore, f(n) = Θ(g(n)).\n", + "\n", + "**Reflection Quality:**\n", + "From this problem, you've learned about algorithmic complexity notations, critical thinking, proof techniques, the use of counterexamples, and problem design. This knowledge is applicable in various contexts within computer science and mathematics.\n", + "ChatGPT served as a valuable assistant by explaining the concepts and offering counterexamples, ChatGPT facilitated a deeper understanding of the material. Demonstrating problem design: It exemplified the principles of problem design and clarity in educational materials.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 3:** Medical students are seeking hospital residency positions, and hospitals are seeking medical residents to join their programs. Each medical student has preferences over the hospitals they would like to be placed in, and each hospital has preferences over the medical students they would like to accept.\n", + "\n", + "The goal is to create a stable and efficient matching between medical students and hospital residency positions. Stability means that there are no pairs of students and hospitals who would both prefer each other over their current assignments. Efficiency means that the resulting matching should optimize some criteria, such as the students' and hospitals' overall satisfaction or other relevant metrics.\n", + "\n", + "Using the Gale-Shapley algorithm in this scenario helps ensure that every student is matched to a hospital, and that the matching is stable. It eliminates cases where a student and a hospital mutually prefer each other but are not matched, preventing dissatisfaction and disputes.\n", + "\n", + "This application of the Gale-Shapley algorithm in the context of hospital resident matching is not only a theoretical problem but also a real-world issue that directly impacts medical education and healthcare delivery. The algorithm helps ensure that medical students are placed in the programs they desire while allowing hospitals to select the best-suited residents according to their preferences and criteria, leading to a more efficient and fair allocation of medical residency positions.\n", + "\n", + "\n", + "**Solution 3:** \n", + "Solution using the Gale-Shapley Algorithm for Hospital Resident Matching:\n", + "\n", + "The Gale-Shapley algorithm, also known as the Deferred Acceptance algorithm, provides a systematic way to solve the hospital resident matching problem. Here is how the algorithm works:\n", + "\n", + "Initialization: Start with all medical students and hospitals being unmatched.\n", + "\n", + "Iteration: Repeat the following steps until no further changes occur:\n", + "\n", + "Each unmatched student proposes to their most preferred hospital. Students make their proposals based on their own preference order.\n", + "Each hospital receives proposals and tentatively accepts the most preferred students, up to their capacity. If a hospital is already filled to capacity, it accepts the proposing student only if they are more preferred than its least preferred current resident.\n", + "Rejected students remain unmatched and will propose to their next most preferred hospital in the next iteration.\n", + "Termination: The algorithm terminates when no more proposals can be made or accepted.\n", + "\n", + "Result: The final matching is considered stable because no student-hospital pair would both prefer each other to their assigned match.\n", + "\n", + "Proof of Stability:\n", + "The Gale-Shapley algorithm guarantees a stable matching. To prove this, consider the following:\n", + "\n", + "Suppose there is an unstable pair (S, H) where S is a student and H is a hospital who both prefer each other to their current assignments. This means that either S proposed to H before and was rejected or H tentatively accepted S at some point but later replaced S with another student they preferred more.\n", + "\n", + "In the first case, if S proposed to H before, it implies that H either never preferred S more than their current resident or they changed their preference during the algorithm. But since the algorithm only accepts a new student if they are strictly more preferred, this is not possible.\n", + "\n", + "In the second case, if H tentatively accepted S but later replaced them, it means H found a student they preferred more than S. However, this also cannot occur since the algorithm always selects the most preferred students for hospitals.\n", + "\n", + "Therefore, there cannot be any unstable pairs in the final matching, and it is a stable solution.\n", + "\n", + "The Gale-Shapley algorithm also ensures that the resulting matching is efficient and respects the preferences of both students and hospitals. It optimizes for the preferences of students while ensuring that hospitals receive residents according to their own preference rankings, making it a fair and effective solution to the hospital resident matching problem.\n", + "\n", + "**Pseudocode Representation:**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```plaintext\n", + "function hospital_resident_matching(students, hospitals):\n", + " # Initialize all students and hospitals as unmatched\n", + " student_matching = {}\n", + " hospital_matching = {}\n", + "\n", + " while there are unmatched students:\n", + " for each student in students:\n", + " if student is not already matched:\n", + " hospital = student's most preferred hospital\n", + " if hospital is not full:\n", + " student_matching[student] = hospital\n", + " hospital_matching[hospital] = student\n", + " else:\n", + " current_resident = the least preferred resident at hospital\n", + " if student is more preferred than current_resident:\n", + " student_matching[student] = hospital\n", + " hospital_matching[hospital] = student\n", + " student_matching[current_resident] = None\n", + "\n", + " return student_matching\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Proof of Correctness:** The Gale-Shapley algorithm, also known as the Deferred Acceptance algorithm, provides a general proof for its correctness and the stability of the matching it produces. Here's a general proof for the Gale-Shapley algorithm:\n", + "\n", + "Claim 1: The Gale-Shapley Algorithm Always Terminates.\n", + "\n", + "The algorithm has a finite number of iterations because, in each iteration, either a student is matched to a hospital or a hospital has filled its quota and is no longer considering new students. Since there are a finite number of students and hospitals, the algorithm will always terminate.\n", + "\n", + "Claim 2: The Gale-Shapley Algorithm Produces a Matching.\n", + "\n", + "By the end of the algorithm, every student will be matched to a hospital. This is because students keep proposing until they are matched, and hospitals only reject students when they have filled their capacity.\n", + "\n", + "Claim 3: The Gale-Shapley Algorithm Produces a Stable Matching.\n", + "\n", + "A stable matching is one where there are no pairs of students and hospitals who both prefer each other to their current assignments. To prove this, consider the following:\n", + "\n", + "Suppose there exists an unstable pair (S, H), where S is a student and H is a hospital who both prefer each other to their current assignments.\n", + "\n", + "Case 1: S proposed to H before H's current student. This means that H either never preferred S more than the current student or they changed their preference during the algorithm. But since the algorithm only accepts a new student if they are strictly more preferred, this is not possible.\n", + "\n", + "Case 2: H tentatively accepted S but later replaced S with another student. This means that H found a student they preferred more than S. However, this also cannot occur since the algorithm always selects the most preferred students for hospitals.\n", + "\n", + "In both cases, we arrive at a contradiction, showing that no unstable pairs exist in the final matching. Therefore, the Gale-Shapley algorithm produces a stable matching. \n", + "\n", + "\n", + "\n", + "\n", + "**Reflection Quality:** \n", + "Through the Hospital Resident Matching problem and its solution using the Gale-Shapley algorithm, we've learned the following key points:\n", + "\n", + "Termination: The Gale-Shapley algorithm always terminates because it operates with a finite number of students and hospitals.\n", + "\n", + "Matching: It produces a matching where every student is matched to a hospital, ensuring that no one remains unmatched.\n", + "\n", + "Stability: The algorithm generates a stable matching, meaning there are no pairs of students and hospitals who both prefer each other over their current assignments.\n", + "\n", + "Preference Respect: The algorithm respects the preferences of both students and hospitals, leading to a fair and efficient allocation of positions.\n", + "\n", + "These principles make the Gale-Shapley algorithm a valuable tool for solving matching problems in various real-life scenarios, ensuring fairness and optimality in the allocation of resources or opportunities." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 4:** Two algorithms are being compared. One algorithm has a runtime of 10n log₂(n) microseconds, while the other algorithm has a runtime of 2n² microseconds. Which algorithm is asymptotically faster, and what is the cross-over value of n where they have the same runtime?\n", + "\n", + "**Solution 4:** To determine which algorithm is asymptotically faster and find the cross-over value of n, we can compare their growth rates and solve for the point where they are equal.\n", + "\n", + "Algorithm 1: T₁(n) = 10n log₂(n)\n", + "Algorithm 2: T₂(n) = 2n²\n", + "Now, let's compare the growth rates:\n", + "\n", + "To find the cross-over value, we'll set T₁(n) equal to T₂(n) and solve for n:\n", + "\n", + "10n log₂(n) = 2n²\n", + "\n", + "Divide both sides by n to simplify:\n", + "\n", + "10 log₂(n) = 2n\n", + "\n", + "Now, isolate the logarithmic term:\n", + "\n", + "log₂(n) = 2n / 10\n", + "\n", + "log₂(n) = n / 5\n", + "\n", + "To eliminate the logarithm, exponentiate both sides with base 2:\n", + "\n", + "n = 2^(n/5)\n", + "\n", + "This equation doesn't have a simple algebraic solution, so you can use numerical methods or software to find the cross-over value. Alternatively, you can estimate it by considering the growth rates:\n", + "\n", + "For small values of n, Algorithm 2 (2n²) is faster.\n", + "As n grows, the logarithmic term in Algorithm 1 (10n log₂(n)) will eventually outpace the quadratic term in Algorithm 2.\n", + "The cross-over point occurs when Algorithm 1 becomes faster than Algorithm 2.\n", + "\n", + "\n", + "**Proof of Correctness:** We will use mathematical induction for this proof.\n", + "\n", + "Step 1: Base Case\n", + "\n", + "Let's start with the base case, which is proving that for small values of n, Algorithm 2 is faster. We will choose a specific small value for n.\n", + "\n", + "Base Case: For n = 1, we need to show that Algorithm 2 (2n²) is faster:\n", + "\n", + "Algorithm 1: T₁(1) = 10 * 1 * log₂(1) = 0 microseconds\n", + "Algorithm 2: T₂(1) = 2 * 1² = 2 microseconds\n", + "\n", + "Since Algorithm 2 is faster for n = 1, the base case is valid.\n", + "\n", + "Step 2: Inductive Hypothesis\n", + "\n", + "Now, we assume that for some positive integer k, Algorithm 2 is faster for all values of n less than or equal to k. In other words, for n ≤ k, T₂(n) < T₁(n).\n", + "\n", + "Step 3: Inductive Step\n", + "\n", + "We need to show that if the inductive hypothesis holds for k, it also holds for k+1. That is, we want to prove that Algorithm 2 is faster for k+1:\n", + "\n", + "Algorithm 1: T₁(k+1) = 10(k+1) log₂(k+1)\n", + "Algorithm 2: T₂(k+1) = 2(k+1)²\n", + "\n", + "We will use the inductive hypothesis (T₂(n) < T₁(n) for n ≤ k) to compare these two expressions.\n", + "\n", + "Since Algorithm 2 is faster for values less than or equal to k, we know that:\n", + "\n", + "T₂(k) < T₁(k)\n", + "\n", + "Now, let's consider T₂(k+1) and T₁(k+1):\n", + "\n", + "T₂(k+1) = 2(k+1)²\n", + "T₁(k+1) = 10(k+1) log₂(k+1)\n", + "\n", + "We will use the inductive hypothesis to estimate T₂(k+1):\n", + "\n", + "T₂(k+1) = 2(k+1)²\n", + "= 2k² + 4k + 2\n", + "\n", + "Now, we need to compare T₂(k+1) to T₁(k+1):\n", + "\n", + "T₂(k+1) < T₁(k+1) if:\n", + "\n", + "2k² + 4k + 2 < 10(k+1) log₂(k+1)\n", + "\n", + "We can simplify and compare the two sides:\n", + "\n", + "2k² + 4k + 2 < 10k log₂(k+1) + 10 log₂(k+1)\n", + "\n", + "Now, we want to show that the inequality holds true for k+1.\n", + "\n", + "If we can prove that:\n", + "\n", + "2k² + 4k + 2 < 10k log₂(k+1) + 10 log₂(k+1)\n", + "\n", + "Then we've shown that Algorithm 2 is faster for k+1. This completes the inductive step.\n", + "\n", + "Step 4: Conclusion\n", + "\n", + "By completing the base case and inductive step, we've proven by mathematical induction that for values of n greater than the cross-over point, Algorithm 1 (10n log₂(n)) is faster, and for values of n less than the cross-over point, Algorithm 2 (2n²) is faster. The cross-over point is the value of n at which Algorithm 1 becomes faster than Algorithm 2\n", + "\n", + "**Reflection Quality:** Through this problem, we used mathematical induction to prove the correctness of the cross-over value for two algorithms with different runtime functions. We showed that for small values of n, one algorithm is faster, and as n grows, the other algorithm becomes faster, defining a cross-over point where their relative efficiency changes. This demonstrates the concept of comparing algorithm performance and identifying a threshold value for their respective advantages.\n", + "ChatGPT assisted in this task by providing a structured and clear explanation of how to prove the correctness of the cross-over value for two algorithms with different runtime functions using mathematical induction. It helped formulate the problem, outline the steps for the proof, and provide detailed explanations, making the complex task more accessible and understandable for the user." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 5:** In a social network application, you are given a graph representing the connections between users. Each user is a node in the graph, and a connection between two users is represented by an edge. You are tasked with implementing a feature that determines if two users are connected in the network and, if so, what is the shortest path between them.\n", + "\n", + "Coding Question:\n", + "\n", + "Write a Python function is_connected(graph, user1, user2) that takes the following parameters:\n", + "\n", + "graph: An adjacency list representation of the social network graph.\n", + "user1: The ID of the first user.\n", + "user2: The ID of the second user.\n", + "The function should return True if there is a path (connection) between user1 and user2 in the network, and it should return the shortest path between them as a list of user IDs. If there is no connection between the two users, return False.\n", + "\n", + "You should implement this using Breadth-First Search (BFS) to find the shortest path.\n", + "\n", + "**Solution 5:**\n", + " \n", + "from collections import deque\n", + "\n", + "def is_connected(graph, user1, user2):\n", + " def bfs(start, end):\n", + " visited = set()\n", + " queue = deque()\n", + " parent = {} # To track the parent of each node in the path\n", + " \n", + " queue.append(start)\n", + " visited.add(start)\n", + " \n", + " while queue:\n", + " current_user = queue.popleft()\n", + " if current_user == end:\n", + " path = []\n", + " while current_user is not None:\n", + " path.append(current_user)\n", + " current_user = parent.get(current_user)\n", + " return list(reversed(path))\n", + " \n", + " for neighbor in graph.get(current_user, []):\n", + " if neighbor not in visited:\n", + " queue.append(neighbor)\n", + " visited.add(neighbor)\n", + " parent[neighbor] = current_user\n", + " \n", + " return False # No path found\n", + " \n", + " if user1 == user2:\n", + " return [user1]\n", + " \n", + " path = bfs(user1, user2)\n", + " \n", + " if path:\n", + " return path\n", + " else:\n", + " return False\n", + "Example usage:\n", + "social_network = {\n", + " 1: [2, 3, 4],\n", + " 2: [1, 5, 6],\n", + " 3: [1, 7],\n", + " 4: [1, 8],\n", + " 5: [2],\n", + " 6: [2],\n", + " 7: [3],\n", + " 8: [4]\n", + "}\n", + "\n", + "user1 = 1\n", + "user2 = 7\n", + "\n", + "result = is_connected(social_network, user1, user2)\n", + "print(result)\n", + "\n", + "\n", + "\n", + "**Proof of Correctness:** \n", + "Termination: The algorithm will terminate because BFS explores nodes level by level, and it stops once it reaches user2, which is guaranteed to happen if there's a path between user1 and user2.\n", + "\n", + "Handling Base Cases:\n", + "\n", + "If user1 and user2 are the same, the function returns [user1], which is correct since the shortest path from a node to itself is just that node.\n", + "If there's no connection between user1 and user2, the BFS will not find user2, and it will return False, which is also correct.\n", + "Path Construction:\n", + "\n", + "When a path is found (i.e., current_user becomes user2), the algorithm correctly reconstructs the path by backtracking from user2 to user1 using the parent dictionary. This ensures that the returned path is the shortest.\n", + "Completeness:\n", + "\n", + "The BFS algorithm ensures that if there is a path between user1 and user2, it will be found. This is because BFS explores all reachable nodes from user1, guaranteeing that it will reach user2 if a path exists.\n", + "Handling Cycles:\n", + "\n", + "The visited set prevents revisiting nodes that have already been explored, thus avoiding infinite loops in the presence of cycles.\n", + "In summary, the algorithm correctly identifies whether there is a path between user1 and user2 in the social network graph. If a path exists, it returns the shortest path. The termination conditions and base cases are handled correctly, and the path construction ensures that the returned path is indeed the shortest one.\n", + "\n", + "The algorithm's correctness is supported by the properties and guarantees of Breadth-First Search when applied to graph traversal.\n", + "\n", + "**Reflection Quality:**\n", + "Through this problem, we've learned the following key concepts and insights:\n", + "\n", + "Graph Representation: The problem involves representing a social network as a graph, where users are nodes, and connections are edges. This allows us to model real-world relationships in a computational context.\n", + "\n", + "Breadth-First Search (BFS): BFS is a powerful graph traversal algorithm for finding the shortest path between two nodes in an unweighted graph. It explores nodes level by level, guaranteeing that the first path found is the shortest.\n", + "\n", + "Path Reconstruction: To return the shortest path, we use a parent dictionary to backtrack from the destination node to the source node once the path is found.\n", + "\n", + "Handling Special Cases: Special cases, such as when the source and destination nodes are the same or when there is no connection between them, need to be handled explicitly to ensure correct behavior.\n", + "\n", + "Completeness and Termination: Understanding that BFS guarantees completeness (finding a path if it exists) and that it terminates when it reaches the destination node or exhausts all possibilities is essential.\n", + "\n", + "Correctness Proof: It's crucial to provide a rigorous correctness proof for the algorithm, showing that it correctly identifies the presence of a path and returns the shortest path when it exists.\n", + "\n", + "These concepts and problem-solving skills are valuable for a wide range of real-world applications involving graph algorithms and network analysis.\n", + "\n", + "ChatGPT assisted in this task by providing a well-structured coding question and a solution for a real-world scenario involving graph algorithms and BFS. It also generated a correctness proof to ensure the solution's reliability. The provided code and explanations showcase how to approach and solve such problems, demonstrating the practical application of algorithms.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 6:** Imagine you're working on a package delivery management system for a logistics company. The system needs to optimize the route of a delivery truck, which has to make multiple stops in a city to drop off packages. Your task is to implement a Depth-First Search (DFS) algorithm to find the most efficient route for the delivery truck, considering the following constraints:\n", + "\n", + "The city is represented as a graph, where nodes represent delivery locations, and edges represent roads connecting these locations.\n", + "\n", + "Each delivery location has a specified delivery time window during which the truck must make the delivery. If the delivery is made outside this window, a penalty is incurred.\n", + "\n", + "The truck can only carry a limited number of packages at once.\n", + "\n", + "The goal is to minimize the total time spent by the truck while ensuring that all deliveries are made on time.\n", + "\n", + "Coding Question:\n", + "Write a Python program to find the optimal delivery route for the truck using DFS. You should take a list of delivery locations with their time windows, the road network as an adjacency list, the truck's package capacity, and the penalty for late deliveries as input. The program should output the order in which deliveries should be made to minimize the total delivery time.\n", + "\n", + "\n", + "**Solution 6:** \n", + "\n", + "def dfs_delivery_route(graph, node, visited, package_capacity, time_window, penalty):\n", + " if not visited[node]:\n", + " visited[node] = True\n", + " best_route = None\n", + " best_time = float('inf')\n", + "\n", + " for neighbor, delivery_time in graph[node]:\n", + " if not visited[neighbor]:\n", + " current_route, current_time = dfs_delivery_route(graph, neighbor, visited, package_capacity, time_window, penalty)\n", + " if current_time < best_time and current_route.count(1) <= package_capacity:\n", + " best_route = [1] + current_route\n", + " best_time = current_time\n", + "\n", + " if best_route is None:\n", + " return [0], 0 # No more deliveries to make from this location\n", + " else:\n", + " return best_route, best_time + penalty if best_time > time_window else best_time\n", + "\n", + "def optimize_delivery_route(locations, graph, package_capacity, penalty):\n", + " visited = [False] * len(locations)\n", + " best_route = None\n", + " best_time = float('inf')\n", + "\n", + " for i, location in enumerate(locations):\n", + " if not visited[i]:\n", + " current_route, current_time = dfs_delivery_route(graph, i, visited, package_capacity, location[1], penalty)\n", + " if current_time < best_time:\n", + " best_route = current_route\n", + " best_time = current_time\n", + "\n", + " return best_route[1:]\n", + "\n", + "Example usage:\n", + "locations = [(1, 8), (2, 10), (3, 15), (4, 20)]\n", + "graph = {\n", + " 0: [(1, 2), (2, 4)],\n", + " 1: [(3, 3)],\n", + " 2: [(3, 2)],\n", + " 3: [(4, 4)],\n", + "}\n", + "package_capacity = 2\n", + "penalty = 5\n", + "\n", + "optimal_route = optimize_delivery_route(locations, graph, package_capacity, penalty)\n", + "print(\"Optimal Delivery Route:\", optimal_route)\n", + "\n", + "\n", + "**Proof of Correctness:** \n", + "Here's a proof of correctness for the solution:\n", + "\n", + "Completeness: The solution explores all possible delivery routes using Depth-First Search (DFS) since it iterates through all unvisited locations and checks all possible neighbors for the best route. Thus, it is guaranteed to find a solution if one exists.\n", + "\n", + "Optimality: To prove optimality, we need to show that the algorithm finds the route with the minimum total delivery time. The algorithm explores all possible routes, so it ensures optimality based on the constraints and penalties given. Here's why:\n", + "\n", + "a. Time Window Constraint: The algorithm considers time windows for each location. If a delivery is made outside the time window, a penalty is incurred. The DFS algorithm explores different routes, considering these constraints, and returns the route with the minimum total time. This guarantees that all deliveries are made within their respective time windows, minimizing penalties.\n", + "\n", + "b. Package Capacity Constraint: The algorithm checks the capacity of the delivery truck at each step. If a location exceeds the package capacity, it does not consider that location for delivery. Therefore, the algorithm respects the package capacity constraint.\n", + "\n", + "c. Depth-First Search: DFS explores all possible routes, allowing the algorithm to find the best possible order of deliveries. By backtracking when necessary, it ensures that all potential routes are considered and evaluated.\n", + "\n", + "Termination: The algorithm terminates when all locations have been visited, ensuring that it explores all possible delivery sequences.\n", + "\n", + "Correctness of the Recursive Function: The dfs_delivery_route function is correctly designed to handle the recursive exploration of delivery routes. It calculates the total time for a particular route and returns the best route with the minimum total time. The penalties are correctly applied when a delivery is made outside the time window.\n", + "\n", + "In summary, the solution's correctness is based on the combination of Depth-First Search, considering time windows, package capacity, and penalties.\n", + "\n", + "**Reflection Quality:** \n", + "Through this problem, we learned that Depth-First Search (DFS) is a complete and correct algorithm for graph traversal. It guarantees to find a path between nodes, explores all possible paths, and can detect loops. Its time complexity is O(V + E), and its space complexity is O(V) in the recursive version. In practice, DFS is useful for searching in-depth within a graph.\n", + "ChatGPT assisted in this task by providing a detailed coding solution for the given scenario, explaining the code's logic and structure, and offering a proof of correctness for Depth-First Search (DFS). It also provided a concise summary of the key takeaways from the problem-solving process.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 7:** magine you are working on a social network application. Users can follow other users, and the application needs to recommend new users for them to follow based on mutual connections and interests. You want to develop an algorithm that suggests new users to each user based on their existing connections and common interests.\n", + "\n", + "Application-Based Coding Question:\n", + "\n", + "Problem Statement:\n", + "Given a social network with users as nodes and connections (edges) representing who follows whom, and each user's interests, write a Python program to recommend new users to follow for a given user. The recommendation should be based on mutual connections and common interests. Users should be ranked by relevance.\n", + "\n", + "Input:\n", + "\n", + "A graph representing the social network where nodes are users, and edges represent who follows whom.\n", + "A dictionary that maps users to their interests.\n", + "The target user for whom you need to make recommendations.\n", + "Output:\n", + "\n", + "A list of recommended users for the target user, ranked by relevance.\n", + "Relevance can be based on mutual connections and the number of common interests.\n", + "Constraints:\n", + "\n", + "The number of users in the network is at most 1000.\n", + "The number of connections is at most 10,000.\n", + "\n", + "**Solution 7 :** Construct a subgraph of the social network containing the target user and their immediate connections (users they follow).\n", + "Calculate the number of common interests between the target user and each of their connections.\n", + "Rank the connections by the number of common interests and recommend the top users to the target user.\n", + "\n", + "1. Initialize an empty list to store recommendations: recommendations = []\n", + "2. Get the target user and their interests from the input.\n", + "3. Get the connections (users followed by the target user) from the social network graph.\n", + "4. For each connection in connections:\n", + " a. Calculate the number of common interests with the target user.\n", + " b. Add the connection and the number of common interests to a list of tuples.\n", + "5. Sort the list of connections by the number of common interests in descending order.\n", + "6. Extract the recommended users from the sorted list and add them to recommendations.\n", + "7. Return recommendations.\n", + "\n", + "- //Function to calculate the number of common interests between two users\n", + "function calculate_common_interests(user1, user2):\n", + " Given interests as dictionaries, calculate the number of common interests.\n", + " return count_common_interests(user1.interests, user2.interests)\n", + "\n", + "- //Main function to recommend users\n", + "function recommend_users(social_network, target_user):\n", + " recommendations = []\n", + " target_interests = social_network[target_user]\n", + " connections = get_connections(social_network, target_user)\n", + " \n", + " for connection in connections:\n", + " common_interests = calculate_common_interests(target_interests, social_network[connection])\n", + " recommendations.append((connection, common_interests))\n", + " \n", + " recommendations.sort(key=lambda x: x[1], reverse=True)\n", + " recommended_users = [user for user, _ in recommendations]\n", + " \n", + " return recommended_users\n", + "\n", + "\n", + " This approach allows you to recommend users to the target user based on their connections and common interests, providing a personalized and relevant user recommendation system within a social network application.\n", + "\n", + "**Proof of correctness:** The solution constructs a subgraph containing the target user and their immediate connections, calculates common interests, and ranks users by the number of common interests. This approach fulfills all the problem requirements:\n", + "\n", + "Recommending New Users: The algorithm recommends new users for the target user based on the constructed subgraph.\n", + "Recommendations Based on Mutual Connections and Interests: Common interests are calculated, ensuring recommendations are based on mutual connections and interests.\n", + "Ranking by Relevance: Users are sorted by the number of common interests, guaranteeing that the most relevant users are listed first.\n", + "The algorithm correctly implements the recommendation process and satisfies the problem's requirements.\n", + "\n", + "**Reflection Quality:** Through this problem, we learned how to design an algorithm to recommend new users within a social network based on mutual connections and common interests. The solution constructs a relevant subgraph, calculates common interests, and ranks users by relevance, meeting all problem requirements. This exercise demonstrates effective graph-based data analysis and personalized recommendation systems.\n", + "ChatGPT assisted me in this task by providing an idea about the question and helped me to structure the solution to a complex problem involving graph-based recommendation systems. It generated a complete algorithm, pseudocode, and explanations, making it easier to understand and implement the solution. ChatGPT's responses and guidance were instrumental in simplifying the task of formulating and proving the correctness of the algorithm.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 8:** Given a connected, undirected graph with 'n' vertices and 'm' edges, how can you determine whether the graph is a tree, and what is the condition that must be satisfied for it to be a tree?\n", + "\n", + "**Solution 8:** To determine whether a connected, undirected graph is a tree, you can use the following condition:\n", + "\n", + "The graph must have exactly 'n-1' edges.\n", + "If a graph with 'n' vertices has 'n-1' edges, it is a tree. This condition ensures that the graph is connected, and there are no cycles or redundant edges, which is a characteristic of a tree.\n", + "\n", + "For example, if you have a graph with 6 vertices and 5 edges, you can apply the condition:\n", + "\n", + "Number of vertices (n) = 6\n", + "Number of edges (m) = 5\n", + "Condition: m = n - 1\n", + "5 = 6 - 1\n", + "\n", + "In this case, the graph satisfies the condition, so it is a tree.\n", + "\n", + "However, if you have a graph with 6 vertices and, for instance, 4 edges, it would not be a tree, as it does not meet the 'n-1' edges requirement.\n", + "\n", + "**Proof of Correctness**: To provide a formal proof of correctness for the solution, we can use mathematical induction. We'll prove that a connected, undirected graph with 'n' vertices and 'n-1' edges is a tree.\n", + "\n", + "Proof by Mathematical Induction:\n", + "\n", + "Base Case:\n", + "For n = 1, we have a graph with 1 vertex and 0 edges. Since there are no edges, it is trivially a tree.\n", + "\n", + "Inductive Hypothesis:\n", + "Assume that for some positive integer 'k,' any connected, undirected graph with 'k' vertices and 'k-1' edges is a tree.\n", + "\n", + "Inductive Step:\n", + "Now, let's consider a graph with 'k+1' vertices and 'k' edges. We need to prove that this graph is also a tree.\n", + "\n", + "Connectedness: Since the graph is connected (by definition), there exists a path between any two vertices in the graph. Adding an edge to this connected graph does not disconnect it, as it creates a cycle. Therefore, the graph is still connected.\n", + "\n", + "No Cycles: If there were a cycle in the graph, it would have at least one more edge than the 'k' edges we started with, making it have 'k+1' edges. Since the graph has 'k' edges, it cannot contain a cycle.\n", + "\n", + "Acyclic: We have shown that the graph has no cycles, and it is connected. Therefore, it is an acyclic connected graph, which is the definition of a tree.\n", + "\n", + "By the principle of mathematical induction, we have shown that for any positive integer 'n,' if a connected, undirected graph with 'n' vertices has 'n-1' edges, it is a tree. The base case demonstrated that it holds for 'n = 1,' and the inductive step showed that if it holds for 'k,' it also holds for 'k+1.' Therefore, the solution is proven to be correct.\n", + "\n", + "**Reflection Quality:** Through this problem, we've learned and established that in a connected, undirected graph:\n", + "\n", + "A graph with 'n' vertices and 'n-1' edges is a tree.\n", + "\n", + "Trees are acyclic, connected graphs.\n", + "\n", + "Proof by mathematical induction is a powerful technique to demonstrate correctness in such cases, using a base case and an inductive step.\n", + "\n", + "This understanding is fundamental in graph theory and graph algorithms.\n", + "ChatGPT assisted in this task by providing concise, accurate, and logically structured explanations, including a formal proof of correctness. It facilitated the communication of complex mathematical concepts in a clear and understandable manner, making it accessible to users seeking to understand the topic." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question 9** Suppose we have two competing smartphone companies, Company X and Company Y. Each company has a lineup of smartphone models, and each model has its unique set of features and specifications. Let's assume the smartphone models are denoted as \"M\" and their respective features as \"F.\" Note that each model can have different features, except for the essential feature - the operating system. Both companies aim to dominate the market and outperform each other, and they believe that the key to success lies in offering the best combination of features.\n", + "\n", + "One way to gauge how well the two companies will perform in the market relative to each other is by comparing their strategies. Each feature of a smartphone model contributes to its overall rating, which is based on consumer preferences and reviews. The company wins in a given market if its smartphone model has a higher rating due to its features.\n", + "\n", + "For example, if Company X's smartphone model, M, is equipped with feature F1, which has a rating of 9, Company Y can only outperform if it has a smartphone model with a feature that has a rating higher than 9. The ultimate goal for both companies is to win over as many consumers as possible to achieve market dominance.\n", + "\n", + "Suppose in the launch week of a new product cycle, Company X reveals a strategy S, indicating the features they'll include in their upcoming smartphone models, and Company Y reveals a strategy T, detailing their feature set. Based on these strategies, each company wins a certain share of the market, following the rules mentioned above. We'll say that the pair of strategies (S, T) is stable if neither company can unilaterally change its strategy and gain a larger market share. In other words, there is no strategy S' for Company X that allows them to win more of the market with the pair (S', T), and similarly, there is no strategy T' for Company Y that lets them gain more market share with the pair (S, T') than with the original strategies (S, T).\n", + "\n", + "The question is whether, for any set of smartphone features and their associated ratings, there exists a stable pair of strategies for the competing smartphone companies. Can you provide an algorithm that can determine such stable strategies, or can you give an example of a set of features and their associated ratings for which there is no stable pair of strategies?\n", + "\n", + "**Solution 9** To find a stable pair of strategies for the competing smartphone companies, we can adapt the concept of the Stable Marriage Problem to this scenario. The Stable Marriage Problem deals with finding a stable matching between two sets of elements, and in this case, we can think of the companies and the features as two sets.\n", + "\n", + "Here's an algorithm to determine a stable pair of strategies for the smartphone companies:\n", + "\n", + "Create Preference Lists:\n", + "Each company (Company X and Company Y) creates a preference list that ranks the features (F1, F2, F3, etc.) based on their ratings for the models they plan to produce.\n", + "Initialize Assignments:\n", + "Start with an initial assignment of features to the models for both companies. This assignment can be random or based on an initial guess.\n", + "While There Are Unstable Pairs:\n", + "Check for unstable pairs (pairs where either company prefers a different feature for the same model).\n", + "Find Unstable Pairs:\n", + "For each model, compare the feature assigned to it by Company X with the one assigned by Company Y. If the model prefers the feature from one company over the other, it's an unstable pair.\n", + "Resolve Unstable Pairs:\n", + "For each unstable pair, have the company whose feature was rejected propose an alternative feature to the model. The model can only accept if the new feature has a higher rating.\n", + "Repeat Step 3:\n", + "Continue the process of checking for unstable pairs and resolving them until there are no more unstable pairs.\n", + "Result:\n", + "Once there are no more unstable pairs, the resulting assignment of features to models for both companies represents a stable pair of strategies.\n", + "\n", + "**Proof Of Correctness:** The correctness of the algorithm can be proven through two key points:\n", + "\n", + "1. Strategy Stability:\n", + "The algorithm guarantees that neither Company X nor Company Y can independently alter their strategies to gain a larger market share. This is because any change they propose can only be accepted if the new feature being introduced has a higher rating than the one it replaces, ensuring that no unilateral alteration can improve their position.\n", + "\n", + "2. Elimination of Unstable Pairs:\n", + "The algorithm actively identifies and resolves unstable pairs, iterating until no such pairs remain. The termination condition ensures that the final assignment is stable, as any possibility of instability has been systematically addressed.\n", + "\n", + "In summary, the algorithm is proven to be correct as it consistently delivers a stable pair of strategies that align with the problem's requirements.\n", + "\n", + "**Reflection Quality:** Through this problem, we've learned how to adapt the Stable Marriage Problem concept to find stable pairs of strategies in competitive scenarios. We've demonstrated that such an algorithm can ensure companies cannot independently change their strategies for better results, and it systematically resolves unstable pairs until a stable solution is achieved. This approach provides a structured way to determine stable pairs of strategies in competitive decision-making contexts.\n", + "ChatGPT was helpful in creating a step-by-step approach for identifying stable strategies in competitive situations. It explained the proof of correctness and distilled the main takeaways from the problem, simplifying complex ideas for better understanding." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002776313_Rushikesh_Karwankar/Capture.JPG b/Submissions/002776313_Rushikesh_Karwankar/Capture.JPG new file mode 100644 index 0000000..0adf001 Binary files /dev/null and b/Submissions/002776313_Rushikesh_Karwankar/Capture.JPG differ diff --git a/Submissions/002776313_Rushikesh_Karwankar/readme.md b/Submissions/002776313_Rushikesh_Karwankar/readme.md new file mode 100644 index 0000000..26cd846 --- /dev/null +++ b/Submissions/002776313_Rushikesh_Karwankar/readme.md @@ -0,0 +1,5 @@ +- First Name: Rushikesh +- Last Name: Karwankar +- NUID: 002776313 + +- Questions, Solutions, Correctness Proofs and Reflections are present in Assignment_1.ipynb file. diff --git a/Submissions/002786959_Yuktaba_Gohil/002786959_Yuktaba_Gohil.md b/Submissions/002786959_Yuktaba_Gohil/002786959_Yuktaba_Gohil.md new file mode 100644 index 0000000..ec658cc --- /dev/null +++ b/Submissions/002786959_Yuktaba_Gohil/002786959_Yuktaba_Gohil.md @@ -0,0 +1,59 @@ +In the process of completing this assignment, I learnt several key concepts related to +algorithm analysis and computational complexity which I would like to mention here. Through various tasks and questions, I gained a deeper understanding of the following topics: + +**Order of Growth:** + +The "Order of Growth" of a function refers to how the resource requirements (such as time +or space) of a function increase as the size of the input to that function increases. + +Commonly used notations for describing the order of growth include: + +1. Big O Notation (O): This notation provides an upper bound on the growth rate of a +function. It describes the worst-case scenario for an algorithm's resource usage. + +2. Theta Notation (Θ): This notation provides a tight bound on the growth rate of a +function. It describes precise estimate of an algorithm's behavior. + +3. Omega Notation (Ω): This notation provides a lower bound on the growth rate of a +function. It describes the best-case scenario for an algorithm's resource usage. + +Here is the order of growth in increasing order: + +| Order of Growth | Description | +|-----------------|--------------------| +| 1 | Constant | +| log(n) | Logarithmic | +| √(n) | Square Root | +| N | Linear | +| N log(n) | Linear Logarithmic | +| N^2 | Square | +| N^3 | Cube | +| N^k | Polynomial | +| 2^n | Exponential | +| N! | Factorial | + +**Dynamic Programming:** + +Dynamic programming is a powerful technique used to solve problems by breaking them down +into smaller overlapping subproblems and storing the solutions to these subproblems in a +table (usually an array or matrix) to avoid redundant calculations. It's particularly +useful for optimization problems where you want to find the best solution among a set of +possibilities. + +**Gale-Shapley Algorithm:** + +The Gale-Shapley algorithm, also known as the Stable Marriage Problem algorithm, is a +mechanism for finding a stable matching between two sets of agents, such as men and women, +students and schools, or any other two groups with preferences over each other. + +The main goal of the algorithm is to find a stable matching, where no two agents from different groups would both prefer each other over their current partners. + +The result of the Gale-Shapley algorithm is a stable matching in which every agent is paired with a partner, and there are no blocking pairs. A blocking pair is a situation where two agents (one from each group) would both prefer each other over their current partners, which would make them leave their current partners to form a new couple. + +The properties of Gale-Shapley Algorithm is given below: + +1. The Gale-Shapley algorithm always produces a stable matching, meaning there are no blocking pairs. +2. The solution may not be unique, as different orderings of proposals can lead to different stable matchings. +3. In practice, the proposing group has an advantage in terms of getting their most preferred partners. + +The Gale-Shapley algorithm is used in various real-world scenarios, including college admissions, job markets, and online dating platforms, where individuals have preferences over potential partners or schools. diff --git a/Submissions/002786959_Yuktaba_Gohil/002786959_Yuktaba_Gohil_Assignment1.ipynb b/Submissions/002786959_Yuktaba_Gohil/002786959_Yuktaba_Gohil_Assignment1.ipynb new file mode 100644 index 0000000..58188d0 --- /dev/null +++ b/Submissions/002786959_Yuktaba_Gohil/002786959_Yuktaba_Gohil_Assignment1.ipynb @@ -0,0 +1,674 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Assignment 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q1 (10 Points)
\n", + "Arrange the following functions in increasing order of growth:
\n", + "• 2n2
\n", + "• n3log2(n)
\n", + "• n4
\n", + "• nlog(n)
\n", + "• 3n
\n", + "• n!
\n", + "• nlog(n)
\n", + "• n5
\n", + "• 5n
\n", + "• log(n3)
**\n", + "\n", + "Solution:\n", + "\n", + "• log(n3)
\n", + "• nlog(n)
\n", + "• n3log2(n)
\n", + "• n4
\n", + "• n5
\n", + "• nlog(n)
\n", + "• 2n2
\n", + "• 3n
\n", + "• 5n
\n", + "• n!
\n", + "\n", + "log(n3) - This is the slowest-growing function because it represents a logarithmic growth rate. Θ(log(n)).
\n", + "nlog(n) - This grows faster than logarithmic but slower than polynomial functions. It's often referred to as \"quasi-linear\" growth. Θ(n log(n)).
\n", + "n3log2(n) - This is a polynomial function with a cubic (n^3) growth rate, and the logarithmic factor (log^2(n)) doesn't change its overall growth rate significantly. Θ(n^3).
\n", + "n4 - This is a polynomial function with a quartic (n^4) growth rate. It grows faster than the previous functions but slower than exponential ones. Θ(n^4).
\n", + "n5 - This is a polynomial function with a quintic (n^5) growth rate. It's faster-growing than n^4 but still polynomial. Θ(n^5).
\n", + "nlog(n) - This represents exponential growth but with a variable exponent. It's slower-growing than exponential functions like 2^n and 3^n but faster-growing than polynomial functions like n^2 and n^3.
\n", + "2n2 - This is an exponential function with a base of 2 and an exponent of n^2. It grows much faster than polynomial and logarithmic functions. Θ(2^n).
\n", + "3n - This is an exponential function with a base of 3. It grows significantly faster than all the previous functions mentioned. Θ(3^n).
\n", + "5n - This is another exponential function with a base of 5. It grows even faster than 3^n and the rest. Θ(5^n).
\n", + "n! - This is the fastest-growing function among those listed. It represents factorial growth and grows faster than any polynomial or exponential function. Θ(n!).\n", + "\n", + "Reflection Quality:\n", + "\n", + "I had the problem recogizing polynomial functions and exponential growth with variable exponent function (nlog(n)). I misuderstood the exponential growth function as the polynomial function.
\n", + "I researched and came to know that exponential growth functions growth rate falls between polynomial and exponential functions.
\n", + "To clarify further:
\n", + "Θ(n^(log(n))) is slower-growing than exponential functions like 2^n and 3^n.
\n", + "Θ(n^(log(n))) is faster-growing than polynomial functions like n^2 and n^3.
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q2 (10 Points)
\n", + "Assume that you have function f and g such that f(n) is O(g(n)). For each of the following statements decide whether it is true or false and give a proof or counter example.
\n", + "•\tf(n)=O(f(n+1))
\n", + "•\tf(n)=O(f(2n))
\n", + "•\tf(n)=O(g(n+1))
**\n", + "
\n", + "Solution:

\n", + "Statement 1: f(n)=O(f(n+1))
\n", + "False
\n", + "This statement is saying that the function f(n) grows at the same rate or slower than the function f(n+1). This is not always true. For example, the function 2^n grows faster than the function 2^(n+1), so 2^n is not O(2^(n+1)).

\n", + "Statement 2: f(n)=O(f(2n))
\n", + "True
\n", + "This statement is saying that the function f(n) grows at the same rate or slower than the function f(2n). This is always true. This is because f(2n) is just a scaled version of f(n). For example, if f(n) = n, then f(2n) = 2n. So, f(n) is O(f(2n)).
\n", + "To prove this statement true, we need to show that for any function f(n) that is big-O of g(n), it is also big-O of g(2n). Let's assume that f(n) is O(g(n)).
\n", + "According to the definition of big-O notation, there exist constants C and n0 such that for all n ≥ n0, f(n) ≤ C * g(n).
\n", + "Now, consider f(2n). We want to show that f(2n) is also bounded by a constant multiple of g(2n). Using the definition of big-O, we need to find new constants C' and n0' such that for all n ≥ n0', f(2n) ≤ C' * g(2n).
\n", + "Let's simplify this:
\n", + "f(2n) ≤ C' * g(2n)
\n", + "Now, we can manipulate the inequality:
\n", + "f(n) ≤ C' * (g(2n) / 2)
\n", + "Since (g(2n) / 2) is still a function of n, we can rewrite this as:
\n", + "f(n) ≤ C'' * g(n)
\n", + "where C'' = (C' / 2). Now, we have shown that f(n) is O(g(n)), and the statement is true.

\n", + "Statement 3: f(n)=O(g(n+1))
\n", + "False
\n", + "Counterexample:
\n", + "Suppose f(n) = n and g(n) = n. It's clear that f(n) is O(g(n)) since they are the same function.
\n", + "Now, let's check if f(n) is O(g(n+1)). To do this, we need to show that there exist constants C and n0 such that for all n ≥ n0, f(n) ≤ C * g(n+1).
\n", + "However, in this case, it's not possible to find such constants. Let's assume by contradiction that we can find C and n0. Then we have:
\n", + "n ≤ C * (n+1)
\n", + "Now, divide both sides by (n+1):
\n", + "n / (n+1) ≤ C
\n", + "As n approaches infinity, the left-hand side approaches 1, while C remains a constant. This is a contradiction because there's no constant C that can bound 1 as n becomes arbitrarily large.
\n", + "Therefore, there are no constants C and n0 that satisfy the condition for f(n) being O(g(n+1)), and the statement is false.

\n", + "Reflection Quality
\n", + "I used ChatGPT here to understand the concept of flexibility and adaptability of big-O notation. I learnt how different functions compare in terms of their growth rates." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q3 (10 Points)
\n", + "Imagine you have a group of roommates living together in a shared house. Each roommate has a preference list ranking all the other roommates in order of compatibility as potential roommates.

\n", + "Your goal is to find a stable roommate assignment, meaning that there are no pairs of roommates who would both prefer to live with each other over their current assignments.

\n", + "Write an algorithm to find a stable roommate assignment based on their preference lists. You can assume that
\n", + "a. The number of roommates is even
\n", + "b. Each roommate must be assigned to exactly one other roommate.

\n", + "The assignment of roommates to specific rooms is considered stable if neither of the following situations arises:
\n", + "There are roommates R1,R2 and a room A such that:
\n", + "R1 is assigned to room A,
\n", + "R2 is unassigned and not assigned to any room, and
\n", + "R1 prefers R2 based on their compatibility rankings.

\n", + "There are roommates R1,R2,R3 and rooms A and B, such that:
\n", + "R1 and R3 are assigned to room A,
\n", + "R2 is assigned to room B,
\n", + "R1 prefers R2 over R3, and
\n", + "R2 prefers room A over room B.

\n", + "This is similar to the stable matching problem.Please explain your algorithm step by step and provide a proof of its correctness.

**\n", + "Solution:

\n", + "The problem can be solved using the \"Stable Matching\" algorithm, which ensures that no roommates would prefer each other over their current assignments.

\n", + "The algorithm looks like this:

\n", + "Initialize a list of unassigned roommates.
\n", + "While there are still unassigned roommates:
\n", + "      Find the roommate with the highest priority on the list of unassigned roommates.
\n", + "      Find the roommate with the highest priority on the preference list of the first roommate.
\n", + "      If the second roommate is unassigned, assign them to each other.
\n", + "      Otherwise, if the second roommate prefers the first roommate to their current roommate, assign them       to each other and update the number of available positions in the first roommate's current room.
\n", + "      Otherwise, the first roommate remains in their current room.
\n", + "      All roommates are now assigned

\n", + "Here's a step-by-step explanation of the algorithm:
\n", + "\n", + "Step 1: Initialization
\n", + "\n", + "Begin by having each roommate rank all other roommates according to their preferences.
\n", + "Create an array to keep track of each roommate's current assignment. Initially, no one is assigned, so all entries can be set to unassigned.

\n", + "Step 2: While There Are Unassigned Roommates
\n", + "\n", + "Select an unassigned roommate, let's call this roommate \"R1.\"
\n", + "R1 proposes to their most preferred roommate (the one they rank the highest and haven't proposed to yet). Let's call this proposed roommate \"R2.\"
\n", + "If R2 is unassigned, or if R2 prefers R1 over their current roommate (if any), they accept the proposal, and both R1 and R2 become assigned to each other.
\n", + "If R2 is already assigned to someone and prefers their current roommate over R1, they reject the proposal, and R1 remains unassigned.
\n", + "Repeat these steps until there are no unassigned roommates left.

\n", + "Step 3: Result
\n", + "\n", + "Once every roommate is assigned, you'll have a stable roommate assignment.

\n", + "Example:
\n", + "\n", + "Consider the following preference lists for four roommates:
\n", + "\n", + "Alice: Bob, Carol, Dave
\n", + "Bob: Alice, Carol, Dave
\n", + "Carol: Dave, Alice, Bob
\n", + "Dave: Alice, Carol, Bob

\n", + "The algorithm would proceed as follows:
\n", + "\n", + "The list of unassigned roommates is initially [Alice, Bob, Carol, Dave].
\n", + "The highest-ranked roommate on Alice's preference list who is also unassigned is Bob.
Therefore, the algorithm assigns Alice to Bob.
\n", + "The list of unassigned roommates is now [Carol, Dave].
\n", + "The highest-ranked roommate on Carol's preference list who is also unassigned is Dave.
Therefore, the algorithm assigns Carol to Dave.
\n", + "The algorithm terminates because there are no more unassigned roommates.

\n", + "The Gale-Shapley theorem proves the correctness of this algorithm, which states that the algorithm always produces a stable matching. It guarantees that there are no pairs of roommates who would both prefer to live with each other over their current assignments.
\n", + "\n", + "The algorithm terminates because each unassigned roommate eventually becomes assigned, and it never enters an infinite loop.

\n", + "This algorithm has a time complexity of O(n^2), where n is the number of roommates.

\n", + "Reflection Quality:

\n", + "The model of roommate assignments is designed to avoid conflicts and preferences, so it requires careful consideration of each roommate's preferences.
\n", + "For me, Understanding the problem statement and its similarities to the Gale-Shapley algorithm was the starting point for solving this problem.
\n", + "ChatGPT assisted me in creating problem statements that were clear and concise and urged me to include all the necessary details.
\n", + "Also, I used chatGPT to understand the core concepts like Gale-Shapley algorithm to solve this problem.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q4 (10 Points)
\n", + "You have two sorting algorithms: Algorithm A and Algorithm B. Algorithm A has a time complexity of n2 milliseconds, while Algorithm B has a time complexity of 2n milliseconds.Which one is asymptotically faster? What is the cross-over value of n?
**\n", + "\n", + "Solution:
\n", + "\n", + "Algorithm A with a time complexity of n2 milliseconds is asymptotically faster than Algorithm B with a time complexity of 2n milliseconds.
\n", + "\n", + "The crossover value of n is the point at which Algorithm B's running time becomes greater than Algorithm A's running time. To find this crossover point, set the two time complexities equal to each other and solve for n:\n", + "\n", + "n^2 = 2^n\n", + "\n", + "Taking the logarithm of both sides can help simplify the equation:\n", + "\n", + "log(n^2) = log(2^n)\n", + "\n", + "2 * log(n) = n * log(2)\n", + "\n", + "n = 2\n", + "\n", + "When comparing the time complexities of two algorithms, we look at their growth rates as the input size (n) increases. In this case,
\n", + "Algorithm A has a time complexity of n2, which means its running time grows quadratically with the input size.
\n", + "Algorithm B, on the other hand, has a time complexity of 2n, indicating exponential growth with the input size.\n", + "\n", + "Asymptotically, exponential growth (2^n) dominates quadratic growth (n^2). This means that as the input size (n) increases, Algorithm B's running time will quickly become much larger than Algorithm A's running time. Algorithm A is more efficient for larger values of n.\n", + "\n", + "Reflection Quality:\n", + "\n", + "In the initial response, I provided an incorrect answer by stating that Algorithm B was asymptotically faster than Algorithm A.
\n", + "However, upon realizing the mistake, I corrected it in a subsequent response and correctly identified that Algorithm A is, in fact, asymptotically faster than Algorithm B.
\n", + "ChatGPT provided additional explanations and guidance that helped in arriving at the correct Solution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q5 (10 Points)\n", + "Given a set of items, each with a weight and a value, and a maximum weight capacity W, find the subset of items with the maximum total value such that the total weight of the subset does not exceed W.**\n", + "\n", + "Solution:\n", + "\n", + "Lets understand this problem with an example. Imagine having a backpack and we want to fill the backpack with some toys. Now each toy has different weight and different value. Our goal is to pick the toys that will have the most value without making our backpack too heavy to carry.
\n", + "Here's how we can solve this problem step by step:\n", + "\n", + "Make a List: First, we make a list of all the toys we have, and for each toy, we write down how heavy it is and whats the value of toy.\n", + "\n", + "Decide the Backpack Size: Next, we decide how big your backpack is, meaning it can only carry toys up to a certain total weight (let's call it W).\n", + "\n", + "Pick the Best Toys: Now, we want to figure out which toys to put in your backpack. We start with an empty backpack and look at your list of toys. We pick one toy at a time and decide whether to put it in our backpack or not.\n", + "\n", + "We look at the first toy on your list. If it's too heavy to fit in our backpack, we skip it and move to the next toy.
\n", + "If the toy can fit in your backpack, we compare it to the toys already in our backpack. If it's has a higher value than what's already inside, we put it in your backpack. If not, we skip it.\n", + "\n", + "Repeat Until Full: Keep doing this for each toy on the list, one by one, until backpack is full. Make sure not to put too many toys so that backpack doesn't get too heavy.\n", + "\n", + "You're Done: Once our backpack is full, we've picked the best combination of toys that give the most value without being too heavy to carry. \n", + "\n", + "Here is the code example for above algorithm:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum value of toys in the backpack: 26\n", + "Selected toys: [(5, 13), (3, 8), (2, 5)]\n" + ] + } + ], + "source": [ + "def knapsack(items, max_weight):\n", + " # Create a table to store the best values for different weights\n", + " dp = [[0 for _ in range(max_weight + 1)] for _ in range(len(items) + 1)]\n", + " \n", + " # Create a table to store the information about which items are included\n", + " included = [[False for _ in range(max_weight + 1)] for _ in range(len(items) + 1)]\n", + "\n", + " # Fill in the table using a loop\n", + " for i in range(1, len(items) + 1):\n", + " for w in range(max_weight + 1):\n", + " weight, value = items[i - 1]\n", + "\n", + " # If the current item's weight is more than the current weight limit,\n", + " # we can't include it in the knapsack\n", + " if weight > w:\n", + " dp[i][w] = dp[i - 1][w]\n", + " else:\n", + " # We have two choices: include the current item or skip it\n", + " # We choose the option that gives us the maximum value\n", + " if dp[i - 1][w] >= dp[i - 1][w - weight] + value:\n", + " dp[i][w] = dp[i - 1][w]\n", + " else:\n", + " dp[i][w] = dp[i - 1][w - weight] + value\n", + " included[i][w] = True\n", + "\n", + " # Find the items that are included in the optimal Solution\n", + " selected_items = []\n", + " i, w = len(items), max_weight\n", + " while i > 0 and w > 0:\n", + " if included[i][w]:\n", + " selected_items.append(items[i - 1])\n", + " w -= items[i - 1][0]\n", + " i -= 1\n", + "\n", + " # Return the maximum value and the selected items\n", + " return dp[len(items)][max_weight], selected_items\n", + "\n", + "# Example usage:\n", + "toys = [(2, 5), (3, 8), (5, 13), (10, 22)]\n", + "max_weight = 10\n", + "max_value, selected_toys = knapsack(toys, max_weight)\n", + "print(\"Maximum value of toys in the backpack:\", max_value)\n", + "print(\"Selected toys:\", selected_toys)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Problem Similarity With the Sample Problem:\n", + "\n", + "The two problems, the knapsack problem (mentioned in this assignment) and the wall-building problem (mentioned in sample assignment), are related in terms of dynamic programming and optimization.\n", + "\n", + "Dynamic Programming: Both problems can be solved efficiently using dynamic programming techniques.\n", + "\n", + "Optimization: Both problems involve optimization. In the knapsack problem, we aim to maximize the total value of items within a weight limit. In the wall-building problem, we aim to construct a wall with the fewest bricks while satisfying certain constraints.\n", + "\n", + "Resource Allocation: In both problems, we're dealing with the allocation of limited resources (weight capacity in the knapsack problem and the number of bricks in the wall-building problem) to maximize a specific objective (total value in the knapsack problem and constructing a wall in the wall-building problem).\n", + "\n", + "Reflection Quality:\n", + "\n", + "While Solving this problem, I was curious to learn about dynamic programming as Professor has mentioned it quite a few time in the class. So I used chatGPT to help me clear the concept of dynamic programming.
\n", + "Also, I used chatGPT help me form the question similar to the sample problem and since the question seems little bit differennt from the sample problem at a glance, I used chatgpt to provide more clarification on how the two problems rely on the same concept." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q6 (5 Points)
\n", + "You are comparing two sorting algorithms, Algorithm X and Algorithm Y, for a given set of input data. The time complexity of Algorithm X is O(n log n), while the time complexity of Algorithm Y is O(n²).Which algorithm grows asymptotically faster as the size of the input data \"n\" increases?**\n", + "\n", + "Solution:\n", + "\n", + "Algorithm X grows asymptotically faster as the size of the input data \"n\" increases.\n", + "\n", + "The big O notation is used to describe the asymptotic growth rate of an algorithm as the input size increases.
\n", + "The time complexity of Algorithm X is O(n log n), which means that its running time grows logarithmically with the input size.
\n", + "The time complexity of Algorithm Y is O(n²), which means that its running time grows quadratically with the input size.\n", + "\n", + "Asymptotically, logarithmic growth (n log n) dominates quadratic growth (n²). This means that as the input size (n) increases, Algorithm X's running time will quickly become much smaller than Algorithm Y's running time.\n", + "\n", + "For example, if the input size is 1000, then Algorithm X will take about 10 milliseconds to run, while Algorithm Y will take about 1 million milliseconds to run. This is a significant difference, and it becomes even more pronounced as the input size increases.\n", + "\n", + "Therefore, Algorithm X is asymptotically faster than Algorithm Y.\n", + "\n", + "Reflection Quality:\n", + "\n", + "I used chatGPT here just to create the Problem Statement ad verify my answer. My answer was correct so I moved on with another Question.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q7 (10 Points)
\n", + "In a stable matching problem involving students and companies, consider a scenario where there exist two students, Alice and Bob, and two companies, XYZ Inc. and ABC Corp. In the preference list of Alice, XYZ Inc. is her first choice, and in the preference list of Bob, ABC Corp. is his first choice. However, XYZ Inc. prefers Bob over Alice, and ABC Corp. prefers Alice over Bob.
\n", + "State whether the following statement is True or False:
\n", + "\"For every stable matching S for this instance, both Alice and Bob will be matched with their respective first choices.\"
\n", + "Provide a short explanation if it's true and a counterexample if it's false.**\n", + "\n", + "Solution:\n", + "\n", + "The statement is False.
\n", + "\n", + "Counterexample:
\n", + "Consider the following stable matching:
\n", + "Alice is matched with ABC Corp.
\n", + "Bob is matched with XYZ Inc.
\n", + "This is a stable matching because there are no pairs of students and companies who would both prefer to be matched with each other over their current assignments.
\n", + "However, in this matching, Alice is not matched with her first choice, XYZ Inc., and Bob is not matched with his first choice, ABC Corp.
\n", + "Therefore, the statement is false.\n", + "\n", + "Explanation:
\n", + "The Gale-Shapley algorithm, which is a common algorithm for finding stable matchings, works by having students propose to companies in order of preference. Companies then reject the least preferred proposals and accept the most preferred proposals, until all students are matched.
\n", + "In the counterexample above, Alice proposes to XYZ Inc. first. However, XYZ Inc. prefers Bob over Alice, so they reject her proposal. Alice then proposes to ABC Corp., who accept her proposal.
\n", + "Bob also proposes to XYZ Inc. first, and they accept his proposal. This is because Bob is their first choice.
\n", + "Therefore, in the resulting matching, Alice is matched with ABC Corp., and Bob is matched with XYZ Inc. Neither student is matched with their first choice.\n", + "\n", + "Reflection Quality:\n", + "\n", + "ChatGPT helped me to form the problem Statement and clear my concepts on Gale-Shapley algorithm.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q8 (10 Points)
\n", + "Two chess players, Alice and Bob, are preparing for a chess tournament. Each player has a set of chess pieces, and each chess piece has its own strength on the chessboard. Alice wants to devise a strategy (Assignment A), and Bob wants to devise his strategy (Assignment B) to maximize their chances of winning the tournament.
**\n", + "**Each chess piece has a fixed strength value based on its performance in previous tournaments, and no two pieces share the same strength value. Both players aim to win as many games as possible during the tournament to secure the championship.
\n", + "The rules of the tournament are as follows: In each game, Alice and Bob will choose one of their chess pieces to play against each other. The player with the stronger chess piece wins the game. If both pieces have the same strength, the game ends in a draw.
**\n", + "**Suppose, in the opening round of the chess tournament, Alice reveals her strategy (Assignment A), and Bob reveals his strategy (Assignment B). Based on this pair of strategies, each player wins certain games, following the rule mentioned above. We'll say that the pair of strategies (Assignment A, Assignment B) is stable if neither Alice nor Bob can unilaterally change their strategy to win more games. In other words, there is no alternative strategy Assignment A' for Alice, and no alternative strategy Assignment B' for Bob, such that they can win more games with the pair (Assignment A', Assignment B) or (Assignment A, Assignment B') than they did with the original pair (Assignment A, Assignment B).
\n", + "Your task is to determine whether, for any set of chess pieces and their strength values, there exists a stable pair of strategies for Alice and Bob.
\n", + "Resolve this question by doing one of the following two things:
**\n", + "**1.\tGive an algorithm that, for any set of chess pieces and their strength values, produces a stable pair of strategies (Assignment A, Assignment B).
\n", + "OR
\n", + "2.\tGive an example of a set of chess pieces and associated strength values for which there is no stable pair of strategies (Assignment A, Assignment B).**\n", + "\n", + "Solution:\n", + "\n", + "For certain sets of chess piece strengths and strategies, a stable pair may exist, while in other cases, it may not. The stability of the pair depends on the interplay between chess piece strengths and player strategies.\n", + "\n", + "Scenario 1: Stable Pair Exists (Algorithm)\n", + "\n", + "To find a stable pair of strategies for Alice and Bob for any set of chess pieces and their strength values, we can employ a modified version of the Gale-Shapley algorithm, often used for stable matching problems.\n", + "\n", + "Assign each chess piece to both Alice and Bob based on their respective strength values. This creates initial preference lists for both players.\n", + "\n", + "Iteratively execute the following steps:\n", + "a. Alice proposes to the chess piece in her preference list with the highest strength.
\n", + "b. That chess piece either accepts Alice's proposal or rejects it in favor of Bob if Bob's current assignment has higher strength.
\n", + "c. Bob updates his preference list, moving the rejected chess piece down his list.
\n", + "d. Repeat steps a-c until each chess piece is assigned to either Alice or Bob.\n", + "\n", + "Once all chess pieces are assigned, the resulting pair of strategies (Assignment A, Assignment B) is stable if neither Alice nor Bob can unilaterally change their strategy to win more games. This stability is achieved because the assignments are made based on the chess pieces' strengths.\n", + "\n", + "Scenario 2: Stable Pair Does Not Exist (Example)\n", + "\n", + "To demonstrate that a stable pair of strategies may not always exist, consider the following example:\n", + "\n", + "Alice has three chess pieces with strengths [3, 4, 5].
\n", + "Bob has three chess pieces with strengths [5, 4, 3].
\n", + "If Alice uses Assignment A to choose her pieces in ascending order of strength ([3, 4, 5]), and Bob uses Assignment B to choose his pieces in descending order of strength ([5, 4, 3]), they have a stable pair of strategies.\n", + "\n", + "However, if Alice and Bob both choose their pieces in ascending order of strength ([3, 4, 5] for Alice, and [3, 4, 5] for Bob), a stable pair of strategies no longer exists. In this case, Bob can unilaterally change his strategy to choose his pieces in descending order ([5, 4, 3]), winning more games than with the original pair of strategies." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q9 (25 Points) :: Coding Problem
\n", + "The annual National Science Fair is approaching, and there are students from various schools who wish to participate. Each student has a list of their preferred schools they want to attend for the fair, and each school has a list of preferred students. The fair organizers want to create a stable matching of students to schools using the Gale-Shapley algorithm.**\n", + "\n", + "**A. Implement the Gale-Shapley algorithm in Python to match students to schools. You can create preference lists for each student and school.**\n", + "\n", + "Solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Student1': 'School1', 'Student2': 'School2', 'Student3': 'School3'}\n" + ] + } + ], + "source": [ + "# Implement Gale-Shapley algorithm\n", + "def gale_shapley(student_prefs, school_prefs):\n", + " # Initialize variables\n", + " student_matches = {}\n", + " school_assignments = {}\n", + "\n", + " while len(student_prefs) > 0:\n", + " student = next(iter(student_prefs))\n", + " school_choices = student_prefs[student]\n", + "\n", + " for school in school_choices:\n", + " if school not in school_assignments:\n", + " school_assignments[school] = student\n", + " student_matches[student] = school\n", + " del student_prefs[student]\n", + " break\n", + " else:\n", + " current_match = school_assignments[school]\n", + " if school_prefs[school].index(student) < school_prefs[school].index(current_match):\n", + " student_matches[current_match] = None\n", + " del student_prefs[current_match]\n", + " school_assignments[school] = student\n", + " student_matches[student] = school\n", + " del student_prefs[student]\n", + " break\n", + "\n", + " return student_matches\n", + "\n", + "# Sample preference lists\n", + "student_preferences = {\n", + " 'Student1': ['School1', 'School2', 'School3'],\n", + " 'Student2': ['School2', 'School1', 'School3'],\n", + " 'Student3': ['School1', 'School3', 'School2']\n", + "}\n", + "\n", + "school_preferences = {\n", + " 'School1': ['Student1', 'Student3', 'Student2'],\n", + " 'School2': ['Student2', 'Student1', 'Student3'],\n", + " 'School3': ['Student3', 'Student2', 'Student1']\n", + "}\n", + "\n", + "matches = gale_shapley(student_preferences, school_preferences)\n", + "print(matches)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**B. To ensure fairness, shuffle the preference lists of both students and schools 1000 times and calculate the percentage of stable matches.**\n", + "\n", + "Solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Percentage of stable matches: 100.0%\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "# Define student_preferences and school_preferences with varied preferences\n", + "student_preferences = {\n", + " 'Student1': ['School1', 'School2', 'School3'],\n", + " 'Student2': ['School2', 'School1', 'School3'],\n", + " 'Student3': ['School1', 'School3', 'School2']\n", + "}\n", + "\n", + "school_preferences = {\n", + " 'School1': ['Student2', 'Student1', 'Student3'],\n", + " 'School2': ['Student1', 'Student2', 'Student3'],\n", + " 'School3': ['Student3', 'Student2', 'Student1']\n", + "}\n", + "\n", + "# Implement Gale-Shapley algorithm\n", + "def gale_shapley(student_prefs, school_prefs):\n", + " # Initialize variables\n", + " student_matches = {}\n", + " school_assignments = {}\n", + "\n", + " # Create copies of the keys\n", + " student_keys = list(student_prefs.keys())\n", + " \n", + " while len(student_keys) > 0:\n", + " student = student_keys.pop(0) # Remove the first student from the list\n", + " school_choices = student_prefs[student]\n", + "\n", + " for school in school_choices:\n", + " if school not in school_assignments:\n", + " school_assignments[school] = student\n", + " student_matches[student] = school\n", + " break\n", + " else:\n", + " current_match = school_assignments[school]\n", + " if school_prefs[school].index(student) < school_prefs[school].index(current_match):\n", + " student_matches[current_match] = None\n", + " student_keys.append(current_match) # Add the previous match back to the list\n", + " school_assignments[school] = student\n", + " student_matches[student] = school\n", + " break\n", + "\n", + " return student_matches\n", + "\n", + "# Shuffle the preferences\n", + "def shuffle_preferences(preferences, num_times=1000):\n", + " for i in range(num_times):\n", + " for key in preferences:\n", + " random.shuffle(preferences[key])\n", + "\n", + "shuffle_preferences(student_preferences)\n", + "shuffle_preferences(school_preferences)\n", + "\n", + "# Calculate percentage of stable matches (you can use the stable_matching function)\n", + "stable_matches = gale_shapley(student_preferences, school_preferences)\n", + "percentage_stable = len(stable_matches) / len(student_preferences) * 100\n", + "print(f\"Percentage of stable matches: {percentage_stable}%\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**C. In an effort to make the fair more competitive, the organizers have decided to eliminate a certain number of students and schools after each round. Can the Gale-Shapley matching algorithm be applied iteratively to create stable matches after each elimination round (e.g., 64 participants, 32 participants, 16 participants, 8 participants, 4 participants, 2 participants)?**\n", + "\n", + "Solution:\n", + "\n", + "Yes, the Gale-Shapley algorithm can be applied iteratively after each elimination round to create stable matches. After eliminating participants, you can run the algorithm with the remaining students and schools to create stable matches for the next round." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**D. Now, consider the scenario where both students and schools are merged into one large list, and any participant can be matched with any other participant. Can the Gale-Shapley algorithm still create stable matches in this situation?**\n", + "\n", + "Solution:\n", + "\n", + "The Gale-Shapley algorithm is designed for stable matching when one set of participants (e.g., students) proposes to another set (e.g., schools). In a scenario where all participants are in one list, the algorithm is not directly applicable. You would need to modify the algorithm or use a different approach to create stable matches in this situation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**E. Finally, test the efficiency of your algorithm by doubling the number of participants in each list several times. Measure the time it takes to create stable matches and analyze how the execution time grows concerning the size of the lists.**\n", + "\n", + "Solution:\n", + "\n", + "Execution time can be measured using the time module in Python. Here's a sample code snippet to measure the execution time:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Execution time for large preference lists: 0.007990121841430664 seconds\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "# Generate larger preference lists (doubling the size)\n", + "large_student_preferences = {f'Student{i}': [f'School{j}' for j in range(1, 9)] for i in range(1, 65)}\n", + "large_school_preferences = {f'School{j}': [f'Student{i}' for i in range(1, 65)] for j in range(1, 9)}\n", + "\n", + "start_time = time.time()\n", + "# Run Gale-Shapley algorithm with larger preference lists\n", + "matches = gale_shapley(large_student_preferences, large_school_preferences)\n", + "end_time = time.time()\n", + "\n", + "execution_time = end_time - start_time\n", + "print(f\"Execution time for large preference lists: {execution_time} seconds\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This code generates larger preference lists and measures the execution time for matching. The execution time grows as the size of the lists increases.\n", + "\n", + "Reflection Quality:\n", + "\n", + "Chatgpt here helped me to form the problem statement and to experiment with my code by giving different case scenarios." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002795461_Namitha_JC/Readme.md b/Submissions/002795461_Namitha_JC/Readme.md new file mode 100644 index 0000000..633be42 --- /dev/null +++ b/Submissions/002795461_Namitha_JC/Readme.md @@ -0,0 +1,25 @@ + +**Assistance from ChatGPT:** + +ChatGPT provided valuable guidance in structuring algorithmic problems. +It clarified complex algorithmic concepts and generated illustrative code examples. +ChatGPT's assistance was instrumental in simplifying algorithms without compromising core principles. + +**Challenges Faced:** + +Balancing algorithmic complexity and simplicity was challenging. +Dealing with variable data and constraints in real-world scenarios required adaptation without oversimplification. +Maintaining the integrity of algorithmic principles while being practical was a hurdle. +Striking the right balance between algorithmic complexity and real-world relevance posed a challenge. + +**Learning About Problem Design:** + +Clarity and simplicity are crucial in problem design for effective learning. +Real-world relevance and adaptability engage learners at different proficiency levels. +The iterative nature of problem design became evident, highlighting the importance of feedback and refinement. +ChatGPT played a vital role in enhancing problem design and educational materials. +These points encapsulate your reflection on the role of ChatGPT in algorithmic problem design, the challenges faced, and the insights gained about effective problem design in the realm of algorithms. + + + + diff --git a/Submissions/002795461_Namitha_JC/assignment1.ipynb b/Submissions/002795461_Namitha_JC/assignment1.ipynb new file mode 100644 index 0000000..24975dd --- /dev/null +++ b/Submissions/002795461_Namitha_JC/assignment1.ipynb @@ -0,0 +1,1109 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Assignment 1:**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question1** \n", + "\n", + "**Arrange the given space complexities in ascending order based on their memory usage. Start with the space complexity that requires the least memory and end with the one that requires the most.**\n", + "\n", + "- A. O(log(log n))\n", + "- B. O(n^e)\n", + "- C. O(log(n)^2)\n", + "- D. O(log(n!))\n", + "- E. O(e^n)\n", + "- F. O(e^(e^n))\n", + "- G. O(n^log n)\n", + "- H. O(n^(e^2))\n", + "- I. O(e^(n^2))\n", + "- J. O(log(log(n)^e))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Answer1** \n", + "\n", + "- O(log(log n))\n", + "- O(log(n)^2)\n", + "- O(log(n!))\n", + "- O(n^log n)\n", + "- O(e^n)\n", + "- O(n^e)\n", + "- O(e^(n^2))\n", + "- O(n^(e^2))\n", + "- O(e^(e^n))\n", + "- O(log(log(n)^e))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question2**\n", + "\n", + "**Given two functions P and Q such that P(n) is O(Q(n)), evaluate the following statements to determine whether they are true or false. Provide proofs or counterexamples as needed.**\n", + "\n", + "**P(n) = θ(P(n + 1))**\n", + "**P(n) = O(P(n/2))**\n", + "**P(n) = O(Q(n^2)) implies Q(n) = Ω(P(n))**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Answer2** \n", + "\n", + "Statement 1: Is it true that P(n) = θ(P(n + 1))?\n", + "\n", + "Solution 1: This statement is not true.\n", + "\n", + "Counterexample: Let P(n) = n. In this case, P(n) = θ(P(n + 1)) is not true because n and n + 1 have different growth rates. P(n + 1) grows faster by a constant factor than P(n).\n", + "\n", + "Statement 2: Is it true that P(n) = O(P(n/2))?\n", + "\n", + "Solution 2: This statement is true.\n", + "\n", + "Explanation: To prove this, we can demonstrate that P(n) = O(P(n/2)). This is often true in algorithms where the input size is halved in each step, leading to a logarithmic growth rate.\n", + "\n", + "Statement 3: Does P(n) = O(Q(n^2)) imply Q(n) = Ω(P(n))?\n", + "\n", + "Solution 3: This statement is true.\n", + "\n", + "Explanation: If P(n) = O(Q(n^2)), it means that P(n) grows at a rate bounded by Q(n^2). To prove that Q(n) = Ω(P(n)), we can show that Q(n) grows at least as fast as P(n) (with some positive constant factor) for all n greater than or equal to a certain value (n0). This is a common property of Big O notation.\n", + "\n", + "**Psdeudo Code:**\n", + "\n", + "*Given functions P and Q*\n", + "function P(n):\n", + " *Implementation of function P*\n", + " return n\n", + "\n", + "function Q(n):\n", + " *Implementation of function Q*\n", + " return n^2\n", + "\n", + "*Statement 1*\n", + "function isStatement1True():\n", + " for n from 1 to infinity:\n", + " if P(n) != θ(P(n + 1)):\n", + " return False\n", + " return True\n", + "\n", + "*Statement 2*\n", + "function isStatement2True():\n", + " for n from 1 to infinity:\n", + " if P(n) > O(P(n/2)):\n", + " return False\n", + " return True\n", + "\n", + "*Statement 3*\n", + "function isStatement3True():\n", + " for n from 1 to infinity:\n", + " if P(n) <= O(Q(n^2)):\n", + " if Q(n) < Ω(P(n)):\n", + " return False\n", + " return True\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question3**\n", + "\n", + "**Consider a scenario in a bustling city where there are \"x\" restaurants and \"n\" food delivery drivers. Each restaurant has a ranking of drivers based on their delivery speed and customer ratings, and each driver also has a ranking of restaurants based on factors like cuisine type and location. Assume that there are more food delivery drivers than there are available delivery slots at the restaurants.**\n", + "\n", + "**The objective is to devise an algorithm to find a stable assignment of drivers to restaurants, ensuring that each restaurant fills its available delivery slots and no driver is left without a delivery assignment. A stable assignment is one in which neither of the following situations arises:**\n", + "\n", + "**a. There are drivers \"D1\" and \"D2\" and a restaurant \"R,\" such that:**\n", + "\n", + "**\"D1\" is assigned to \"R,\"**\n", + "**\"D2\" is not assigned to any restaurant, and**\n", + "**\"R\" prefers \"D2\" to \"D1\" based on cuisine type and location.**\n", + "**b. There are drivers \"D1\" and \"D2\" and restaurants \"R1\" and \"R2,\" such that:**\n", + "\n", + "**\"D1\" is assigned to \"R1,\"**\n", + "**\"D2\" is assigned to \"R2,\"**\n", + "**\"R1\" prefers \"D2\" to \"D1,\" and**\n", + "**\"D2\" prefers \"R1\" to \"R2.\"**\n", + "**Demonstrate that there is always a stable assignment of drivers to restaurants under these conditions, and outline an algorithm to find such a stable assignment.**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Answer3**\n", + "\n", + "The algorithm to find a stable assignment of drivers to restaurants, taking into account the new conditions, follows a structure similar to the Gale-Shapley algorithm for the Stable Marriage Problem. At any given time, a driver is either matched with a restaurant or remains unmatched, and each restaurant can have a certain number of available delivery slots or be fully occupied. The algorithm proceeds as follows:\n", + "\n", + "**Input:**\n", + "**x: Number of restaurants**\n", + "**n: Number of food delivery drivers**\n", + "**restaurant_rankings: A 2D array where restaurant_rankings[i][j] represents the ranking of driver j by restaurant i**\n", + "**driver_rankings: A 2D array where driver_rankings[i][j] represents the ranking of restaurant j by driver i**\n", + "\n", + "**Initialize an array to keep track of driver assignments**\n", + "driver_assignment = [-1] * n\n", + "\n", + "**Initialize an array to keep track of the number of available delivery slots at each restaurant**\n", + "available_slots = [x] * x\n", + "\n", + "**Create a dictionary to store the current position in the preference list for each driver**\n", + "driver_position = {driver: 0 for driver in range(n)}\n", + "\n", + "**While there exists a restaurant R1 with available delivery slots:**\n", + "while any(available_slots):\n", + " for driver in range(n):\n", + " if driver_assignment[driver] == -1:\n", + " # Get the current restaurant that the driver is considering\n", + " current_restaurant = driver_rankings[driver][driver_position[driver]]\n", + " driver_position[driver] += 1\n", + " \n", + " # If the restaurant has available delivery slots\n", + " if available_slots[current_restaurant] > 0:\n", + " driver_assignment[driver] = current_restaurant\n", + " available_slots[current_restaurant] -= 1\n", + " else:\n", + " # The restaurant is fully occupied, check if the restaurant prefers the current driver\n", + " current_driver = driver_assignment.index(current_restaurant)\n", + " if restaurant_rankings[current_restaurant][driver] < restaurant_rankings[current_restaurant][current_driver]:\n", + " # The restaurant prefers the current driver, so switch the assignments\n", + " driver_assignment[driver] = current_restaurant\n", + " driver_assignment[current_driver] = -1\n", + "\n", + "**The driver_assignment array now contains the stable assignment of drivers to restaurants**\n", + "\n", + "This pseudo-code implements the algorithm to find a stable assignment of food delivery drivers to restaurants based on their preferences, which now include cuisine type, location, delivery speed, and customer ratings. The algorithm ensures that each restaurant fills its available delivery slots, and no driver is left unassigned. The algorithm continues until all restaurants have assigned their available slots or until no further stable assignments are possible.\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question4** \n", + "\n", + "**Two sorting algorithms, Bubble Sort and Merge Sort, are compared based on their runtime complexities. Bubble Sort takes 10log2(n) microseconds to sort an array of size n, while Merge Sort takes 5sqrt(n) microseconds. Which of these sorting algorithms demonstrates superior asymptotic efficiency, and at what value of n do they reach a point of intersection in terms of runtime efficiency?**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Answer4**\n", + "\n", + "In this examination of sorting algorithms, the first algorithm corresponds to Bubble Sort, while the second algorithm corresponds to Merge Sort.\n", + "\n", + "Bubble Sort exhibits a runtime complexity of 10*log2(n) microseconds.\n", + "Merge Sort demonstrates a runtime complexity of 5*sqrt(n) microseconds.\n", + "To determine which algorithm boasts superior asymptotic efficiency, it's crucial to assess their respective order of growth:\n", + "\n", + "The order of growth associated with Bubble Sort (10log2(n)) is less significant than the order of growth associated with Merge Sort (5sqrt(n)).\n", + "Consequently, Bubble Sort stands as the asymptotically faster algorithm when compared to Merge Sort.\n", + "\n", + "Now, let's pinpoint the crossover value of n, indicating the threshold at which Merge Sort surpasses Bubble Sort in terms of runtime efficiency:\n", + "\n", + "The crossover point for n materializes when both algorithms exhibit equivalent runtime durations, specifically when 10log2(n) microseconds equals 5sqrt(n) microseconds.\n", + "To arrive at the precise crossover value, further mathematical analysis or numerical methods may be essential. The provided solution indicates that the crossover value for n occurs when 10log2(n) equals 5sqrt(n)." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Let's illustrate the concept with Python code using the specific runtime values provided:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Merge Sort is faster for n = 2000\n" + ] + } + ], + "source": [ + "import time\n", + "import math\n", + "import random\n", + "\n", + "# Bubble Sort - Runtime: 10 * log2(n) microseconds\n", + "def bubble_sort(arr):\n", + " n = len(arr)\n", + " for i in range(n):\n", + " for j in range(0, n - i - 1):\n", + " if arr[j] > arr[j + 1]:\n", + " arr[j], arr[j + 1] = arr[j + 1], arr[j]\n", + "\n", + "# Merge Sort - Runtime: 5 * sqrt(n) microseconds\n", + "def merge_sort(arr):\n", + " if len(arr) > 1:\n", + " mid = len(arr) // 2\n", + " left_half = arr[:mid]\n", + " right_half = arr[mid:]\n", + "\n", + " merge_sort(left_half)\n", + " merge_sort(right_half)\n", + "\n", + " i = j = k = 0\n", + "\n", + " while i < len(left_half) and j < len(right_half):\n", + " if left_half[i] < right_half[j]:\n", + " arr[k] = left_half[i]\n", + " i += 1\n", + " else:\n", + " arr[k] = right_half[j]\n", + " j += 1\n", + " k += 1\n", + "\n", + " while i < len(left_half):\n", + " arr[k] = left_half[i]\n", + " i += 1\n", + " k += 1\n", + "\n", + " while j < len(right_half):\n", + " arr[k] = right_half[j]\n", + " j += 1\n", + " k += 1\n", + "\n", + "# Test the Algorithms\n", + "crossover_value = 2000 # Adjust this value as needed\n", + "\n", + "random.seed(42)\n", + "array = [random.randint(1, 1000) for _ in range(crossover_value)]\n", + "\n", + "# Measure the runtime of Bubble Sort\n", + "start_time = time.time()\n", + "bubble_sort(array.copy())\n", + "bubble_sort_time = (time.time() - start_time) * 1e6 # Convert to microseconds\n", + "\n", + "# Measure the runtime of Merge Sort\n", + "start_time = time.time()\n", + "merge_sort(array.copy())\n", + "merge_sort_time = (time.time() - start_time) * 1e6 # Convert to microseconds\n", + "\n", + "if bubble_sort_time < 5 * math.sqrt(crossover_value):\n", + " print(f\"Bubble Sort is faster for n = {crossover_value}\")\n", + "else:\n", + " print(f\"Merge Sort is faster for n = {crossover_value}\")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question5** \n", + "\n", + "**Imagine you are tasked with designing a sequence of picture frames to hang on a wall, and you want to minimize the growth rate of the function f(n), where n represents the total number of frames used in the design. Each row of frames will be placed one below the other, and you want to ensure that the number of frames used in each row is bounded by a constant c. Your objective is to create this design using frames with widths determined by the function f(n), where f(n) grows as slowly as possible.**\n", + "\n", + "**How can you design this arrangement of picture frames while adhering to the constraints mentioned above?**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Answer5**\n", + "\n", + "Suppose we want to construct a series of shelves to hold a total of n books, with each shelf having a maximum capacity of c books. To minimize the growth rate of the function f(n), we can approach this problem using a binary search-like algorithm.\n", + "\n", + "Here's a code example and complexity explanation:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minimum number of shelves needed: 6\n" + ] + } + ], + "source": [ + "def find_min_shelves(n, c):\n", + " left, right = 1, n # Initialize the search range for the number of shelves\n", + "\n", + " while left <= right:\n", + " mid = (left + right) // 2 # Calculate the midpoint\n", + " total_books = mid * c # Calculate the total books with mid shelves\n", + "\n", + " if total_books == n:\n", + " return mid # Exact match found\n", + " elif total_books < n:\n", + " left = mid + 1 # Adjust the search range to the right\n", + " else:\n", + " right = mid - 1 # Adjust the search range to the left\n", + "\n", + " return right # Return the minimum number of shelves needed\n", + "\n", + "# Example usage\n", + "total_books_needed = 30 # Total number of books needed\n", + "books_per_shelf = 5 # Maximum number of books per shelf\n", + "\n", + "min_shelves = find_min_shelves(total_books_needed, books_per_shelf)\n", + "print(f\"Minimum number of shelves needed: {min_shelves}\")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Space Complexity:\n", + "\n", + "Space Complexity: O(1)\n", + "The code's memory usage is constant, unaffected by the input size n or c.\n", + "\n", + "Time Complexity:\n", + "\n", + "Time Complexity: O(log₂(n))\n", + "Explanation:\n", + "\n", + "left and right represent the search range.\n", + "mid is calculated as the average of left and right.\n", + "total_books is computed as mid * c.\n", + "With each iteration, we reduce the search range by half, resulting in a logarithmic number of iterations based on n.\n", + "\n", + "In summary, the space complexity is constant (O(1)), and the time complexity is logarithmic (O(log(n))), making the code efficient in terms of both space and time, while minimizing the growth rate of the function f(n)." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question6**\n", + "\n", + "**One algorithm requires log2 (n) seconds and another algorithm requires √n seconds. Which one grows\n", + "asymptotically faster? That is, which grows faster as n gets large? What is the cross-over value of n? (The\n", + "value at which the curves intersect)?**" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting matplotlib\n", + " Downloading matplotlib-3.8.0-cp310-cp310-macosx_11_0_arm64.whl (7.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.5/7.5 MB\u001b[0m \u001b[31m21.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hCollecting contourpy>=1.0.1\n", + " Downloading contourpy-1.1.1-cp310-cp310-macosx_11_0_arm64.whl (232 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m232.4/232.4 kB\u001b[0m \u001b[31m35.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting cycler>=0.10\n", + " Downloading cycler-0.11.0-py3-none-any.whl (6.4 kB)\n", + "Collecting kiwisolver>=1.0.1\n", + " Downloading kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl (66 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.2/66.2 kB\u001b[0m \u001b[31m15.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting pillow>=6.2.0\n", + " Downloading Pillow-10.0.1-cp310-cp310-macosx_11_0_arm64.whl (3.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.3/3.3 MB\u001b[0m \u001b[31m65.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: packaging>=20.0 in /Users/namithajc/Library/Python/3.10/lib/python/site-packages (from matplotlib) (23.1)\n", + "Collecting pyparsing>=2.3.1\n", + " Downloading pyparsing-3.1.1-py3-none-any.whl (103 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m103.1/103.1 kB\u001b[0m \u001b[31m14.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy<2,>=1.21 in /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages (from matplotlib) (1.23.5)\n", + "Collecting fonttools>=4.22.0\n", + " Downloading fonttools-4.42.1-cp310-cp310-macosx_10_9_universal2.whl (2.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.7/2.7 MB\u001b[0m \u001b[31m47.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: python-dateutil>=2.7 in /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: six>=1.5 in /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Installing collected packages: pyparsing, pillow, kiwisolver, fonttools, cycler, contourpy, matplotlib\n", + "Successfully installed contourpy-1.1.1 cycler-0.11.0 fonttools-4.42.1 kiwisolver-1.4.5 matplotlib-3.8.0 pillow-10.0.1 pyparsing-3.1.1\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.3.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def plotting_func():\n", + "\n", + " fn1 = input('Enter the first function (for \"log\" use numpy)): ')\n", + " fn2 = input('Enter the second function (for \"log\" use numpy): ')\n", + "\n", + " try:\n", + " x = np.arange(1, 101) \n", + "\n", + " func1 = eval(fn1)\n", + " func2 = eval(fn2)\n", + "\n", + " plt.plot(x, func1, label = f'Function 1: {fn1}')\n", + " plt.plot(x, func2, label = f'Function 2: {fn2}')\n", + "\n", + " plt.xlabel('Input Size')\n", + " plt.ylabel('Running Time')\n", + " plt.legend()\n", + "\n", + " plt.show()\n", + "\n", + " crossover_point = np.argmax(func1 > func2)\n", + " if crossover_point == 0:\n", + "\n", + " print('The functions do not intersect')\n", + " else:\n", + " print(f'The functions cross at n = {crossover_point}.')\n", + "\n", + "\n", + " if func1[-1] > func2[-1]:\n", + " print(f'Function 1{fn1} grows faster.')\n", + "\n", + " elif func1[-1] < func2[-1]:\n", + " print(f'Function 2 ({fn2}) grows faster.')\n", + " else:\n", + " print('Both functions grow at the same rate.')\n", + "\n", + " except Exception as e:\n", + " print(\"Error:\", str(e))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Please put your own input" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The functions cross at n = 1.\n", + "Function 1x**2 grows faster.\n" + ] + } + ], + "source": [ + "plotting_func()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question7**\n", + "\n", + "**In a student assignment scenario, consider two students, Alice and Bob, and two assignments, Assignment A and Assignment B. Alice ranks Assignment A as her top preference, and Bob ranks Assignment B as his top preference. If this assignment situation results in a stable matching, is it always true that Alice and Bob will be assigned to Assignment A and Assignment B, respectively?**\n", + "\n", + "**State whether the above statement is True or False.**\n", + "**If the statement is true, provide a brief explanation. If false, provide a counterexample to demonstrate when Alice and Bob might not be assigned to their top preferences despite the matching being stable.**\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Answer7**\n", + "\n", + "In any stable seating arrangement for this instance, the pair (Alex, Bella) will be seated together.\n", + "\n", + "Explanation:\n", + "The statement is true. If Alice and Bob both rank each other as their top preferences, it means they strongly prefer each other over any other possible partner. In the context of stable matching, if they are not matched with each other, it would imply that there is another pairing where both Alice and Bob prefer each other over their current partners. This would make the matching unstable, which contradicts the definition of a stable matching.\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Pseudo Code**" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Alice': 'Bob', 'Bob': 'Charlie', 'Charlie': 'Charlie'}\n" + ] + } + ], + "source": [ + "function stable_matching(preferences):\n", + " Initialize an empty matching dictionary\n", + " Initialize an empty proposals dictionary\n", + "\n", + " Create a list of all individuals\n", + " while individuals is not empty:\n", + " person = first individual in the list\n", + " pref_list = preferences[person]\n", + " preferred_partner = the first person in pref_list\n", + "\n", + " if preferred_partner is not matched:\n", + " Match person with preferred_partner\n", + " Remove person from the list of individuals\n", + " else:\n", + " current_partner = the current partner of preferred_partner\n", + "\n", + " if person is preferred over current_partner:\n", + " Match person with preferred_partner\n", + " Remove person from the list of individuals\n", + " else:\n", + " Add person to preferred_partner's proposal list\n", + "\n", + " Return the matching dictionary\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Complexity Analysis:\n", + "The complexity of this code depends on the number of individuals and their preferences. In the worst case, the code may iterate through the preferences multiple times, but it is guaranteed to find a stable matching. The time complexity can be roughly approximated as O(n^2), where n is the number of individuals. However, the actual number of iterations may be fewer in practice, especially when individuals have strong mutual preferences." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question8**\n", + "\n", + "**Consider a hospital with multiple departments, each offering a variety of medical services to patients. The hospital's goal is to establish a stable patient appointment scheduling system that maximizes patient satisfaction and minimizes appointment conflicts.**\n", + "\n", + "**Each patient has preferences for the medical services they require, and each service has a limited capacity.**\n", + "**A stable appointment schedule means that no patient wants to cancel or reschedule their appointments, and no healthcare provider wishes to remove a patient from their appointment list.**\n", + "**Each medical service has specific time slots and availability throughout the week.**\n", + "**Patients have their own schedules indicating the days and times they are available for appointments.**\n", + "**A patient can only schedule an appointment for a service if it aligns with their availability, and they won't cancel it unless there's a suitable replacement within their availability.**\n", + "**The challenge is to design a scheduling algorithm that assigns patients to appointments while considering these timing constraints, ensuring:**\n", + "\n", + "**Each patient is assigned appointments for their preferred medical services that fit their schedules and for which they meet the medical criteria.**\n", + "**Each medical service is fully utilized without exceeding its capacity and adheres to its schedule.**\n", + "**No patient wishes to cancel or reschedule an appointment and seek another because they prefer their current set of appointments and their schedules.**\n", + "**The question to resolve is whether there exists a stable patient appointment scheduling system that satisfies all these conditions for any given set of patients, medical services, their preferences, and timing constraints. Provide an algorithm to determine if a stable appointment schedule is possible or an example where it is not possible.**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Answer8**\n", + "\n", + "Stable Patient Appointment Scheduling with Medical Criteria and Timing Constraints.\n", + "\n", + "Pseudo Code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize empty appointment schedules for each patient\n", + "appointment_schedules = {}\n", + "\n", + "# Initialize available appointments for each medical service\n", + "available_appointments = {}\n", + "\n", + "# Initialize stability flag\n", + "is_stable = False\n", + "\n", + "# Main algorithm loop\n", + "while not is_stable:\n", + " # Reset the stability flag for this iteration\n", + " is_stable = True\n", + "\n", + " # Iterate over each patient\n", + " for patient in patients:\n", + " # Sort medical service preferences based on priority\n", + " sorted_preferences = sort_preferences(patient.preferences)\n", + "\n", + " # Initialize a flag to track if any changes are made for this patient\n", + " changes_made = False\n", + "\n", + " # Iterate over sorted preferences\n", + " for service in sorted_preferences:\n", + " if meets_medical_criteria(patient, service) and has_available_appointments(service):\n", + " # Assign the appointment to the patient\n", + " appointment = assign_appointment(patient, service)\n", + " appointment_schedules[patient].append(appointment)\n", + " available_appointments[service].remove(appointment)\n", + "\n", + " # Mark that changes were made for this patient\n", + " changes_made = True\n", + "\n", + " if changes_made:\n", + " # If changes were made for this patient, check for schedule alignment\n", + " appointment_schedules[patient] = align_schedule(patient, appointment_schedules[patient])\n", + "\n", + " # Check if the patient still wishes to make changes\n", + " if wants_to_change_appointments(patient, appointment_schedules[patient]):\n", + " is_stable = False # Not stable if patient wants changes\n", + "\n", + "# Final appointment schedules are stable\n", + "final_appointment_schedules = appointment_schedules\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this pseudo-code:\n", + "\n", + "**sort_preferences** sorts the patient's preferences.\n", + "**meets_medical_criteria** checks if the patient meets the medical criteria for a service.\n", + "**has_available_appointments** checks if there are available appointments for a service.\n", + "**assign_appointment** assigns an appointment to a patient.\n", + "**align_schedule** aligns the patient's schedule with the assigned appointments.\n", + "**wants_to_change_appointments** checks if the patient still wishes to change appointments.\n", + "\n", + "This algorithm iteratively assigns appointments based on patient preferences, aligns schedules, and checks for stability until no patient wishes to change appointments. If it reaches a point where no changes are requested, the appointment schedules are considered stable." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Question9**\n", + "\n", + "At a grand prom event, organizers are reimagining the traditional prom dance format to foster inclusivity and intergenerational connections. This prom will include participants of various age groups, from teenagers to adults. Instead of allowing attendees to choose their own dance partners, they are implementing a Dance Partner Matching Algorithm, inspired by the Gale-Shapley Algorithm.\n", + "\n", + "Key Points:\n", + "\n", + "Intergenerational Prom: Unlike conventional proms that mainly cater to teenagers, this event welcomes participants from different age groups, including teenagers and adults. The goal is to create an inclusive and memorable experience for all attendees.\n", + "\n", + "Dance Partner Matching Algorithm: To ensure that everyone has a chance to enjoy the dance floor, the organizers have designed a Gale-Shapley-inspired Matching Algorithm. This algorithm will consider factors like dance style preferences, age compatibility, and participant interests to create optimal dance pairs.\n", + "\n", + "Participant Input: Participants are encouraged to provide information about their preferred dance styles (e.g., ballroom, salsa, contemporary), age group preferences for dance partners, and any specific dance songs they would like to dance to.\n", + "\n", + "Fostering Connections: The primary objective of this change is to promote connections and camaraderie across age groups. It offers an opportunity for older individuals to share their dance experiences with younger generations and vice versa.\n", + "\n", + "Evaluation and Feedback: The success of this new prom format will be evaluated based on participant feedback, the quality of dance matches, and the level of enjoyment experienced by all attendees. Organizers will also assess whether it achieves the intended intergenerational connections.\n", + "\n", + "This scenario introduces an innovative approach to prom dances by utilizing a matching algorithm to pair participants from different age groups with dance partners. It seeks to create an inclusive and enriching experience where attendees can share their love for dancing and forge meaningful connections with individuals of various generations." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A. Write a code in python to match different number of teenagers and with each other using the Gale-Shapley algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Elder1 is matched with Teen1\n", + "Elder2 is matched with Teen2\n", + "Elder3 is matched with Teen3\n", + "Elder4 is matched with Teen4\n", + "Elder5 is matched with Teen5\n" + ] + } + ], + "source": [ + "def gale_shapley(teenagers, elders):\n", + " # Create dictionaries to store the matches\n", + " matches = {}\n", + " reverse_matches = {}\n", + "\n", + " # Initialize all participants as free\n", + " free_teenagers = list(teenagers.keys())\n", + "\n", + " # While there are free teenagers\n", + " while free_teenagers:\n", + " teen = free_teenagers.pop(0)\n", + " teen_preferences = teenagers[teen]\n", + "\n", + " for adult in teen_preferences:\n", + " # Check if the adult is free or prefers the current teenager\n", + " current_match = matches.get(adult)\n", + " if current_match is None or elders[adult].index(teen) < elders[adult].index(current_match):\n", + " # Update matches\n", + " matches[adult] = teen\n", + " reverse_matches[teen] = adult\n", + " if current_match is not None:\n", + " free_teenagers.append(current_match)\n", + " break\n", + "\n", + " return matches, reverse_matches\n", + "\n", + "# Example input data (preferences)\n", + "teenagers = {\n", + " 'Teen1': ['Elder1', 'Elder2', 'Elder3', 'Elder4', 'Elder5'],\n", + " 'Teen2': ['Elder2', 'Elder1', 'Elder3', 'Elder4', 'Elder5'],\n", + " 'Teen3': ['Elder3', 'Elder2', 'Elder1', 'Elder4', 'Elder5'],\n", + " 'Teen4': ['Elder4', 'Elder2', 'Elder1', 'Elder3', 'Elder5'],\n", + " 'Teen5': ['Elder5', 'Elder4', 'Elder2', 'Elder1', 'Elder3'],\n", + "}\n", + "\n", + "elders = {\n", + " 'Elder1': ['Teen1', 'Teen2', 'Teen3', 'Teen4', 'Teen5'],\n", + " 'Elder2': ['Teen2', 'Teen3', 'Teen4', 'Teen5', 'Teen1'],\n", + " 'Elder3': ['Teen3', 'Teen4', 'Teen5', 'Teen1', 'Teen2'],\n", + " 'Elder4': ['Teen4', 'Teen5', 'Teen1', 'Teen2', 'Teen3'],\n", + " 'Elder5': ['Teen5', 'Teen1', 'Teen2', 'Teen3', 'Teen4'],\n", + "}\n", + "\n", + "# Run the Gale-Shapley algorithm\n", + "matches, reverse_matches = gale_shapley(teenagers, elders)\n", + "\n", + "for adult, teenager in matches.items():\n", + " print(f\"{adult} is matched with {teenager}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "B.Write a code to shuffle the preferences by n number of times and calculate stable matches" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Elder3 is matched with Teen5\n", + "Elder2 is matched with Teen2\n", + "Elder1 is matched with Teen1\n", + "Elder5 is matched with Teen4\n", + "Elder4 is matched with Teen3\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "def gale_shapley(teenagers, elders):\n", + " # Create dictionaries to store the matches\n", + " matches = {}\n", + " reverse_matches = {}\n", + "\n", + " # Initialize all participants as free\n", + " free_teenagers = list(teenagers.keys())\n", + "\n", + " # While there are free teenagers\n", + " while free_teenagers:\n", + " teen = free_teenagers.pop(0)\n", + " teen_preferences = teenagers[teen]\n", + "\n", + " for adult in teen_preferences:\n", + " # Check if the adult is free or prefers the current teenager\n", + " current_match = matches.get(adult)\n", + " if current_match is None or elders[adult].index(teen) < elders[adult].index(current_match):\n", + " # Update matches\n", + " matches[adult] = teen\n", + " reverse_matches[teen] = adult\n", + " if current_match is not None:\n", + " free_teenagers.append(current_match)\n", + " break\n", + "\n", + " return matches, reverse_matches\n", + "\n", + "def shuffle_preferences(preferences):\n", + " # Shuffle the order of preferences for each participant\n", + " for participant, prefs in preferences.items():\n", + " random.shuffle(prefs)\n", + "teenagers = {\n", + " 'Teen1': ['Elder1', 'Elder2', 'Elder3', 'Elder4', 'Elder5'],\n", + " 'Teen2': ['Elder2', 'Elder1', 'Elder3', 'Elder4', 'Elder5'],\n", + " 'Teen3': ['Elder3', 'Elder2', 'Elder1', 'Elder4', 'Elder5'],\n", + " 'Teen4': ['Elder4', 'Elder2', 'Elder1', 'Elder3', 'Elder5'],\n", + " 'Teen5': ['Elder5', 'Elder4', 'Elder2', 'Elder1', 'Elder3'],\n", + "}\n", + "\n", + "elders = {\n", + " 'Elder1': ['Teen1', 'Teen2', 'Teen3', 'Teen4', 'Teen5'],\n", + " 'Elder2': ['Teen2', 'Teen3', 'Teen4', 'Teen5', 'Teen1'],\n", + " 'Elder3': ['Teen3', 'Teen4', 'Teen5', 'Teen1', 'Teen2'],\n", + " 'Elder4': ['Teen4', 'Teen5', 'Teen1', 'Teen2', 'Teen3'],\n", + " 'Elder5': ['Teen5', 'Teen1', 'Teen2', 'Teen3', 'Teen4'],\n", + "}\n", + "\n", + "# Number of times to shuffle preferences\n", + "n_shuffle = 1000\n", + "\n", + "# Run the Gale-Shapley algorithm after shuffling preferences n times\n", + "for _ in range(n_shuffle):\n", + " shuffle_preferences(teenagers)\n", + " # shuffle_preferences(adults)\n", + " shuffle_preferences(elders)\n", + " matches, _ = gale_shapley(teenagers, elders)\n", + "\n", + "# Print the final matches\n", + "for adult, teenager in matches.items():\n", + " print(f\"{adult} is matched with {teenager}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "C.Assume if for certain songs one person might dance and for other songs they might not , write a code for it" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Elder1 is matched with Teen1 and will dance.\n", + "Elder4 is matched with Teen4 and will dance.\n", + "Elder5 is matched with Teen3 and will dance.\n", + "Elder3 is matched with Teen5 and will dance.\n", + "Elder2 is matched with Teen2 and will dance.\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "def gale_shapley_with_song_preferences(teenagers, elders, song_preferences):\n", + " # Create dictionaries to store the matches\n", + " matches = {}\n", + " reverse_matches = {}\n", + "\n", + " # Initialize all participants as free\n", + " free_teenagers = list(teenagers.keys())\n", + "\n", + " # While there are free teenagers\n", + " while free_teenagers:\n", + " teen = free_teenagers.pop(0)\n", + " teen_preferences = teenagers[teen]\n", + "\n", + " for adult in teen_preferences:\n", + " # Check if the adult is free or prefers the current teenager\n", + " current_match = matches.get(adult)\n", + "\n", + " # Check song preferences for the current match\n", + " song_preference = song_preferences[adult].get(teen, True)\n", + "\n", + " if (current_match is None or elders[adult].index(teen) < elders[adult].index(current_match)) and song_preference:\n", + " # Update matches\n", + " matches[adult] = teen\n", + " reverse_matches[teen] = adult\n", + " if current_match is not None:\n", + " free_teenagers.append(current_match)\n", + " break\n", + "\n", + " return matches, reverse_matches\n", + "\n", + "def shuffle_preferences(preferences):\n", + " # Shuffle the order of preferences for each participant\n", + " for participant, prefs in preferences.items():\n", + " random.shuffle(prefs)\n", + "\n", + "# Example input data (preferences)\n", + "teenagers = {\n", + " 'Teen1': ['Elder1', 'Elder2', 'Elder3', 'Elder4', 'Elder5'],\n", + " 'Teen2': ['Elder2', 'Elder1', 'Elder3', 'Elder4', 'Elder5'],\n", + " 'Teen3': ['Elder3', 'Elder2', 'Elder1', 'Elder4', 'Elder5'],\n", + " 'Teen4': ['Elder4', 'Elder2', 'Elder1', 'Elder3', 'Elder5'],\n", + " 'Teen5': ['Elder5', 'Elder4', 'Elder2', 'Elder1', 'Elder3'],\n", + "}\n", + "\n", + "elders = {\n", + " 'Elder1': ['Teen1', 'Teen2', 'Teen3', 'Teen4', 'Teen5'],\n", + " 'Elder2': ['Teen2', 'Teen3', 'Teen4', 'Teen5', 'Teen1'],\n", + " 'Elder3': ['Teen3', 'Teen4', 'Teen5', 'Teen1', 'Teen2'],\n", + " 'Elder4': ['Teen4', 'Teen5', 'Teen1', 'Teen2', 'Teen3'],\n", + " 'Elder5': ['Teen5', 'Teen1', 'Teen2', 'Teen3', 'Teen4'],\n", + "}\n", + "\n", + "# Song preferences (for each adult, True means they will dance, False means they won't)\n", + "song_preferences = {}\n", + "for elder in elders:\n", + " song_preferences[elder] = {}\n", + " for teenager in teenagers:\n", + " # Randomly set song preferences for each pair (elder, teenager)\n", + " song_preferences[elder][teenager] = [random.choice([True, False]) for _ in range(3)]\n", + "\n", + "# Number of times to shuffle preferences\n", + "n_shuffle = 100\n", + "\n", + "# Run the Gale-Shapley algorithm after shuffling preferences n times\n", + "for _ in range(n_shuffle):\n", + " shuffle_preferences(teenagers)\n", + " # shuffle_preferences(adults)\n", + " matches, _ = gale_shapley_with_song_preferences(teenagers, elders, song_preferences)\n", + "\n", + "# Print the final matches\n", + "for adult, teenager in matches.items():\n", + " if song_preferences[adult].get(teenager, False):\n", + " print(f\"{adult} is matched with {teenager} and will dance.\")\n", + " else:\n", + " print(f\"{adult} is matched with {teenager} but won't dance for this song.\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "D.Can we match teens with only Teens and Elders with only elders\n", + "\n", + "If you want to match elders with only elders and teens with only teens, we can run he algorithm only by\n", + "\n", + "teenager_matches, _ = gale_shapley({'teenagers': teenagers}, song_preferences['teenagers'])\n", + "\n", + "elder_matches, _ = gale_shapley({'elders': elders}, song_preferences['elders'])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "E. By incresing the number of participants does the time complexity increase?\n", + "\n", + "The time Complexity of the code can be analysed as : Shuffling: Shuffling each participant's list involves iterating through the list once and randomly selecting elements using random.sample. The time complexity for this operation is O(n), where n is the length of the list (which is constant, as there are always 15 participants). Creating Subsets: Creating subsets involves slicing the shuffled list into three parts (Teens, Adults, Elders), which is also an O(n) operation. Therefore, the overall time complexity of the code is O(n) for shuffling each participant's list and creating subsets for each participant.\n", + "\n", + "Thus by increaseing by n participants the code increases in iteration by n." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Assistance from ChatGPT:**\n", + "\n", + "ChatGPT provided valuable guidance in structuring algorithmic problems.\n", + "It clarified complex algorithmic concepts and generated illustrative code examples.\n", + "ChatGPT's assistance was instrumental in simplifying algorithms without compromising core principles.\n", + "\n", + "**Challenges Faced:**\n", + "\n", + "Balancing algorithmic complexity and simplicity was challenging.\n", + "Dealing with variable data and constraints in real-world scenarios required adaptation without oversimplification.\n", + "Maintaining the integrity of algorithmic principles while being practical was a hurdle.\n", + "Striking the right balance between algorithmic complexity and real-world relevance posed a challenge.\n", + "\n", + "**Learning About Problem Design:**\n", + "\n", + "Clarity and simplicity are crucial in problem design for effective learning.\n", + "Real-world relevance and adaptability engage learners at different proficiency levels.\n", + "The iterative nature of problem design became evident, highlighting the importance of feedback and refinement.\n", + "ChatGPT played a vital role in enhancing problem design and educational materials.\n", + "These points encapsulate your reflection on the role of ChatGPT in algorithmic problem design, the challenges faced, and the insights gained about effective problem design in the realm of algorithms.\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.7" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "98590ff4fe04c8543246b2a01debd3de3c5ca9b666f43f1fa87d5110c692004c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002795957_Lokesh_jeswani/Assignment_1(PSA).ipynb b/Submissions/002795957_Lokesh_jeswani/Assignment_1(PSA).ipynb new file mode 100644 index 0000000..47fced1 --- /dev/null +++ b/Submissions/002795957_Lokesh_jeswani/Assignment_1(PSA).ipynb @@ -0,0 +1,472 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "INFO 6205 - Program Structure and Algorithms(PSA)\\\n", + "Assignment 1:\\\n", + "Student Name: Lokesh Mohan Jeswani [NU ID: 002795957]\\\n", + "Professor: Nick Bear Brown" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q1. Suppose you have a graph with the following edges:\n", + "\n", + "A -> B\\\n", + "A -> C\\\n", + "B -> D\\\n", + "B -> E\\\n", + "C -> F\n", + "\n", + "You are given three tasks:\n", + "\n", + "**Task 1:** Perform a Breadth-First Search (BFS) starting from node A. What will be the order of visited nodes?\n", + "\n", + "**Task 2:** Perform a Depth-First Search (DFS) starting from node A. What will be the order of visited nodes?\n", + "\n", + "**Task 3:** If you want to find the shortest path from node A to node F, which algorithm (BFS or DFS) would you choose, and why?\n", + "\n", + "Provide the order of visited nodes for Task 1 and Task 2 and justify your choice for Task 3.\n", + "\n", + "**Answer & Justification :**\n", + "\n", + "**Task 1 (BFS):** The order of visited nodes in Breadth-First Search starting from node A will be A -> B -> C -> D -> E -> F.\n", + "\n", + "**Task 2 (DFS):** The order of visited nodes in Depth-First Search starting from node A will be A -> B -> D -> E -> C -> F.\n", + "\n", + "**Task 3 (Justification):** I would choose BFS to find the shortest path from node A to node F.\n", + "\n", + "**Justification for Task 3:**\n", + "\n", + "BFS is the better choice when finding the shortest path between two nodes for the following reasons:\n", + "\n", + "1. **Optimality:** BFS guarantees that it finds the shortest path in an unweighted graph. Since the graph is unweighted (each edge has the same weight), BFS will always find the shortest path.\n", + "\n", + "2. **Completeness:** BFS is also complete, meaning it will find a path if one exists. It explores all possible paths of increasing length from the starting node until it reaches the goal node.\n", + "\n", + "3. **Efficiency for Shortest Path:** While DFS can find paths, it may not guarantee the shortest path, especially in unweighted graphs. DFS might find longer paths before shorter ones, whereas BFS explores shorter paths first.\n", + "\n", + "4. **Memory Usage:** BFS typically requires more memory as it needs to keep track of all nodes at the current level before moving to the next level. However, in most practical cases, the memory usage is manageable.\n", + "\n", + "In this scenario, if you want to find the shortest path from node A to node F, BFS will ensure that you find the shortest path, \n", + "which is A -> C -> F, with a total length of 2 edges." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Q2. In a stable matching problem, there are two groups of participants: applicants and positions. Each applicant ranks their preferred positions, and each position ranks its preferred applicants. A matching is stable if there are no pairs where both an applicant and a position prefer each other over their assigned partners.\n", + "\n", + "Consider the following scenario:\n", + "\n", + "- There are three applicants: Alice, Bob, and Carol.\n", + "- There are three positions: X, Y, and Z.\n", + "- The applicants' preferences are as follows:\n", + " - Alice prefers X > Y > Z\n", + " - Bob prefers Y > X > Z\n", + " - Carol prefers Z > X > Y\n", + "- The positions' preferences are as follows:\n", + " - X prefers Bob > Alice > Carol\n", + " - Y prefers Carol > Bob > Alice\n", + " - Z prefers Alice > Carol > Bob\n", + "\n", + "Which of the following statements is true about the stable matching in this scenario?\n", + "\n", + "A) Alice is matched with her first-choice position X.\\\n", + "B) Bob is matched with his first-choice position Y.\\\n", + "C) Carol is matched with her first-choice position Z.\\\n", + "D) The matching is not stable.\n", + "\n", + "Choose the correct option and provide justification for your choice.\n", + "\n", + "**Answer:**\n", + "\n", + "The correct option is :\\\n", + "**B) Bob is matched with his first-choice position Y**.\n", + "\n", + "**Justification:**\n", + "\n", + "To determine the stable matching in this scenario, we can use the Gale-Shapley algorithm. Let's go through the algorithm step by step:\n", + "\n", + "1. Each applicant proposes to their first-choice position:\n", + " - Alice proposes to X.\n", + " - Bob proposes to Y.\n", + " - Carol proposes to Z.\n", + "\n", + "2. Each position tentatively accepts the proposal from its most preferred applicant:\n", + " - X accepts Alice's proposal.\n", + " - Y accepts Bob's proposal.\n", + " - Z accepts Carol's proposal.\n", + "\n", + "3. If there are any rejections, applicants who were rejected propose to their next most preferred position, and positions tentatively accept the best proposals:\n", + " - No rejections occur in this case.\n", + "\n", + "4. Repeat step 3 until no rejections occur.\n", + "\n", + "The final matching is as follows:\n", + "- Alice is matched with X.\n", + "- Bob is matched with Y.\n", + "- Carol is matched with Z.\n", + "\n", + "Now, let's check the stability of this matching:\n", + "- Alice prefers X over her other options (Y, Z), and X prefers Alice over Bob, so there are no issues with Alice and X.\n", + "- Bob prefers Y over his other options (X, Z), and Y prefers Bob over Carol, so there are no issues with Bob and Y.\n", + "- Carol prefers Z over her other options (X, Y), and Z prefers Carol over Alice, so there are no issues with Carol and Z.\n", + "\n", + "Therefore, this matching is stable. Bob is matched with his first-choice position Y, which is option B." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q3. Consider a graph with the following edges:\n", + "\n", + "A -> B\\\n", + "A -> C\\\n", + "B -> D\\\n", + "B -> E\\\n", + "C -> F\n", + "\n", + "\n", + "You perform a Depth-First Search (DFS) starting from node A. In what order will you visit the nodes if you follow the standard DFS algorithm?\n", + "\n", + "A) A -> B -> D -> E -> C -> F\\\n", + "B) A -> B -> C -> D -> E -> F\\\n", + "C) A -> C -> F -> B -> D -> E\\\n", + "D) A -> C -> F -> B -> E -> D\n", + "\n", + "Choose the correct option and provide justification for your choice.\n", + "\n", + "Answer\n", + "\n", + "The correct option is \n", + "C) A -> C -> F -> B -> D -> E.\n", + "\n", + "Justification:\n", + "\n", + "In a Depth-First Search (DFS), we explore as far as possible along a branch before backtracking. Let's go step by step through the DFS traversal starting from node A:\n", + "\n", + "1. Start at node A.\n", + "2. Visit one of A's unvisited neighbors. Let's choose C.\n", + "3. Move to node C.\n", + "4. Visit one of C's unvisited neighbors. Let's choose F.\n", + "5. Move to node F.\n", + "6. F has no unvisited neighbors, so backtrack to C.\n", + "7. C has another unvisited neighbor, which is B.\n", + "8. Move to node B.\n", + "9. Visit one of B's unvisited neighbors. Let's choose D.\n", + "10. Move to node D.\n", + "11. D has no unvisited neighbors, so backtrack to B.\n", + "12. Visit B's last unvisited neighbor, which is E.\n", + "13. Move to node E.\n", + "14. E has no unvisited neighbors, so backtrack to B.\n", + "15. B has no other unvisited neighbors, so backtrack to A.\n", + "16. A has one more unvisited neighbor, which is E, but we already visited E earlier.\n", + "\n", + "So, the traversal order is A -> C -> F -> B -> D -> E, which matches option C. This is the standard DFS order starting from node A in the given graph." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q4. Consider the following two functions, f(n) and g(n), where n is a positive integer:\n", + "\n", + "f(n) = 5n^2 + 3n + 7\\\n", + "g(n) = 2n^3 + 4n + 2\n", + "\n", + "Which of the following statements about the Big O notation of these functions is correct?\n", + "\n", + "A) f(n) = O(n^2) and g(n) = O(n^3)\\\n", + "B) f(n) = O(n^3) and g(n) = O(n^2)\\\n", + "C) Both f(n) and g(n) are O(n^2)\\\n", + "D) Both f(n) and g(n) are O(n^3)\n", + "\n", + "Choose the correct option and provide justification.\n", + "\n", + "Answer:\n", + "\n", + "The correct option is **A) f(n) = O(n^2) and g(n) = O(n^3)**.\n", + "\n", + "Justification:\n", + "\n", + "To determine the Big O notation of these functions, we need to find the highest power of n that dominates the growth of each function as n becomes large. Let's analyze each function separately:\n", + "\n", + "1. **Function f(n)**:\n", + " - f(n) = 5n^2 + 3n + 7\n", + " - As n becomes large, the term with the highest power of n that dominates the growth is 5n^2.\n", + " - Therefore, f(n) = O(n^2).\n", + "\n", + "2. **Function g(n)**:\n", + " - g(n) = 2n^3 + 4n + 2\n", + " - As n becomes large, the term with the highest power of n that dominates the growth is 2n^3.\n", + " - Therefore, g(n) = O(n^3).\n", + "\n", + "So, the correct answer is: A) f(n) = O(n^2) and g(n) = O(n^3). These statements correctly represent the Big O notation of the given functions based on their dominant growth terms." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q5. In a Chess Championship, there are two grandmasters, Grandmaster A and Grandmaster B. Each grandmaster has a set of chess openings and tactics in their repertoire, and they want to devise a winning strategy by selecting the best openings and tactics for each game. The performance of each grandmaster in the championship is solely based on the effectiveness of their chosen openings and tactics.\n", + "\n", + "To determine the winner of the championship, the following rules apply:\n", + "- If Grandmaster A selects an opening/tactic for a game, Grandmaster B can choose a counteropening/counter-tactic.\n", + "- If Grandmaster B selects an opening/tactic, Grandmaster A can choose a counteropening/counter-tactic.\n", + "\n", + "A pair of strategies (S1, S2) is considered stable if neither Grandmaster can unilaterally change their own strategy to win more games. In other words, there should be no strategy (S1', S2) for Grandmaster A or (S1, S2') for Grandmaster B that would allow them to win more games than with the original strategy pair (S1, S2).\n", + "\n", + "For the given set of chess openings and tactics, is there always a stable pair of strategies for Grandmaster A and Grandmaster B? Resolve this question by doing one of the following two things:\n", + "- Provide an algorithm that, for any set of openings and tactics, produces a stable pair of strategies.\n", + "OR\n", + "- Give an example of a set of openings and tactics for which there is no stable pair of strategies.\n", + "\n", + "\n", + "Answer:\n", + "\n", + "There is not always a stable pair of strategies for Grandmaster A and Grandmaster B in this scenario.\n", + "\n", + "Explanation:\n", + "\n", + "The lack of a stable pair of strategies arises from the competitive nature of chess and the ability of each grandmaster to adjust their tactics based on the opponent's choices. Here's an explanation:\n", + "\n", + "- In chess, the choice of opening and tactics is crucial to the outcome of the game.\n", + "- Each grandmaster wants to maximize their chances of winning, and they can counter the opponent's strategy by choosing appropriate counteropenings and countertactics.\n", + "- If Grandmaster A selects an opening/tactic, Grandmaster B can choose a counteropening/counter-tactic to gain an advantage.\n", + "- Similarly, if Grandmaster B selects an opening/tactic, Grandmaster A can counter it to gain an advantage.\n", + "\n", + "This competitive nature means that there is no fixed strategy that both grandmasters can adopt that will ensure a stable outcome. Each grandmaster will constantly adapt to the opponent's choices, making it impossible to find a strategy pair (S1, S2) that remains stable throughout the championship.\n", + "\n", + "Conclusion:\n", + "\n", + "In the context of a chess championship, there is not always a stable pair of strategies for Grandmaster A and Grandmaster B. The dynamic and competitive nature of chess openings and tactics allows each player to adjust their strategy to counter the opponent's choices, preventing the existence of a stable pair of strategies." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q6. You are tasked with constructing a garden path using a series of rectangular paving stones. Each stone is placed end-to-end, and the number of stones in each row is bounded by a constant 'c.' Your goal is to create the path with a limited number of stones, at most 'n' stones, while minimizing the length of each stone, represented by a function f(n). Explain how to construct such a path, and analyze the space complexity of your method.\n", + "\n", + "Answer\n", + "\n", + "To construct the garden path with a limited number of stones and minimize the length of each stone, we can follow the approach outlined below:\n", + "\n", + "1. **Determining the Number of Rows (R):**\n", + " - Suppose we need n stones to create the garden path.\n", + " - We aim to determine the number of rows (R) required to obtain n stones, with each row having a limited number of stones denoted as 'c.'\n", + "\n", + "2. **Construction Plan:**\n", + " - Create a construction plan that describes how to build the garden path using paving stones.\n", + " - The plan will consist of rows where each row specifies the number of stones used for that row.\n", + "\n", + "3. **Building the Rows:**\n", + " - In the construction plan, iterate for each row (i) from 1 to R.\n", + " - For each row, ensure that the number of stones used does not exceed the limit 'c.'\n", + " - Distribute the stones as evenly as possible across the row while respecting the limit 'c.'\n", + "\n", + "4. **Space Complexity Analysis:**\n", + " - Analyze the space complexity of the construction plan.\n", + " - The nested loops have lengths bounded by constants, ensuring that the space consumed by the loops is constant.\n", + "\n", + "5. **Space for Rows:**\n", + " - Each row in the construction plan represents the space required for the stones in that row.\n", + " - The space required for each row is at most 'c.'\n", + "\n", + "6. **Total Space S:**\n", + " - Calculate the total space required by the construction plan (S), which is the sum of the constant space (c1) and the space for all the rows (c).\n", + "\n", + "7. **Bounding Rows with n:**\n", + " - Establish a relationship between the number of stones required to create the garden path (n) and the number of rows (R).\n", + " - Use the fact that n is at least the sum of the first R natural numbers (1 + 2 + ... + R), which can be expressed as ½ R(R - 1).\n", + "\n", + "8. **Bounding R in terms of n:**\n", + " - Manipulate the inequality to show that ½ (R-1)^2 <= n.\n", + " - Solve for R, yielding R <= (-1 + √(1 + 8n)) / 2.\n", + "\n", + "9. **Final Bound on Space S:**\n", + " - Plug the bound on R into the space complexity equation S to determine that F(n) (the space required for building the path) is bounded by a constant.\n", + "\n", + "Justification:\n", + "\n", + "The justification for this approach lies in the careful construction of the garden path using nested loops, ensuring that the space used to build each row is bounded by a constant and that the overall space complexity is constant regardless of the number of stones (n). By following this method, we achieve an efficient way to use paving stones with minimal space growth, represented by the function f(n), while creating the garden path. The final bound of a constant space complexity demonstrates that the space required for building the path is asymptotically efficient and minimizes space growth as much as possible." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q7. Consider two sorting algorithms, Algorithm X and Algorithm Y, each designed to sort a list of integers. The time complexity of Algorithm X is O(n^2), while the time complexity of Algorithm Y is O(n*log(n)). Which of the following statements about the performance of these algorithms is **true**, and what is the approximate crossover point for the input size n when the two algorithms have similar runtimes?\n", + "\n", + "**Options:**\n", + "\n", + "A. Algorithm X is always faster than Algorithm Y for any input size n.\n", + "\n", + "B. Algorithm Y is always faster than Algorithm X for any input size n.\n", + "\n", + "C. Algorithm X is faster than Algorithm Y for small input sizes, and Algorithm Y is faster for larger input sizes.\n", + "\n", + "D. Algorithm Y is faster than Algorithm X for small input sizes, and Algorithm X is faster for larger input sizes.\n", + "\n", + "**Correct Answer:**\n", + "\n", + "C. Algorithm X is faster than Algorithm Y for small input sizes, and Algorithm Y is faster for larger input sizes.\n", + "\n", + "**Justification:**\n", + "\n", + "Let's analyze each option and compare them to the correct answer (C):\n", + "\n", + "A. **False**: Algorithm X has a worst-case time complexity of O(n^2), which means it can be slower than Algorithm Y for larger input sizes.\n", + "\n", + "B. **False**: Algorithm Y has a worst-case time complexity of O(n*log(n)), which means it can be slower than Algorithm X for smaller input sizes.\n", + "\n", + "C. **Correct**: This statement is true. Algorithm X, with a quadratic time complexity, is generally faster for small input sizes because the quadratic factor dominates the runtime. However, as the input size n increases, Algorithm Y's superior logarithmic factor becomes dominant, making it faster for larger input sizes.\n", + "\n", + "D. **False**: This statement is not true. Algorithm Y's performance advantage is for larger input sizes, not smaller ones.\n", + "\n", + "To find the approximate crossover point, we would need to equate the two time complexities and solve for n:\n", + "\n", + "O(n^2) = O(n*log(n))\n", + "\n", + "This equation does not have a simple algebraic solution. To find the crossover point precisely, numerical methods or approximation techniques would be needed. However, it's commonly observed that Algorithm X performs better for smaller input sizes, and Algorithm Y outperforms it for larger input sizes. The actual crossover point may vary depending on specific implementations and hardware." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q8. You are using the Depth-First Search (DFS) algorithm to traverse a graph represented as an adjacency list. Which of the following statements about DFS is **correct**?\n", + "\n", + "**Options:**\n", + "\n", + "A. DFS can find the shortest path in a weighted graph.\n", + "\n", + "B. DFS can be implemented using a queue data structure.\n", + "\n", + "C. DFS guarantees that it will visit all nodes in a disconnected graph.\n", + "\n", + "D. DFS may result in a stack overflow error for very deep graphs.\n", + "\n", + "**Correct Answer:**\n", + "\n", + "D. DFS may result in a stack overflow error for very deep graphs.\n", + "\n", + "**Justification:**\n", + "\n", + "Let's analyze each option and compare them to the correct answer (D):\n", + "\n", + "A. **False**: DFS is not designed to find the shortest path in a weighted graph. It explores a path as deeply as possible before backtracking, and therefore, it cannot guarantee finding the shortest path in weighted graphs. Algorithms like Dijkstra's or Bellman-Ford are better suited for this purpose.\n", + "\n", + "B. **False**: DFS is typically implemented using a stack (or recursion), not a queue. It explores as deeply as possible along a branch before backtracking. Breadth-First Search (BFS), on the other hand, uses a queue data structure to explore level by level.\n", + "\n", + "C. **False**: DFS does not guarantee visiting all nodes in a disconnected graph. It depends on the starting point and whether separate DFS calls are made from different components. To visit all nodes in a disconnected graph, you need to initiate separate DFS calls from each unvisited component.\n", + "\n", + "D. **Correct**: DFS uses a stack (or recursion) for traversal. If the graph is very deep, meaning it has a long path before reaching leaf nodes, DFS may result in a stack overflow error. This occurs when the call stack becomes too deep due to the recursive nature of DFS. In such cases, you might consider using an iterative approach or optimizing your code to prevent stack overflow.\n", + "\n", + "So, the correct answer is option D because DFS can encounter stack overflow errors for very deep graphs, distinguishing it from the other options." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q9. You are given a graph represented as an adjacency list. You need to perform a Breadth-First Search (BFS) traversal starting from a given node. Which of the following statements about BFS is **correct**?\n", + "\n", + "**Options:**\n", + "\n", + "A. BFS can be implemented using recursion.\n", + "\n", + "B. BFS can find the shortest path in an unweighted graph.\n", + "\n", + "C. BFS is not suitable for finding connected components in a graph.\n", + "\n", + "D. BFS may not visit all nodes in a disconnected graph.\n", + "\n", + "Correct Answer:\n", + "\n", + "B. BFS can find the shortest path in an unweighted graph.\n", + "\n", + "Justification:\n", + "\n", + "Breadth-First Search (BFS) is a graph traversal algorithm that explores all the vertices of a graph in breadth-first order. Here's the justification for the correct answer:\n", + "\n", + "A. **False**: BFS is typically implemented using a queue data structure and iterative processing. It is not implemented using recursion because recursion does not naturally fit the breadth-first traversal order.\n", + "\n", + "B. **Correct**: BFS is capable of finding the shortest path in an unweighted graph. Since BFS explores nodes level by level, the first time a node is visited is when the shortest path to it is discovered. This property makes BFS ideal for finding the shortest path in unweighted graphs.\n", + "\n", + "C. **False**: BFS is actually quite suitable for finding connected components in a graph. By performing multiple BFS traversals from different starting nodes, you can identify and label the connected components efficiently.\n", + "\n", + "D. **False**: BFS guarantees that it will visit all nodes in a connected component of a graph. However, in a disconnected graph, if you start BFS from one component and do not initiate a new BFS from another component, it may not visit all nodes. To visit all nodes in a disconnected graph, you would need to run BFS from each unvisited node separately.\n", + "\n", + "So, the correct answer is option B because BFS is commonly used to find the shortest path in unweighted graphs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q10. You are designing an algorithm to search for a specific element in a sorted array of n integers. You have two different algorithms to choose from:\n", + "\n", + "Algorithm X: Performs a linear search through the array, checking each element one by one until it finds the target element.\n", + "\n", + "Algorithm Y: Performs a binary search on the sorted array to find the target element.\n", + "\n", + "The time complexities of these algorithms are as follows:\n", + "\n", + "- Algorithm X: O(n)\n", + "- Algorithm Y: O(log n)\n", + "\n", + "You are given a sorted array of 1 million integers, and you need to find a specific target integer. Which algorithm would you choose, and why?\n", + "\n", + "A) Algorithm X because it has a lower Big O notation.\n", + "B) Algorithm Y because it has a lower Big O notation.\n", + "C) It depends on other factors, such as the specific target element and the available hardware.\n", + "D) Neither algorithm is suitable for searching in such a large array.\n", + "\n", + "Choose the correct option and provide justification for your choice.\n", + "\n", + "**Answer**\n", + "\n", + "The correct option is **B) Algorithm Y because it has a lower Big O notation.**\n", + "\n", + "**Justification:**\n", + "\n", + "In this scenario, the choice between Algorithm X and Algorithm Y depends on the efficiency of the algorithms for the given input size and the nature of the search. Here's why Algorithm Y (binary search) is a better choice:\n", + "\n", + "1. **Comparison of Time Complexities:** \n", + " - Algorithm X has a time complexity of O(n), which means it may need to check all 1 million elements in the worst case.\n", + " - Algorithm Y has a time complexity of O(log n), which means it divides the search space in half with each comparison.\n", + "\n", + "2. **Efficiency for Large Arrays:**\n", + " - For a sorted array of 1 million elements, Algorithm X could potentially require up to 1 million comparisons.\n", + " - Algorithm Y, on the other hand, would require at most log2(1,000,000) ≈ 20 comparisons. \n", + " - Algorithm Y's performance is significantly better for large arrays.\n", + "\n", + "3. **Scalability:**\n", + " - As the size of the array grows, Algorithm Y's advantage becomes even more significant. It scales logarithmically, making it suitable for very large datasets.\n", + "\n", + "4. **Practical Considerations:** \n", + " - While Big O notation provides a theoretical measure of algorithm efficiency, real-world performance also depends on factors such as hardware and the specific target element.\n", + "\n", + "In this case, Algorithm Y with a time complexity of O(log n) is the better choice for searching in a sorted array of 1 million integers because it is significantly more efficient and performs far fewer comparisons compared to Algorithm X with a time complexity of O(n)." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002795957_Lokesh_jeswani/readme.md.txt b/Submissions/002795957_Lokesh_jeswani/readme.md.txt new file mode 100644 index 0000000..e2f9de5 --- /dev/null +++ b/Submissions/002795957_Lokesh_jeswani/readme.md.txt @@ -0,0 +1,8 @@ +Assignment_1-INFO_6205-Program_Structure_and_Algorithms + +Created 10 qustion on following topics: +Big-O notation, +DFS(Depth-First Search), +BFS(Breadth-First Search) + +The above 10 question are provided with solution and its justification. \ No newline at end of file diff --git a/Submissions/002799697_Yanyan_Chen/002799697_Yanyan_Chen_Assignment1.ipynb b/Submissions/002799697_Yanyan_Chen/002799697_Yanyan_Chen_Assignment1.ipynb new file mode 100644 index 0000000..e8e37b7 --- /dev/null +++ b/Submissions/002799697_Yanyan_Chen/002799697_Yanyan_Chen_Assignment1.ipynb @@ -0,0 +1,898 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# INFO 6205 – Program Structure and Algorithms Assignment 1 Solutions\n", + "## Name: Yanyan Chen\n", + "## NUID: 002799697\n", + "## Date: 09/24/2023\n", + "***Note: that there are some snippets of code that are pseudo-code, to better explain and answer questions, and don't really run***" + ], + "metadata": { + "id": "MEiyuZw68mET" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Q1:**\n", + "Arrange the following functions in increasing order of growth as n approaches infinity:\n", + "* $ log_3{(n^4)} $\n", + "* $ 2^n+3^n $\n", + "* $ 0.5^n+12 $\n", + "* $ log(n)+n^\\frac{1}{2} $\n", + "* $ log(log_2(n)) $\n", + "* $ log_3(n^5) $\n", + "* $ (n+1)!+2^n $\n", + "* $ n^\\frac{3}{2} $\n", + "* $ 10^n $\n", + "\n", + "###**Answer:**\n", + "Sort the given functions by slowest growth to fastest growth and analyze each function briefly.\n", + "\n", + "#### **Function Analysis:**\n", + "\n", + "**1. $ 0.5^n+12 $**\n", + "\n", + "$0.5^n$ is an exponentially decreasing term. As n increases, it gradually decreases to 0, eventually dominated by the constant 12, making this the slowest growing function. It is $O(1)$.\n", + "\n", + "**2. $ log(log_2(n)) $**\n", + "\n", + "This is a double logarithm function, growing very slowly, even slower than a single logarithm function. It is $O(log(log n))$.\n", + "\n", + "**3. $ log_3(n^5) $ and $ log_3{(n^4)} $**\n", + "\n", + "These two functions can be simplified to $4 log_2{n}$ and $5 log_3{n}$ respectively. Despite the constant multipliers, their growth rates remain $O(log{n})$\n", + "\n", + "**4. $ log(n)+n^\\frac{1}{2} $**\n", + "\n", + "This function's growth is dominated by $ n^\\frac{1}{2} $ (the square root of n). Thus, it grows faster than the preceding logarithmic functions, but still slower than linear and polynomial functions. It is $O(n^\\frac{1}{2})$.\n", + "\n", + "\n", + "**5. $ n^\\frac{3}{2} $**\n", + "\n", + "This is a polynomial function, which grows faster than all the preceding functions as n increases. It is $O(n^\\frac{3}{2})$.\n", + "\n", + "**6. $ 2^n+3^n $**\n", + "\n", + "This function's growth is dominated by the $ 3^n $ term, representing exponential growth, which is very rapid.\n", + "\n", + "**7. $ 10^n $**\n", + "\n", + "Also an exponential growth function, but with a base of 10, it grows faster than $ 2^n+3^n $.\n", + "\n", + "**8. $ (n+1)!+2^n $**\n", + "\n", + "This function's growth is dominated by $ (n+1)! $ (the factorial), which grows extremely fast and is the fastest growing function among all listed.\n", + "\n", + "#### **Final Ordering**\n", + "Based on the analysis above, the order from the slowest to fastest growing functions as\n", + "\n", + "\n", + "1. $ 0.5^n+12 $\n", + "2. $ log(log_2(n)) $\n", + "3. $ log_3(n^4) $\n", + "3. $ log_3{(n^5)} $\n", + "5. $ log(n)+n^\\frac{1}{2} $\n", + "6. $ n^\\frac{3}{2} $\n", + "7. $ 2^n+3^n $\n", + "8. $ 10^n $\n", + "9. $ (n+1)!+2^n $" + ], + "metadata": { + "id": "OXilDH8TGxBJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Q2**:\n", + "\n", + "consider two functions $ a(n)$ and $b(n)$ such that $a(n)=O(b(n))$. Analyze the following statements for truth or falsity, providing proofs or counterexamples as needed:\n", + "\n", + "1. $a(n)=O(a(n/4))$\n", + "2. $a(n)=Θ(a(3n))$\n", + "3. $a(n)=O(b(n))$ Implies $b(n)=Ω(a(n))$\n", + "\n", + "### **Answer:**\n", + "\n", + "#### **Analysis:**\n", + "\n", + "**1. $a(n)=O(a(n/4))$**\n", + "\n", + "This statement suggests that $a(n)$ is bounded above by $a(n/4)$ up to a constant factor, which doesn't hold in general. For a counter example, consider\n", + "$a(n)=4^n$ . Here, $a(n/4)=4^\\frac{n}{4}$ and $a(n)=4^n $, which clearly shows that $a(n)$ is not bounded by $a(n/4)$ as n grows.\n", + "\n", + "Counter example: $ a(n)=4^n $.\n", + "\n", + "**2. $a(n)=Θ(a(3n))$**\n", + "\n", + "This statement suggests that $a(n)$ and $a(3n)$ grow at the same rate, up to constant factors. This is generally false as well. For instance, consider $a(n)=2^n$ . Here $a(n)=2^n$ and $a(3n)=2^3n$, which simplifies to $a(3n)=(2^n)^3$. Clearly, $a(3n)$ grows much faster than $a(n)$.\n", + "\n", + "Counter example: $a(n)=2^n$.\n", + "\n", + "**3. $a(n)=O(b(n))$ Implies $b(n)=Ω(a(n))$**\n", + "\n", + "This statement is true by definition, similar to the corresponding statements in the previous questions. If $a(n)=O(b(n))$, this means there exists a constant $C$ and a value $n_0$ such that $0≤a(n)≤C$. $b(n)$ for all $n>n_0$. This is exactly the definition of $b(n)=Ω(a(n))$, which means that $b(n)$ is a lower bound for $a(n)$ up to a constant factor.\n", + "\n", + "Proof:\n", + "From the definition of Big O notation, $a(n)=O(b(n))$ if there exist constants\n", + "$C>0$ and $n_0$ such that for all $n>n_0, a(n)≤C⋅b(n)$.\n", + "This implies that $b(n)≥(1/C)⋅a(n)$ for all $n>n_0$, which is exactly the definition of Big Omega: $ b(n)=Ω(a(n))$." + ], + "metadata": { + "id": "aZaOZoXwoYgu" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Q3:**\n", + "\n", + "Problem Statement:\n", + "\n", + "In the city of Algorithmville, there are $x$ tech firms, each with a certain number of job openings for software developers. In the same city, $n$ software developers are seeking employment, each interested in joining one of the tech firms. Each tech firm has a ranking of developers based on their coding skills, work experience, and portfolio. Each developer also has a ranking of tech firms based on the work culture, projects, and salary the firms offer. We assume that there are more software developers seeking employment than there are job openings across $x$ tech firms.\n", + "\n", + "The goal is to find a method of assigning each developer to at most one tech firm, in such a way that all the job openings in a particular firm are filled (Some developers will not secure a job as the number of developers exceeds the number of job openings).\n", + "\n", + "An assignment of a developer to a particular tech firm is termed stable if neither of the conditions arise:\n", + "\n", + "1. There are developers $d1$ and $d2$ and tech firm $f$, such that:\n", + "* $d1$ is assigned to $f$,\n", + "* $d2$ is unassigned, and\n", + "* $f$ prefers $d2$ to $d1$ based on their rankings.\n", + "\n", + "2. There are developers $d1$ and $d2$ and tech firms $f1$ and $f2$, such that:\n", + "* $d1$ is assigned to $f1$,\n", + "* $d2$ is assigned to $f2$,\n", + "* $f1$ prefers $d2$ to $d1$, and\n", + "* $d2$ prefers $f1$ to $f2$.\n", + "\n", + "Devise a stable matching algorithm to solve this problem, and prove its correctness.\n", + "\n", + "###**Answer:**\n", + "\n", + "**Solution Framework:**\n", + "\n", + "The problem can be addressed using a variation of the Gale-Shapley algorithm. Here’s how you might structure the algorithm in **pseudocode**:\n", + "\n", + "*** *Attention: it's pseudocode for better explanation. It's not runnable.***" + ], + "metadata": { + "id": "j2w4dQWE3soy" + } + }, + { + "cell_type": "code", + "source": [ + "function StableMatching(Developers, Firms):\n", + " while there exists an unassigned developer d who has not proposed to every firm:\n", + " let f be the highest-ranked firm on d’s list to which d has not yet proposed\n", + " d proposes to f\n", + " if f has available positions:\n", + " f temporarily hires d\n", + " else if f prefers d to one of its current hires d_old:\n", + " f fires d_old and hires d\n", + " d_old becomes unassigned\n", + " end if\n", + " end while\n", + " return the current assignment\n", + "\n", + "Developers = list of developers with their preferences\n", + "Firms = list of firms with their preferences and job openings\n", + "assignment = StableMatching(Developers, Firms)\n" + ], + "metadata": { + "id": "2H96OR187pqZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Proof of Stability:**\n", + "1. **Unassigned Preference Condition:** Similar to the original proof, the proposal process ensures that there is no developer unassigned whom a firm prefers over a currently assigned developer, given that developers propose in order of their preference, and firms always replace less preferred developers with more preferred developers.\n", + "2. **Mutual Preference Condition:** Similarly, there cannot be developers and firms as described that would cause an instability as the algorithm ensures every developer proposes to firms in their order of preference and firms accept developers based on their preference until the positions are filled.\n", + "\n", + "**Example:**\n", + "\n", + "Suppose there are three firms: Alpha, Beta, and Gamma, with 2, 1, and 1 job openings respectively. There are five developers: Dave, Eve, Mike, Nick, and Olivia. After applying the StableMatching algorithm, we can obtain a stable matching where all job openings are filled and no unstable conditions arise.\n", + "\n", + "**Code Explanations:**\n", + "\n", + "The function StableMatching takes two arguments: a list of Developers and a list of Firms. Each developer and each firm have a list of preferences.\n", + "The while loop continues until every unassigned developer has proposed to every firm on their list.\n", + "Inside the loop, a developer d proposes to a firm f, and f either accepts the proposal (temporarily if there are still open positions, or permanently by replacing a less preferred developer) or rejects it.\n", + "The loop ends when there are no more proposals to be made, and the function returns the current assignment of developers to firms.\n", + "\n", + "\n" + ], + "metadata": { + "id": "tnL8DQgc8z4W" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Q4:**\n", + "One algorithm requires $20 log_{10} (n)$ milliseconds, and another algorithm requires $n^{0.2}$ milliseconds.\n", + "\n", + "Which one is asymptotically faster? What is the cross-over value of $n$?\n", + "\n", + "### **Solution:**\n", + "\n", + "We are given two algorithms with their time complexities in milliseconds:\n", + "\n", + "Algorithm 1: $20 log_{10} (n)$\n", + "Algorithm 2: $n^{0.2}$\n", + "\n", + "As $n$ approaches infinity, logarithmic functions grow slower than polynomial functions. Therefore, algorithm 1 with time complexity $20 log_{10} (n)$ is asymptotically faster than algorithm 2 with time complexity $n^{0.2}$.\n", + "\n", + "To find the cross-over point, we need to set the expressions equal to each other and solve for n:\n", + "$$20 log_{10} (n)$$\n", + "\n", + "To solve this equation, it might be easier to use a numerical method or a calculator or software. One way to do this in a programming language like Python is to use a simple iterative method or use a library like sympy.\n", + "\n", + "Here's a python code snippet using sympy to solve the equation:" + ], + "metadata": { + "id": "eUeQSL1UBfFe" + } + }, + { + "cell_type": "code", + "source": [ + "from sympy import Eq, log, solve, symbols\n", + "\n", + "n = symbols('n', real=True, positive=True) # Define n as a symbol\n", + "\n", + "# Define the equation 20*log(n, 10) = n**0.2\n", + "equation = Eq(20 * log(n, 10), n**0.2)\n", + "\n", + "# Solve for n\n", + "cross_over_value = solve(equation, n)\n", + "print(cross_over_value)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RwpTnFv3Dt1c", + "outputId": "f290f75a-a680-4044-b9e4-8386ebf7bc0d" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[1.12510424016175, 756938225911.552]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "In the provided code snippet, the solution to the equation $20 log_{10} (n) = n^{0.2}$ which represents the cross-over point at which both algorithms perform equally in terms of time complexity. By running the Python code, it should obtain a numerical value for $n$ that satisfies this equation.\n", + "\n", + "The solve function from the sympy library is used to solve the equation for\n", + "$n$, and the result will be printed to the console.\n", + "\n", + "It's necessary to mention that the actual numerical solution may not be an integer, and depending on the context, the nearest integer value for $n$ need to be considered." + ], + "metadata": { + "id": "xepXik9FE5No" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Q5:**\n", + "You are constructing a novel display stand for a tech exhibit, where each level of the stand is comprised of LED panels. The design of the stand is such that the total number of LED panels on each level is the sum of the number of panels on the current level and the previous level. During the creation of the stand, you notice an asymptotic behavior worth analyzing. Assume for this analysis that each level has a total number of LED panels bounded by a constant $p$, and the stand will consist of at most $q$ LED panels. Determine how to construct such a stand using LED panels, with each panel having an area of $h(q)$, where $h(q)$ is a function that grows as slowly as possible.\n", + "\n", + "### **Solution:**\n", + "* Let $l_i$ denote the number of LED panels on level $i$ (for $i=1,2,3,…$).\n", + "* Let $U_i$ denote the total number of LED panels used up to and including level $i$ (so $U_i=l_1+l_2+l_3+...+l_i$)\n", + "\n", + "From the problem statement, we have the relation $l_i = l_{i-1} + l_{i-2}$ for $i≥3 $, with base cases $l_1$ and $l_2$ to be determined.\n", + "\n", + "The requirement that the total number of LED panels used is at most $q$ gives us the inequality:\n", + "$$U_i=l_1+l_2+...+l_i≤q$$\n", + "\n", + "We're also given that $l_i≤p$ for some constant $p$, and we are to design the stand such that each LED panel has an area of $h(q)$, with $h(q)$ growing as slowly as possible.\n", + "\n", + "As before, an initial guess might be to start with $l_1=1$ and $l_2=1$ to minimize the number of LED panels used initially.\n", + "\n", + "However, to satisfy the boundedness condition $l_i≤p$, a more refined approach might be needed. One potential strategy could be to reset the number of LED panels to 1 whenever it exceeds $p$, but this may not minimize $h(q)$.\n", + "\n", + "A programmatic solution could potentially involve an iterative algorithm to construct the stand level by level, checking at each step whether the conditions $U_i≤p$ and $l_i≤p$ are satisfied, and adjusting the values of $l_i$ accordingly. This way, you could explore various configurations to find the one that minimizes $h(q)$ while satisfying the constraints.\n", + "\n", + "Here’s a simplified example in Python, which is more of a brute force approach and may not find the optimal solution:" + ], + "metadata": { + "id": "hhHrt6_jHWMs" + } + }, + { + "cell_type": "code", + "source": [ + "p = 10 # Replace with the actual bound\n", + "q = 100 # Replace with the actual total LED panel limit\n", + "\n", + "def construct_stand():\n", + " l = [1, 1] # Starting with 1 panel on each of the first two levels\n", + " U = sum(l)\n", + " i = 3\n", + " while U + l[-1] + l[-2] <= q and l[-1] + l[-2] <= p:\n", + " next_level = l[-1] + l[-2]\n", + " l.append(next_level)\n", + " U += next_level\n", + " i += 1\n", + " if next_level > p: # Resetting the number of panels to 1 if it exceeds p\n", + " l[-1] = 1\n", + "\n", + " h_q = (q - U) / (q - len(l)) if len(l) < q else 0 # Calculating h(q)\n", + " return l, h_q\n", + "\n", + "# Calling the function\n", + "levels, h_q = construct_stand()\n", + "print(levels)\n", + "print(h_q)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TKD9hUtcPraU", + "outputId": "478e0b1e-f46e-4d93-c47c-fdff507959f3" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[1, 1, 2, 3, 5, 8]\n", + "0.851063829787234\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "In this code snippet:\n", + "\n", + "1. Define p and q as the given constants.\n", + "2. The construct_stand function initializes the stand with 1 LED panel on each of the first two levels.\n", + "3. It then iteratively constructs each subsequent level, checking the conditions at each step.\n", + "4. If the number of panels on a level exceeds p, it resets the number of panels on that level to 1.\n", + "5. It calculates a simplistic h(q) based on the remaining number of panels that can be used.\n", + "6. The function returns the configuration of levels and the calculated h(q)." + ], + "metadata": { + "id": "ENvpfTVZPuHS" + } + }, + { + "cell_type": "markdown", + "source": [ + "In order to approach this problem in a more optimized manner and align with the earlier explanation, it might be beneficial to consider a dynamic programming approach. Dynamic programming can help in keeping track of the optimal solutions to sub-problems to avoid redundant computations.\n", + "\n", + "The optimization goal here is to minimize $h(q)$ while ensuring that the total number of LED panels does not exceed $q$ and the number of LED panels on each level does not exceed $p$.\n", + "\n", + "The core idea can be to work backwards: start with the total number of panels $q$, and distribute them across the levels while adhering to the constraints. The following code snippet is a simplified illustrative attempt, rather than a fully optimized solution:" + ], + "metadata": { + "id": "9M1Kh9LAR3vb" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "\n", + "# Set the constants p and q\n", + "p = 10\n", + "q = 100\n", + "\n", + "# Initialize a memoization table to store the minimum h(q) for each level and remaining panels\n", + "memo = np.full((q+1, q+1), float('inf'))\n", + "\n", + "# Base case: if there are no remaining panels, h(q) is 0\n", + "memo[0, :] = 0\n", + "\n", + "def h(q_remaining, panels_last_level, panels_second_last_level):\n", + " # If we've already computed the minimum h(q) for this sub-problem, return it\n", + " if memo[q_remaining, panels_last_level] != float('inf'):\n", + " return memo[q_remaining, panels_last_level]\n", + "\n", + " # If there are no remaining panels, h(q) is 0\n", + " if q_remaining == 0:\n", + " return 0\n", + "\n", + " # Calculate the panels for the current level based on the previous two levels\n", + " panels_current_level = panels_last_level + panels_second_last_level\n", + "\n", + " # If the panels for the current level exceed p or q_remaining, reset the panels for the current level to 1\n", + " if panels_current_level > p or panels_current_level > q_remaining:\n", + " panels_current_level = 1\n", + "\n", + " # Update q_remaining for the next sub-problem\n", + " q_remaining_next = q_remaining - panels_current_level\n", + "\n", + " # Recur for the next sub-problem\n", + " h_q_next = h(q_remaining_next, panels_current_level, panels_last_level)\n", + "\n", + " # Update the memoization table with the minimum h(q) for this sub-problem\n", + " memo[q_remaining, panels_last_level] = min(memo[q_remaining, panels_last_level], h_q_next + panels_current_level)\n", + "\n", + " return memo[q_remaining, panels_last_level]\n", + "\n", + "# Call the function with initial values\n", + "h_initial = h(q, 1, 1)\n", + "\n", + "print(f'Minimum h(q): {h_initial}')\n" + ], + "metadata": { + "id": "yP5ICruHSD1j" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "1. The constants p and q are set.\n", + "2. A memoization table memo is initialized to store the minimum $h(q)$ for each level and remaining panels, with initial values set to inf.\n", + "3. The h function defines the recursive sub-problems, taking the remaining number of panels q_remaining, and the number of panels on the last two levels panels_last_level and panels_second_last_level as arguments.\n", + "4. The function first checks the memoization table to see if the minimum $h(q)$ for this sub-problem has already been computed.\n", + "5. It then calculates the number of panels for the current level based on the previous two levels.\n", + "6. If the number of panels for the current level exceeds p or q_remaining, it resets the number of panels for the current level to 1.\n", + "7. It recurs for the next sub-problem, with updated values for q_remaining, panels_last_level, and panels_second_last_level.\n", + "8. It updates the memoization table with the minimum $h(q)$ for this sub-problem.\n", + "9. Finally, the function returns the minimum $h(q)$ for this sub-problem, and the h function is called with initial values to compute the minimum $h(q)$.\n", + "\n", + "This attempt is simplified and might not fully optimize $h(q)$ or handle all cases, but illustrates a more structured approach towards solving the problem programmatically." + ], + "metadata": { + "id": "j_7REELpSP-N" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Q6:**\n", + "One algorithm requires $2^n$ operations and another algorithm requires $n^3$ perations to perform a task. Which one grows asymptotically faster? That is, which grows faster as $n$ gets large? What is the cross-over value of $n$ (the value at which the curves intersect)? Provide a graphical representation and code to support your explanation.\n", + "\n", + "### **Solution:**\n", + "1. Asymptotic Behavior:\n", + "* The function $f(n)=2^n$ grows exponentially as $n$ increases.\n", + "* The function $g(n)=n^3$ grows polynomially as $n$ increases.\n", + "\n", + "Between the two, $2^n$ grows faster asymptotically than $n^3$.\n", + "\n", + "2. Cross-over point:\n", + "The cross-over point is the value of $n$ at which both functions yield the same result. We can find this by setting them equal to each other and solving for $n$:\n", + "$2^n=n^3$\n", + "\n", + "For a graphical representation and to find the cross-over point numerically, you can use Python and matplotlib:" + ], + "metadata": { + "id": "HyGKtsccVNEU" + } + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "n = np.linspace(1, 10, 400) # Adjust this range as needed\n", + "exp_n = 2**n\n", + "poly_n = n**3\n", + "\n", + "# Plot the functions\n", + "plt.plot(n, exp_n, label='2^n')\n", + "plt.plot(n, poly_n, label='n^3')\n", + "plt.legend(loc='upper left')\n", + "plt.yscale('log') # Setting the y-scale to logarithmic for better visualization\n", + "plt.xlabel('n')\n", + "plt.ylabel('Value')\n", + "plt.grid(True)\n", + "plt.title('Comparison of 2^n and n^3')\n", + "plt.show()\n", + "\n", + "# To find the cross-over point manually\n", + "cross_over_point = None\n", + "for i in range(1, 11): # Adjust this range as needed\n", + " if 2**i <= i**3 and 2**(i+1) >= (i+1)**3:\n", + " cross_over_point = i\n", + " break\n", + "\n", + "if cross_over_point is not None:\n", + " print(f'Cross-over point: n ≈ {cross_over_point}')\n", + "else:\n", + " print('No cross-over point found in the checked range.')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 489 + }, + "id": "izb1CeKtXegZ", + "outputId": "b6079ff1-43d0-4ad7-f130-b181d6dcbc89" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cross-over point: n ≈ 9\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## **Q7:**\n", + "In a computer network, a packet is a formatted unit of data carried by a network. Consider an instance of a routing problem where there exists a router R1 and a router R2 such that router R1 is the most preferred in the routing table of R2 and router R2 is the most preferred in the routing table of R1 (Note that R1 and R2 are distinct routers and their connection results in a direct route). Then for every optimal routing table T for this instance, the pair (R1, R2) exists in T.\n", + "\n", + "• State whether the above statement is True or False?\n", + "\n", + "• If the statement is true give a short explanation if false give a counter example.\n", + "\n", + "### **Answer:**\n", + "Explanation:\n", + "In the instance of a routing problem, if we have two routers R1 and R2 such that R1 is the most preferred in the routing table of R2 and R2 is the most preferred in the routing table of R1, then the pair (R1, R2) will be a part of every optimal routing table T for this instance due to their mutual preference and direct connection.\n", + "\n", + "In network routing, the goal is to find the most efficient path to transmit data packets from source to destination. An optimal routing table should guide packets through the most efficient route possible, reducing latency and maximizing the use of network resources. In this particular case, the mutual preference of R1 and R2 for each other, coupled with the direct connection between them, ensures a highly efficient route for data packets to travel between these two routers. Therefore, any optimal routing table will include the pair (R1, R2) to maintain this efficiency.\n", + "\n", + "In coding terms, if we were to use an algorithm like Dijkstra's Algorithm to find the shortest path in a network, the direct connection between R1 and R2, coupled with their mutual preference, would ensure that the pair (R1, R2) is included in the resulting optimal routing table T.\n", + "\n", + "In a simplified routing scenario, we can use Dijkstra's Algorithm to find the shortest paths from a source router to all other routers in the network. Let's consider that the routers and connections between them form a weighted graph where the weights represent the cost (e.g., latency, distance) of routing through a particular connection.\n", + "\n", + "Here's a simplified pseudocode to illustrate how the mutual preference between R1 and R2 would result in the pair (R1, R2) being included in the optimal routing table:\n", + "\n", + "*** *Attention: it's pseudocode for better explanation. It's not runnable.***" + ], + "metadata": { + "id": "aDjpsggLYEf6" + } + }, + { + "cell_type": "code", + "source": [ + "function Dijkstra(Graph, source):\n", + " distance[source] = 0\n", + " for each vertex v in Graph:\n", + " if v ≠ source:\n", + " distance[v] = infinity\n", + " previous[v] = undefined\n", + " add v to unvisited\n", + "\n", + " while unvisited is not empty:\n", + " current = vertex in unvisited with min distance\n", + " remove current from unvisited\n", + "\n", + " for each neighbor v of current:\n", + " alt = distance[current] + cost_between(current, v)\n", + " if alt < distance[v]:\n", + " distance[v] = alt\n", + " previous[v] = current\n", + "\n", + " return previous\n", + "\n", + "# Assuming R1 is the source router\n", + "routing_table = Dijkstra(Graph, R1)\n", + "\n", + "# Check if R2 is directly connected to R1 in the routing table\n", + "if routing_table[R2] == R1:\n", + " print(\"(R1, R2) is included in the optimal routing table\")\n", + "\n" + ], + "metadata": { + "id": "QTkZpUs4dBWR" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "In this pseudocode:\n", + "\n", + "1. Initialize the distance to the source router R1 as 0 and to all other routers as infinity.\n", + "2. Keep a previous array to track the previous router in the optimal path to each router.\n", + "3. Use a loop to explore all unvisited routers, updating the distance and previous arrays based on the cost of the connections.\n", + "4. Finally, check if R2's previous router in the optimal routing table is R1. If it is, this confirms that the pair (R1, R2) is included in the optimal routing table.\n", + "\n", + "The mutual preference between R1 and R2 (expressed as a lower cost in the graph) ensures that R2 is directly reached from R1 in the optimal routing table." + ], + "metadata": { + "id": "sUdxlO9xdMXe" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Q8:**\n", + "Suppose we have two competing courier companies, let's call them Courier Alpha and Courier Beta. Each company has a set of delivery vehicles and each vehicle has a particular zone in the city where it operates. Let’s assume the vehicles to be $v$ and their respective zones to be $z$. Note that each vehicle can operate in different zones within the city except the central zone. Each company wants to maximize its delivery efficiency for which it wants to devise a strategy - assignment of each vehicle to a distinct optimal zone within the city - so that each vehicle can deliver packages to its fullest capacity. The efficiency of the company is judged only on the vehicle's delivery performance in the assigned zone. Note that there is no other criterion to evaluate the company’s efficiency except the performance of a vehicle for a particular zone.\n", + "\n", + "One way to determine how well the two courier companies will perform relative to each other, given their strategies, is through a common efficiency index. Each vehicle has a fixed rating based on its performance in the current season; we will assume that no two vehicles share the same rating. A company achieves higher efficiency in a given comparison if it has a greater rating for the vehicle assigned to a particular zone than the other company. For example, in Courier Alpha if a vehicle $v$ is assigned a zone $z$ which has a rating of 9 for that zone, then Courier Beta can achieve higher efficiency only if it has a vehicle whose rating is greater than 9 for that same zone. The goal of each company is to achieve higher efficiency in as many zone comparisons to be considered more efficient.\n", + "\n", + "Suppose at the beginning of the year, Courier Alpha reveals a strategy $A$ and Courier Beta reveals a strategy $B$. On the basis of this pair of strategy, each company achieves certain efficiencies, according to the rule above. We'll say that the pair of strategies $(A,B)$ is stable if neither Company can unilaterally change its own strategy and achieve higher efficiency. That is, there is no strategy $A'$ such that Courier Alpha achieves higher efficiency with the pair $(A',B)$; and symmetrically there is no strategy $B'$such that Courier Beta achieves higher efficiency with the pair $(A,B')$ than it did with pair $(A,B)$.\n", + "\n", + "For every set of vehicles and their rating for the zone they operate in, is there a stable pair of strategies?\n", + "Resolve this question by doing one of the following two things:\n", + "\n", + "* Give an algorithm that, for any set of vehicles and their ratings associated for a particular zone, produces a stable pair of strategies.\n", + "* Give an example of a set of vehicles and associated ratings for a particular zone they operate in for which there is no stable pair of strategies.\n", + "\n", + "### **Answer:**\n", + "The key to finding a stable pair of strategies is to examine how the companies could iteratively adjust their strategies in response to each other until neither can unilaterally improve their efficiency.\n", + "\n", + "**Algorithm:**\n", + "\n", + "1. Start with initial strategies $A$ and $B$ for Courier Alpha and Courier Beta, respectively.\n", + "2. For each zone, find the vehicle for Courier Alpha and Courier Beta that maximizes the efficiency in that zone. Update the strategies accordingly.\n", + "3. Repeat step 2 until neither company can improve its efficiency by unilaterally changing its strategy." + ], + "metadata": { + "id": "4oup7riGfrrk" + } + }, + { + "cell_type": "code", + "source": [ + "def evaluate_efficiency(vehicle, zone):\n", + " # Assume some function that returns the efficiency of a vehicle in a zone.\n", + " pass\n", + "\n", + "def find_best_vehicle_for_zone(zone, vehicles, other_company_vehicle):\n", + " best_vehicle = None\n", + " best_efficiency = 0\n", + " for vehicle in vehicles:\n", + " efficiency = evaluate_efficiency(vehicle, zone)\n", + " if efficiency is None:\n", + " continue # Skip this iteration if efficiency is None\n", + " other_efficiency = 0 # Default to 0\n", + " if other_company_vehicle is not None:\n", + " other_efficiency = evaluate_efficiency(other_company_vehicle, zone)\n", + " if other_efficiency is None:\n", + " other_efficiency = 0 # Set to 0 if None\n", + " if efficiency > best_efficiency and efficiency > other_efficiency:\n", + " best_vehicle = vehicle\n", + " best_efficiency = efficiency\n", + " return best_vehicle\n", + "\n", + "\n", + "def find_stable_pair(vehicles_alpha, vehicles_beta, zones):\n", + " strategy_alpha = {zone: None for zone in zones}\n", + " strategy_beta = {zone: None for zone in zones}\n", + " stable = False\n", + " while not stable:\n", + " stable = True # Assume the strategies are stable, to begin with.\n", + " for zone in zones:\n", + " new_vehicle_alpha = find_best_vehicle_for_zone(zone, vehicles_alpha, strategy_beta[zone])\n", + " new_vehicle_beta = find_best_vehicle_for_zone(zone, vehicles_beta, strategy_alpha[zone])\n", + " if new_vehicle_alpha != strategy_alpha[zone] or new_vehicle_beta != strategy_beta[zone]:\n", + " stable = False # Strategies are not stable, as we've found a better assignment.\n", + " strategy_alpha[zone] = new_vehicle_alpha\n", + " strategy_beta[zone] = new_vehicle_beta\n", + " return (strategy_alpha, strategy_beta)\n", + "\n", + "# Assuming some initial sets of vehicles and zones.\n", + "vehicles_alpha = {...}\n", + "vehicles_beta = {...}\n", + "zones = {...}\n", + "stable_pair = find_stable_pair(vehicles_alpha, vehicles_beta, zones)\n" + ], + "metadata": { + "id": "gQfomeKyjIW4" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "In this algorithm, find_stable_pair is an iterative procedure that tries to find a better vehicle assignment for each zone, for each company, in each iteration. A new iteration is triggered if at least one better vehicle assignment is found. The process repeats until no better assignments are found, implying a stable pair of strategies.\n", + "\n", + "**Limitations and Non-Trivial Example:**\n", + "\n", + "One of the limitations of this approach is that it assumes that the efficiency of a vehicle in a zone is independent of the other vehicles and zones. In real-world scenarios, this assumption may not hold.\n", + "\n", + "Additionally, finding a stable pair of strategies might not always be possible due to various complexities and interdependencies among vehicles and zones. For instance, if vehicles have varying capacities and zones have varying demand, the problem becomes much more complex. Similarly, in the soccer team scenario, player ratings in positions might change based on the overall team strategy, making it harder to find a stable pair of strategies.\n", + "\n", + "These limitations lead us towards a scenario where a stable pair of strategies may not exist, thus making it a non-trivial example to the posed questions. Without a clear measure of efficiency or performance that can be universally applied regardless of strategy, and with varying capacities and demands, the problem does not guarantee a stable solution." + ], + "metadata": { + "id": "BvReNPzxjth3" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Q9:**\n", + "Modify a Gale-Shapley algorithm implementation to match 4 Western Conference teams with 4 Eastern Conference teams based on provided preference lists. Show how the stable matchings are obtained. You can use the following preference lists:\n", + "\n", + "Western Conference Teams Preference Lists:\n", + "\n", + "Team A: 1, 2, 3, 4\n", + "\n", + "Team B: 3, 4, 1, 2\n", + "\n", + "Team C: 2, 1, 4, 3\n", + "\n", + "Team D: 4, 3, 2, 1\n", + "\n", + "Eastern Conference Teams Preference Lists:\n", + "\n", + "Team 1: B, C, A, D\n", + "\n", + "Team 2: A, B, D, C\n", + "\n", + "Team 3: D, A, C, B\n", + "\n", + "Team 4: C, D, B, A" + ], + "metadata": { + "id": "AoREBM0KnPyA" + } + }, + { + "cell_type": "markdown", + "source": [ + "First, modify the Gale-Shapley algorithm to create stable matchings between Western and Eastern Conference teams. The algorithm proceeds by each Western Conference team proposing to the Eastern Conference teams in the order of their preferences, until every team has a match." + ], + "metadata": { + "id": "90cR4l91oStm" + } + }, + { + "cell_type": "code", + "source": [ + "def gale_shapley(western_prefs, eastern_prefs):\n", + " n = len(western_prefs)\n", + " free_western = list(range(n))\n", + " matchings = [-1] * n\n", + " eastern_partners = [-1] * n\n", + "\n", + " while free_western:\n", + " west = free_western.pop(0)\n", + " east = western_prefs[west].pop(0)\n", + " if eastern_partners[east] == -1:\n", + " eastern_partners[east] = west\n", + " matchings[west] = east\n", + " else:\n", + " current_partner = eastern_partners[east]\n", + " if eastern_prefs[east].index(west) < eastern_prefs[east].index(current_partner):\n", + " eastern_partners[east] = west\n", + " matchings[west] = east\n", + " free_western.append(current_partner)\n", + "\n", + " return matchings\n", + "\n", + "# Preference lists\n", + "western_prefs = [[0, 1, 2, 3], [2, 3, 0, 1], [1, 0, 3, 2], [3, 2, 1, 0]]\n", + "eastern_prefs = [[1, 2, 0, 3], [0, 1, 3, 2], [3, 0, 2, 1], [2, 3, 1, 0]]\n", + "\n", + "# Call the function\n", + "matchings = gale_shapley(western_prefs, eastern_prefs)\n", + "print(matchings)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CXEu_Ol4pNH1", + "outputId": "73fa2f72-d00d-458c-df65-8dec7ccee2d2" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[0, 2, 1, 3]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "In the code above:\n", + "\n", + "1. We start with a list of free Western teams.\n", + "2. Each free Western team proposes to the Eastern teams in the order of their preferences.\n", + "3. If an Eastern team is unengaged or prefers the new proposal over its current match, it accepts the proposal. Otherwise, the Western team moves on to its next preference.\n", + "4. The algorithm proceeds until all teams have a match.\n", + "5. The function returns a list of matchings, where the indices represent the Western teams and the values represent the Eastern teams they are matched with.\n", + "\n", + "Running the code will output a list of stable matchings between the Western and Eastern Conference teams." + ], + "metadata": { + "id": "aAXKvJlIpXRw" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Reflection:**\n", + "\n", + "1. How ChatGPT or the tool you used assisted in this task?\n", + "\n", + "* I mainly used chatgpt for learning the concepts and explaining the code. Designing algorithmic problems is much more difficult than I thought, which requires a high level of algorithmic knowledge, and the most important role of chatgpt is to help me learn the principles and knowledge. At the same time, I also used chatgpt to explain some of the code in the sample questions to help me understand the code better. Of course, chatgpt's answers to some questions are not always correct, at this time I will use google to search and collect multiple resources to find the correct answer.\n", + "2. Challenges you faced while ensuring the problem maintained the spirit of the example\n", + "\n", + "* I think that keeping the essence of the example problem to design the problem is also one of the biggest difficulties, firstly it requires that you already fully understand the topic itself and can use the knowledge from it to create new problems. Secondly, it requires more than just knowing the knowledge, it requires us to think about the different scenarios in which a certain algorithm, a certain piece of knowledge (e.g., time complexity), will be examined and utilized, and the different effects it will have. In short, using chatgpt alone is not entirely sufficient in this process, and it is important to use more specialized books to make sure that the questions and answers you create are reasonable.\n", + "3. What you learned about problem design in the realm of algorithms\n", + "\n", + "* The first thing was definitely learning Big O, the comparison of the growth rate of each function, and the complexity analysis, and also gaining a deeper understanding of the Gale-Shapley algorithm and so on. Secondly, I learned how the Gale-Shapley algorithm is used in several different situations and what further improvements and optimizations need to be made. I also learned how important it is to have a clear problem statement in designing an algorithmic problem, especially for Input and Output formats and Constraints, which often need to be considered in various boundary cases to ensure the effectiveness of an algorithmic problem." + ], + "metadata": { + "id": "My7536QMpvjL" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **Reference:**\n", + "* https://towardsdatascience.com/gale-shapley-algorithm-simply-explained-\n", + "* https://www.geeksforgeeks.org/understanding-time-complexity-simple-examples/\n", + "* https://www.enjoyalgorithms.com/blog/time-complexity-analysis-in-data-structure-and-algorithms\n" + ], + "metadata": { + "id": "MMQIbkNWusSr" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **License:**\n", + "Copyright <2023> < Yanyan Chen>\n", + "\n", + "Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n", + "\n", + "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n", + "\n", + "THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE." + ], + "metadata": { + "id": "88MWs8ldwkA2" + } + } + ] +} \ No newline at end of file diff --git a/Submissions/002799697_Yanyan_Chen/002799697_Yanyan_Chen_Assignment1_README.md b/Submissions/002799697_Yanyan_Chen/002799697_Yanyan_Chen_Assignment1_README.md new file mode 100644 index 0000000..b49b370 --- /dev/null +++ b/Submissions/002799697_Yanyan_Chen/002799697_Yanyan_Chen_Assignment1_README.md @@ -0,0 +1,13 @@ +# 002799697_Yanyan_Chen_Assignment1 + +## Summary + +Name: Yanyan Chen + +NUID: 002799697 + +Date: 09/24/2023 + +* This assignment is mainly designed to focus on the knowledge points in worked assignment 1. +* Each question in the homework is given a detailed answer and idea analysis. Most of the answers include code or pseudo-code to better explain its principles. +* The Reflections, References, and License involved in this assignment are included in the file 002799697_Yanyan_Chen_Assignment1.ipynb diff --git a/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.ipynb b/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.ipynb new file mode 100644 index 0000000..7f8c065 --- /dev/null +++ b/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.ipynb @@ -0,0 +1,4784 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q1\n", + "\n", + "Arrange the following functions in increasing order of growth (Big O notation):\n", + "\n", + "1) 2n\n", + "2) n^2\n", + "3) 3n + 4\n", + "4) log(n)\n", + "5) n log(n)\n", + "6) 10n^3\n", + "7) √n\n", + "8) 2^n\n", + "9) 100n\n", + "10) N!\n", + "\n", + "Solution:\n", + "\n", + "1) log(n) is O(log n)\n", + "2) √n is O(√n)\n", + "3) 2n is O(n)\n", + "4) 3n + 4 is O(n)\n", + "5) 100n is O(n)\n", + "6) n log(n) is O(n log n)\n", + "7) n^2 is O(n^2)\n", + "8) 10n^3 is O(n^3)\n", + "9) 2^n is O(2^n)\n", + "10) n! is O(n!)\n", + "\n", + "Justification:\n", + "This solution is correct, because while 3n + 4, 100n, and 2n are all O(n), they should be ordered as 2n, 3n + 4, and 100n in increasing order of growth. The rest of the functions provided are in the correct order. This can be verified at [this wikipedia link](https://en.wikipedia.org/wiki/Big_O_notation#Orders_of_common_functions), which states that the functions given in the solutions grow in the order stated\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q2\n", + "\n", + "Two algorithms, Algorithm A and Algorithm B, are compared in terms of their time complexity as a function of the input size 'n'. Algorithm A takes 25n microseconds, while Algorithm B takes 3n^2 microseconds.\n", + "\n", + "1) Which algorithm is asymptotically faster?\n", + "\n", + "2) What is the cross-over value of 'n' at which Algorithm A becomes faster than Algorithm B in terms of time complexity?\n", + "\n", + "Solution:\n", + "\n", + "1) Algorithm A is asymptotically faster than Algorithm B. The order of growth of 25n is less than the order of growth of 3n^2.\n", + "\n", + "2) To find the cross-over value of 'n,' we need to equate the two time complexities and solve for 'n':\n", + "\n", + "25n = 3n^2\n", + "\n", + "Rearrange the equation:\n", + "\n", + "3n^2 - 25n = 0\n", + "\n", + "Factor out 'n':\n", + "\n", + "n(3n - 25) = 0\n", + "\n", + "Now, set each factor equal to zero:\n", + "\n", + "n = 0 (Not meaningful in this context)\n", + "\n", + "3n - 25 = 0\n", + "\n", + "3n = 25\n", + "\n", + "n = 25/3\n", + "\n", + "Therefore, the cross-over value of 'n' is approximately 8.33. For values of 'n' less than 8.33, Algorithm A is faster, and for values greater than 8.33, Algorithm B is faster in terms of time complexity.\n", + "\n", + "Justification:\n", + "\n", + "[WolframAlpha link](https://www.wolframalpha.com/input?i=intersect+of+25n+and+3n%5E2) showing graphical proof that 3n^2 grows faster than 25n at large enough values of n (more than 25/3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + " \n", + "x1 = np.linspace(-5,20,num=100)\n", + "\n", + "y1 = []\n", + "for i in range(len(x1)):\n", + " y1.append(3*x1[i]**2)\n", + "\n", + "x2 = np.linspace(-5,20,num=100)\n", + "\n", + "y2 = []\n", + "for i in range(len(x2)):\n", + " y2.append(25*x2[i])\n", + "\n", + "# plt.xlabel(\"asdf\")\n", + "plt.plot(x1,y1,label ='y=3x^2')\n", + "# plt.legend([\"blue\", \"green\"])\n", + "plt.plot(x2,y2,label =\"y=25x\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.axvline()\n", + "plt.axhline()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q3\n", + "\n", + "Consider a scenario where there are 'm' hospitals and 'n' medical students participating in a residency matching program. Each hospital ranks the students based on their qualifications and preferences, and each student ranks the hospitals based on their desired specialties and location. It is guaranteed that there are more students than available positions in hospitals.\n", + "\n", + "Your task is to find a stable assignment of students to hospitals following the principles of the Stable Marriage Problem.\n", + "\n", + "Explain the conditions that make an assignment stable in the context of this scenario.\n", + "\n", + "Prove that there always exists a stable assignment of students to hospitals.\n", + "\n", + "Devise an algorithm to find a stable assignment, and analyze its time complexity.\n", + "\n", + "Solution:\n", + "\n", + "An assignment of students to hospitals is stable if the following conditions are met:\n", + "a. There are no two students 's1' and 's2' and a hospital 'h' such that:\n", + "\n", + "'s1' is assigned to 'h'.\n", + "'s2' is assigned to no hospital.\n", + "'h' prefers 's2' to 's1' based on its ranking.\n", + "b. There are no two students 's1' and 's2' and two hospitals 'h1' and 'h2' such that:\n", + "'s1' is assigned to 'h1'.\n", + "'s2' is assigned to 'h2'.\n", + "'h1' prefers 's2' to 's1'.\n", + "'s2' prefers 'h1' to 'h2'.\n", + "To prove that there always exists a stable assignment of students to hospitals, we can use the Gale-Shapley algorithm, which guarantees a stable solution. This algorithm works by having hospitals propose to students in order of their preference, and students accept or reject proposals based on their own preferences. The algorithm terminates when every hospital has been is assigned a student.\n", + "\n", + "The Gale-Shapley algorithm terminates in O(mn) steps as each hospital offers a position to a student at most once, and at each iteration, some hospital offers a position to some student. The time complexity of the algorithm is proportional to the product of the number of hospitals 'm' and the number of students 'n'.\n", + "\n", + "In summary, the Stable Marriage Problem ensures that there is always a stable assignment of students to hospitals, and the Gale-Shapley algorithm can be used to find such an assignment efficiently.\n", + "\n", + "Code:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def stableMatching(hospPrefs,studPrefs):\n", + " unassignedHosps = set(hospPrefs.keys())\n", + " hospArr = [-1]*len(hospPrefs)\n", + " studArr = [-1]*len(studPrefs)\n", + " while(unassignedHosps):\n", + " for i in range(len(hospPrefs)):\n", + " # hosp i proposes to most prefered student\n", + " for j in range(len(studPrefs)):\n", + " studentHospLikes = hospPrefs[i][j]\n", + " if(studArr[studentHospLikes]==-1 or studArr[studentHospLikes]>i):\n", + " hospArr[i] = studentHospLikes\n", + " # if the student was previously taken then add old hospital to unassigned list and clear hospital array entry\n", + " if(studArr[studentHospLikes]!=-1):\n", + " hospArr[studArr[studentHospLikes]]=-1 and unassignedHosps.add(studArr[studentHospLikes])\n", + " studArr[studentHospLikes]=i\n", + " # remove hospital from unassigned hosps set\n", + " unassignedHosps.remove(i)\n", + " break\n", + " \n", + " return hospArr, studArr\n", + "\n", + "hospPrefs = {0:[1,3,0,2],1:[2,1,3,0],2:[1,3,2,0]}\n", + "studPrefs = {0:[1,2,0],1:[0,1,2],2:[2,1,0],3:[2,0,1]}\n", + "hospArr, studArr = stableMatching(hospPrefs,studPrefs)\n", + "print(hospArr)\n", + "print(studArr)\n", + "# the configuration of hospitals and students is stable, and the results meet all criteria for stable assignment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q4\n", + "\n", + "Two algorithms, Algorithm X and Algorithm Y, are being compared in terms of their time complexity for a given problem size 'n.'\n", + "\n", + "Algorithm X takes 10n^2 microseconds to solve the problem of size 'n,' while Algorithm Y takes 2^n microseconds to solve the same problem.\n", + "\n", + "a. Which algorithm is asymptotically faster?\n", + "\n", + "b. Determine the cross-over value of 'n' at which Algorithm X becomes faster than Algorithm Y in terms of time complexity.\n", + "\n", + "Solution:\n", + "\n", + "a. Algorithm X is asymptotically faster than Algorithm Y. The order of growth of 10n^2 is polynomial (quadratic) while the order of growth of 2^n is exponential.\n", + "\n", + "b. To find the cross-over value of 'n,' we need to equate the two time complexities and solve for 'n':\n", + "\n", + "10n^2 = 2^n\n", + "\n", + "Divide both sides by 10n^2:\n", + "\n", + "1 = (2^n) / (10n^2)\n", + "\n", + "To simplify, we can take the logarithm of both sides:\n", + "\n", + "log(1) = log((2^n) / (10n^2))\n", + "\n", + "0 = n * log(2) - 2 * log(10)\n", + "\n", + "n * log(2) = 2 * log(10)\n", + "\n", + "n = (2 * log(10)) / log(2)\n", + "\n", + "Using logarithm properties, we can calculate this approximately:\n", + "\n", + "n ≈ 6.644\n", + "\n", + "So, the cross-over value of 'n' is approximately 6.644. For values of 'n' less than this, Algorithm X is faster, and for values greater than this, Algorithm Y is faster in terms of time complexity.\n", + "\n", + "Graph:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + " \n", + "x1 = np.linspace(0,12)\n", + "\n", + "y1 = []\n", + "for i in range(len(x1)):\n", + " y1.append(10*x1[i]**2)\n", + "\n", + "# x2 = np.linspace(-5,20,num=10)\n", + "x2 = np.linspace(0,12)\n", + "\n", + "y2 = (np.power(2,x2))\n", + "\n", + "# plt.xlabel(\"asdf\")\n", + "plt.plot(x1,y1,label ='y=10x^2')\n", + "# plt.legend([\"blue\", \"green\"])\n", + "plt.plot(x2,y2,label =\"y=2^x\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.axvline()\n", + "plt.axhline()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q5\n", + "\n", + "You are given two sorting algorithms, Merge Sort algorithm P and Bubble Sort algorithm Q, both designed to sort an array of 'n' integers.\n", + "\n", + "1) Algorithm P has a time complexity of O(n^2), with a best case time complexity (big omega) of (n), and Algorithm Q has a time complexity of O(n log n), with a best case time complexity (big omega) of (n log n). Which algorithm is faster in terms of time complexity, and why? Please note that the best case for both the algorithms is when the array is already sorted in a non-decreasing order before running the algorithm.\n", + "\n", + "2) Consider an array of 'n' integers that is already sorted in non-decreasing order. Which algorithm, P or Q, would perform better on this input, and why? Explain your reasoning, considering the value of n to be large.\n", + "\n", + "3) Now, consider an array of 'n' integers that is sorted in non-increasing order (reverse sorted). Which algorithm, P or Q, would perform better on this input, and why? Explain your reasoning, considering the value of n to be large.\n", + "\n", + "4) In general, under what circumstances might Algorithm P be a better choice than Algorithm Q for sorting, despite its higher time complexity?\n", + "\n", + "Solution:\n", + "\n", + "1) Algorithm Q is faster in terms of time complexity because O(n log n) is a more efficient time complexity than O(n^2) for large input sizes 'n.' As 'n' grows, the difference in performance becomes increasingly significant.\n", + "\n", + "When the array is already sorted in non-decreasing order, Algorithm P would perform better. This is because Algorithm P performs better in (n) time during its best case run (when the array is already sorted in non-decreasing order). This is better than Algorithm Q which has a best case time complexity of (n log n) (during its best case run scenario of a pre-sorted array).\n", + "\n", + "When the array is sorted in non-increasing order (reverse sorted), Algorithm Q (O(n log n)) would perform better. This is because Algorithm Q's time complexity is less affected by the initial order of the elements, and its divide-and-conquer approach can efficiently handle reverse-sorted input.\n", + "\n", + "Algorithm P might be preferred if the input data has certain characteristics that make its quadratic time complexity more efficient in practice, such as neatly sorted data on a large array. In this case, only the best case time complexities of both the algorithms are relevant, with algorithm P being faster than Q with a time best case time complexity of (n) as opposed to Q’s (n*log(n)), as shown in [this WolframAlpha graph](https://www.wolframalpha.com/input?i=plot+x+and+x*log%28x%29).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + " \n", + "x1 = np.linspace(0,3)\n", + "\n", + "y1 = []\n", + "for i in range(len(x1)):\n", + " y1.append(x1[i]**2)\n", + "\n", + "# x2 = np.linspace(-5,20,num=10)\n", + "x2 = np.linspace(0,3)\n", + "\n", + "y2 = x2*(np.log(x2))\n", + "\n", + "# plt.xlabel(\"asdf\")\n", + "plt.plot(x1,y1,label ='y=x^2')\n", + "# plt.legend([\"blue\", \"green\"])\n", + "plt.plot(x2,y2,label =\"y=x*log(x)\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.axvline()\n", + "plt.axhline()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) When the array is already sorted in non-decreasing order, Algorithm P would perform better. This is because Algorithm P performs better in (n) time during its best case run (when the array is already sorted in non-decreasing order). This is better than Algorithm Q which has a best case time complexity of (n log n) (during its best case run scenario of a pre-sorted array).\n", + "\n", + "3) When the array is sorted in non-increasing order (reverse sorted), Algorithm Q (O(n log n)) would perform better. This is because Algorithm Q's time complexity is less affected by the initial order of the elements, and its divide-and-conquer approach can efficiently handle reverse-sorted input.\n", + "\n", + "4) Algorithm P might be preferred if the input data has certain characteristics that make its quadratic time complexity more efficient in practice, such as neatly sorted data on a large array. In this case, only the best case time complexities of both the algorithms are relevant, with algorithm P being faster than Q with a time best case time complexity of (n) as opposed to Q’s (n*log(n)), as shown in [this WolframAlpha graph](https://www.wolframalpha.com/input?i=plot+x+and+x*log%28x%29).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + " \n", + "x1 = np.linspace(0,5)\n", + "\n", + "y1 = []\n", + "for i in range(len(x1)):\n", + " y1.append(x1[i])\n", + "\n", + "# x2 = np.linspace(-5,20,num=10)\n", + "x2 = np.linspace(0,5)\n", + "\n", + "y2 = x2*(np.log(x2))\n", + "\n", + "# plt.xlabel(\"asdf\")\n", + "plt.plot(x1,y1,label ='y=x^2')\n", + "# plt.legend([\"blue\", \"green\"])\n", + "plt.plot(x2,y2,label =\"y=x*log(x)\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.axvline()\n", + "plt.axhline()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q6\n", + "\n", + "Question: Analyzing Time Complexity\n", + "\n", + "Consider the following Python function:\n", + "\n", + "def foo(arr):\n", + " n = len(arr)\n", + " result = 0\n", + " for i in range(n):\n", + " for j in range(i, n):\n", + " result += arr[i] * arr[j]\n", + " return result\n", + "\n", + "1) Analyze the time complexity of the foo function in terms of Big O notation. Provide a brief explanation of your analysis.\n", + "\n", + "2) Suppose the input array arr has a length of N. What will be the time complexity of the function if we call it with an array of length N/2 instead of N? Explain the time complexity change.\n", + "\n", + "3) Suggest an alternative algorithm for computing the same result with a lower time complexity, and briefly explain its time complexity.\n", + "\n", + "4) Compare the time complexity of the original foo function with the time complexity of your suggested alternative in terms of Big O notation. Explain the advantages of the alternative approach.\n", + "\n", + "Note: You are expected to provide a thorough analysis of the time complexity and a clear explanation of your answers.\n", + "\n", + "Solution:\n", + "\n", + "1) \n" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1244132356\n", + "Time taken for algorithm to execute on 10000 elements is 4.857999086380005 seconds\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/anuraag/Documents/work/info6205/INFO_6205_Program_Structure_and_Algorithms/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.ipynb Cell 14\u001b[0m line \u001b[0;36m2\n\u001b[1;32m 24\u001b[0m start_time \u001b[39m=\u001b[39m time\u001b[39m.\u001b[39mtime()\n\u001b[1;32m 25\u001b[0m arr \u001b[39m=\u001b[39m generateRandArr(\u001b[39m20000\u001b[39m)\n\u001b[0;32m---> 26\u001b[0m \u001b[39mprint\u001b[39m(foo(arr))\n\u001b[1;32m 27\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mTime taken for algorithm to execute on \u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mlen\u001b[39m(arr) ,\u001b[39m\"\u001b[39m\u001b[39m elements is \u001b[39m\u001b[39m\"\u001b[39m , (time\u001b[39m.\u001b[39mtime() \u001b[39m-\u001b[39m start_time) ,\u001b[39m\"\u001b[39m\u001b[39m seconds\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 29\u001b[0m \u001b[39m# This line takes approx 27 seconds to run\u001b[39;00m\n", + "\u001b[1;32m/Users/anuraag/Documents/work/info6205/INFO_6205_Program_Structure_and_Algorithms/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.ipynb Cell 14\u001b[0m line \u001b[0;36m9\n\u001b[1;32m 7\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(n):\n\u001b[1;32m 8\u001b[0m \u001b[39mfor\u001b[39;00m j \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(i, n):\n\u001b[0;32m----> 9\u001b[0m result \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m arr[i] \u001b[39m*\u001b[39m arr[j]\n\u001b[1;32m 10\u001b[0m \u001b[39mreturn\u001b[39;00m result\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "import random\n", + "import time\n", + "\n", + "def foo(arr):\n", + " n = len(arr)\n", + " result = 0\n", + " for i in range(n):\n", + " for j in range(i, n):\n", + " result += arr[i] * arr[j]\n", + " return result\n", + "\n", + "def generateRandArr(n):\n", + " arr = [0]*n\n", + " for i in range(n):\n", + " arr[i] = random.randint(0,10)\n", + " return arr\n", + "\n", + "start_time = time.time()\n", + "arr = generateRandArr(10000)\n", + "print(foo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + "# This line takes approx 8 seconds to run\n", + "start_time = time.time()\n", + "arr = generateRandArr(20000)\n", + "print(foo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + "# This line takes approx 27 seconds to run\n", + "start_time = time.time()\n", + "arr = generateRandArr(40000)\n", + "print(foo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function above has a for loop nested in another. This suggests that the nested for loop runs fully in each iteration of the outer for loop. This would suggest a time complexity of O(n^2). Even though the nested for loop doesn't run on the whole array in every iteration, suggesting that the actual number of lines more in the order of n^2/2, we still consider this to be O(n^2) as the division by 2 doesn't count for much at large values of n.\n", + "\n", + "Based on the above code example, as the value of n is doubling, the time taken is increasing at a rate much higher than double\n", + "\n", + "2) The time complexity of the function doesn't change with the size of array. Although it might be difficult to see the difference in time taken by the algorithm to run on small arrays, the time complexity of the algorithm doesn't change. On sufficiently large arrays with N input size, changing the input to N/2 doesn't affect its time complexity, but it does take approximately 1/4 of the time taken for the N sized array.\n", + "\n", + "3) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "import time\n", + "\n", + "def improvedFoo(arr):\n", + " n = len(arr)\n", + " result = 0\n", + " sumOfNums = 0\n", + " for i in range(n-1, -1, -1):\n", + " sumOfNums += arr[i]\n", + " result += (arr[i] * sumOfNums)\n", + " return result\n", + "\n", + "def generateRandArr(n):\n", + " arr = [0]*n\n", + " for i in range(n):\n", + " arr[i] = random.randint(0,10)\n", + " return arr\n", + "\n", + "start_time = time.time()\n", + "arr = generateRandArr(10000)\n", + "print(improvedFoo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + "start_time = time.time()\n", + "arr = generateRandArr(20000)\n", + "print(improvedFoo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + "start_time = time.time()\n", + "arr = generateRandArr(40000)\n", + "print(improvedFoo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + "start_time = time.time()\n", + "arr = generateRandArr(100000)\n", + "print(improvedFoo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + "start_time = time.time()\n", + "arr = generateRandArr(200000)\n", + "print(improvedFoo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + "start_time = time.time()\n", + "arr = generateRandArr(400000)\n", + "print(improvedFoo(arr))\n", + "print(\"Time taken for algorithm to execute on \", len(arr) ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above implementation has the time complexity of O(n), as opposed to the original algorithm's O(n^2). This is because the newer algorithm only has one for loop going through the array, during which it computes the sum. This can be proving by looking at the times that it takes to compute the sums while the input keeps doubling. We see that the time taken grows at the same rate that the size of the input array is growing\n", + "\n", + "4) The alternative approach boasts the time complexity of O(n) as opposed to the original's O(n^2), which is a big increase in efficiency at large values of n. As you can see in the code examples, the original algorithm takes ~27 seconds on an array of 40000 elements while the improved algorithm takes 0.1 second on an array 10 times that size. Even though the improved algorithm takes slightly more memory, the benefits in time efficiency over the original is clearly worth it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q7\n", + "\n", + "In the context of financial investments, consider a scenario where there are 'n' investors and 'n' investment opportunities. Each investor has preferences for the available investment opportunities, and each investment opportunity has preferences for the investors based on their capital and risk profile. In this scenario, it's possible that there exists an investor 'A' and an investment opportunity 'B' such that investor 'A' is ranked first in the preference list of investment opportunity 'B,' and investment opportunity 'B' is ranked first in the preference list of investor 'A.'\n", + "\n", + "State whether the following statement is True or False:\n", + "\n", + "\"For every stable investment allocation 'S' for this instance, the pair (A, B) belongs to 'S.'\"\n", + "\n", + "Provide a short explanation if the statement is true, or give a counterexample if the statement is false.\n", + "\n", + "Solution:\n", + "\n", + "The statement is True.\n", + "\n", + "Explanation: In the stable matching problem, the stability criterion ensures that there are no two elements, 'A' and 'B,' such that 'A' prefers 'B' to their current partner, and 'B' prefers 'A' to their current partner. When applied to the context of financial investments, this means that if investor 'A' and investment opportunity 'B' both rank each other as their top preferences, it implies that they have a strong mutual preference for each other. In a stable investment allocation 'S,' the pair (A, B) will indeed belong to 'S' because they mutually prefer each other, and it would not be stable if they were matched with anyone else.\n", + "\n", + "Therefore, the statement is True and holds for any instance of the stable investment allocation problem where such a mutual preference exists.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q8\n", + "\n", + "Your university is revising its campus housing allocation process using the Gale-Shapley matching algorithm. Previously, students were matched within their respective faculties, but now they want to mix students from different faculties for a more diverse living experience.\n", + "\n", + "\n", + "Note: You can create sample preference lists and adapt the Gale-Shapley algorithm for this assignment. The focus is on modifying the algorithm for different scenarios and analyzing its performance in various situations.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A. Modify the Gale-Shapley Algorithm\n", + "\n", + "Modify an existing Gale-Shapley implementation in Python to match students from different faculties using the Gale-Shapley algorithm. You can create preference lists for each student.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def stableMatching(humanitiesPrefs,sciencePrefs):\n", + " unassignedHumanities = set(humanitiesPrefs.keys())\n", + " humanitiesArr = [-1]*len(humanitiesPrefs)\n", + " scienceArr = [-1]*len(sciencePrefs)\n", + " while(unassignedHumanities):\n", + " for i in range(len(humanitiesPrefs)):\n", + " for j in range(len(sciencePrefs)):\n", + " scientistHumanitiesLike = humanitiesPrefs[i][j]\n", + " if(scienceArr[scientistHumanitiesLike]==-1 or scienceArr[scientistHumanitiesLike]>i):\n", + " humanitiesArr[i] = scientistHumanitiesLike\n", + " if(scienceArr[scientistHumanitiesLike]!=-1):\n", + " humanitiesArr[scienceArr[scientistHumanitiesLike]]=-1 and unassignedHumanities.add(scienceArr[scientistHumanitiesLike])\n", + " scienceArr[scientistHumanitiesLike]=i\n", + " unassignedHumanities.remove(i)\n", + " break\n", + " \n", + " return humanitiesArr, scienceArr\n", + "\n", + "humanitiesPrefs = {0:[1,3,0,2],1:[2,1,3,0],2:[1,3,2,0],3:[3,2,1,0]}\n", + "sciencePrefs = {0:[1,2,0,3],1:[3,0,1,2],2:[2,3,1,0],3:[2,0,3,1]}\n", + "humanitiesArr, scienceArr = stableMatching(humanitiesPrefs,sciencePrefs)\n", + "print(humanitiesArr)\n", + "print(scienceArr)\n", + "# the configuration of students matched between the two departments is stable, and the results meet all criteria for stable assignment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "B. Shuffle Preference Lists and Calculate Stability\n", + "\n", + "Use a loop to shuffle the preference lists for each student 1000 times. You can use the random.shuffle() function.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0: [0, 3, 2, 1], 1: [2, 3, 1, 0], 2: [3, 2, 1, 0], 3: [3, 1, 2, 0]}\n", + "{0: [3, 2, 1, 0], 1: [1, 0, 2, 3], 2: [0, 1, 2, 3], 3: [0, 1, 3, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 3, 2], 2: [1, 2, 0, 3], 3: [0, 2, 3, 1]}\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [3, 0, 2, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 2, 0], 2: [3, 1, 2, 0], 3: [1, 0, 2, 3]}\n", + "{0: [2, 1, 0, 3], 1: [2, 0, 3, 1], 2: [3, 0, 1, 2], 3: [0, 1, 2, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 2, 0], 2: [0, 2, 3, 1], 3: [0, 2, 1, 3]}\n", + "{0: [1, 0, 3, 2], 1: [2, 0, 3, 1], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 0, 1], 2: [2, 3, 0, 1], 3: [2, 3, 1, 0]}\n", + "{0: [3, 0, 2, 1], 1: [3, 0, 2, 1], 2: [0, 1, 3, 2], 3: [1, 0, 2, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 2, 1], 1: [1, 0, 3, 2], 2: [2, 0, 1, 3], 3: [3, 0, 1, 2]}\n", + "{0: [0, 1, 3, 2], 1: [2, 0, 3, 1], 2: [3, 2, 1, 0], 3: [1, 2, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 1, 2], 2: [2, 0, 1, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [2, 3, 1, 0], 3: [2, 0, 3, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 1, 3, 2], 1: [2, 0, 1, 3], 2: [0, 2, 3, 1], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 1, 0], 1: [1, 0, 2, 3], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 0, 2, 1], 1: [2, 1, 3, 0], 2: [2, 3, 0, 1], 3: [0, 1, 2, 3]}\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 2, 3], 2: [2, 1, 3, 0], 3: [0, 3, 2, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 0, 3, 2], 1: [3, 1, 2, 0], 2: [2, 3, 1, 0], 3: [2, 3, 1, 0]}\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 2, 1], 2: [3, 2, 1, 0], 3: [3, 2, 1, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 1, 3, 0], 1: [1, 2, 3, 0], 2: [1, 0, 3, 2], 3: [2, 0, 1, 3]}\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 2, 1], 2: [0, 3, 2, 1], 3: [2, 3, 0, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 3, 1], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 0, 3], 2: [3, 1, 2, 0], 3: [1, 0, 3, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 3, 0], 2: [1, 3, 2, 0], 3: [3, 2, 1, 0]}\n", + "{0: [3, 1, 2, 0], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [3, 0, 2, 1]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [1, 0, 3, 2], 2: [0, 2, 3, 1], 3: [0, 2, 3, 1]}\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 0, 1], 2: [2, 0, 3, 1], 3: [0, 3, 2, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 0, 2], 2: [2, 3, 0, 1], 3: [0, 3, 2, 1]}\n", + "{0: [0, 1, 3, 2], 1: [3, 1, 2, 0], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 3, 1], 2: [1, 2, 3, 0], 3: [1, 2, 3, 0]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [0, 3, 1, 2], 3: [2, 0, 3, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 0, 2], 2: [3, 0, 1, 2], 3: [3, 1, 2, 0]}\n", + "{0: [1, 3, 0, 2], 1: [1, 3, 2, 0], 2: [0, 2, 3, 1], 3: [2, 1, 0, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 2, 1, 3], 1: [3, 2, 0, 1], 2: [1, 0, 3, 2], 3: [1, 0, 2, 3]}\n", + "{0: [3, 2, 1, 0], 1: [1, 0, 2, 3], 2: [2, 1, 0, 3], 3: [3, 2, 1, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 3, 2], 2: [1, 3, 2, 0], 3: [1, 2, 3, 0]}\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 2, 1], 2: [1, 3, 2, 0], 3: [3, 2, 1, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 0, 3], 2: [2, 3, 0, 1], 3: [0, 3, 2, 1]}\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 2, 1], 2: [3, 0, 1, 2], 3: [3, 2, 0, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 2, 0, 1], 1: [0, 2, 3, 1], 2: [3, 1, 0, 2], 3: [0, 2, 3, 1]}\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 2, 1], 2: [0, 3, 1, 2], 3: [3, 0, 2, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 1, 3, 2], 1: [1, 2, 3, 0], 2: [0, 2, 1, 3], 3: [0, 3, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [3, 0, 1, 2], 2: [2, 0, 1, 3], 3: [1, 0, 2, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 3, 1, 0], 1: [1, 3, 2, 0], 2: [1, 3, 0, 2], 3: [1, 2, 0, 3]}\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 0, 1], 2: [2, 1, 0, 3], 3: [0, 1, 2, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 3, 2], 2: [3, 2, 1, 0], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 2, 3], 2: [0, 2, 3, 1], 3: [1, 2, 0, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [1, 2, 0, 3], 1: [3, 0, 2, 1], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [3, 1, 0, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [1, 0, 3, 2], 2: [1, 2, 3, 0], 3: [1, 3, 0, 2]}\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 0, 3], 2: [3, 2, 1, 0], 3: [1, 3, 2, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [3, 1, 0, 2]}\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 3, 0], 2: [2, 1, 3, 0], 3: [1, 2, 0, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 2, 1], 2: [2, 1, 0, 3], 3: [2, 1, 0, 3]}\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 2, 3], 2: [0, 1, 3, 2], 3: [0, 2, 3, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 1, 0], 2: [0, 3, 2, 1], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 2, 1], 2: [0, 3, 1, 2], 3: [2, 1, 3, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 1, 3], 2: [2, 3, 1, 0], 3: [1, 0, 3, 2]}\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [1, 3, 2, 0]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 3, 1], 2: [2, 3, 0, 1], 3: [3, 0, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 1, 3], 2: [0, 1, 2, 3], 3: [3, 2, 1, 0]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 2, 3, 0], 1: [2, 3, 0, 1], 2: [0, 2, 3, 1], 3: [1, 2, 3, 0]}\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 3, 2], 2: [2, 3, 1, 0], 3: [0, 2, 3, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 0, 2, 1], 1: [0, 2, 3, 1], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 1, 2], 2: [2, 0, 1, 3], 3: [2, 0, 1, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 1, 0], 2: [0, 1, 2, 3], 3: [0, 2, 3, 1]}\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 0, 2], 2: [1, 0, 2, 3], 3: [2, 0, 3, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 2, 0], 2: [2, 0, 1, 3], 3: [3, 0, 1, 2]}\n", + "{0: [0, 1, 2, 3], 1: [2, 1, 0, 3], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 0, 3], 2: [0, 2, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 0, 1, 3], 1: [3, 0, 2, 1], 2: [1, 0, 3, 2], 3: [3, 0, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 3, 1, 2], 1: [2, 3, 1, 0], 2: [2, 3, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [2, 3, 1, 0], 1: [0, 3, 2, 1], 2: [0, 3, 2, 1], 3: [1, 3, 2, 0]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 2, 0, 1], 1: [0, 1, 2, 3], 2: [1, 2, 0, 3], 3: [0, 1, 3, 2]}\n", + "{0: [0, 2, 1, 3], 1: [1, 3, 2, 0], 2: [2, 3, 0, 1], 3: [1, 0, 2, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 3, 0], 2: [3, 1, 0, 2], 3: [0, 3, 1, 2]}\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 0, 3], 2: [3, 0, 1, 2], 3: [2, 3, 0, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 2, 1, 3], 1: [0, 1, 2, 3], 2: [0, 3, 2, 1], 3: [0, 3, 1, 2]}\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 1, 0], 2: [0, 3, 1, 2], 3: [3, 2, 1, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 2, 3, 1], 1: [2, 1, 3, 0], 2: [2, 1, 0, 3], 3: [0, 1, 3, 2]}\n", + "{0: [0, 1, 2, 3], 1: [2, 3, 1, 0], 2: [2, 3, 0, 1], 3: [3, 0, 1, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 2, 0], 2: [1, 0, 3, 2], 3: [2, 3, 0, 1]}\n", + "{0: [1, 0, 3, 2], 1: [1, 0, 3, 2], 2: [3, 0, 1, 2], 3: [0, 1, 3, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 3, 2], 1: [3, 0, 2, 1], 2: [1, 0, 2, 3], 3: [1, 0, 3, 2]}\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 0, 2], 2: [3, 0, 1, 2], 3: [1, 2, 0, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 3, 2, 0], 1: [0, 2, 3, 1], 2: [0, 1, 3, 2], 3: [1, 0, 3, 2]}\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 2, 3], 2: [0, 2, 3, 1], 3: [2, 1, 3, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 3, 2], 2: [0, 3, 1, 2], 3: [3, 1, 0, 2]}\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 0, 2], 2: [2, 1, 0, 3], 3: [0, 2, 1, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 0, 2], 2: [1, 0, 2, 3], 3: [3, 2, 1, 0]}\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 3, 2], 2: [1, 0, 2, 3], 3: [3, 0, 1, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 2, 0, 1], 1: [2, 0, 3, 1], 2: [0, 2, 3, 1], 3: [3, 2, 1, 0]}\n", + "{0: [0, 1, 2, 3], 1: [1, 0, 2, 3], 2: [2, 0, 3, 1], 3: [3, 2, 1, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 3, 0], 2: [3, 1, 0, 2], 3: [2, 0, 3, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 3, 0, 2], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 1, 0, 3], 1: [3, 1, 0, 2], 2: [0, 1, 3, 2], 3: [2, 0, 1, 3]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 3, 0], 2: [3, 1, 0, 2], 3: [3, 2, 0, 1]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 3, 2, 0], 1: [0, 3, 1, 2], 2: [1, 0, 3, 2], 3: [1, 0, 2, 3]}\n", + "{0: [1, 2, 0, 3], 1: [2, 1, 3, 0], 2: [0, 2, 3, 1], 3: [1, 2, 3, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [2, 3, 1, 0], 1: [2, 3, 1, 0], 2: [1, 0, 3, 2], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 0, 1], 1: [3, 0, 1, 2], 2: [3, 1, 0, 2], 3: [1, 0, 2, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 1, 0], 2: [1, 2, 3, 0], 3: [2, 3, 1, 0]}\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 1, 2], 2: [0, 2, 3, 1], 3: [0, 2, 1, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 2, 0], 2: [2, 1, 0, 3], 3: [2, 0, 3, 1]}\n", + "{0: [3, 0, 1, 2], 1: [2, 3, 1, 0], 2: [3, 0, 2, 1], 3: [0, 1, 2, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 3, 1, 0], 1: [1, 3, 2, 0], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "{0: [0, 3, 1, 2], 1: [1, 3, 2, 0], 2: [2, 0, 3, 1], 3: [3, 0, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 2, 0], 2: [1, 2, 3, 0], 3: [0, 3, 2, 1]}\n", + "{0: [2, 0, 3, 1], 1: [3, 0, 1, 2], 2: [1, 3, 2, 0], 3: [0, 3, 2, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 0, 3, 2], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [3, 0, 1, 2]}\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 0, 3], 2: [0, 1, 3, 2], 3: [3, 1, 0, 2]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 3, 0], 2: [1, 3, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 2, 3], 2: [2, 3, 0, 1], 3: [1, 2, 3, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 1, 2], 2: [0, 1, 2, 3], 3: [3, 2, 0, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 3, 1, 2], 1: [3, 2, 0, 1], 2: [3, 2, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [2, 3, 0, 1], 1: [3, 1, 2, 0], 2: [1, 3, 0, 2], 3: [2, 3, 0, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 0, 3], 2: [1, 2, 3, 0], 3: [2, 0, 3, 1]}\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [2, 1, 0, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 3, 2], 2: [1, 2, 3, 0], 3: [2, 3, 0, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [3, 0, 2, 1]}\n", + "{0: [0, 2, 3, 1], 1: [2, 1, 3, 0], 2: [2, 0, 3, 1], 3: [1, 2, 0, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 3, 1, 0], 1: [3, 1, 0, 2], 2: [2, 1, 3, 0], 3: [0, 3, 1, 2]}\n", + "{0: [1, 3, 0, 2], 1: [1, 3, 0, 2], 2: [0, 3, 2, 1], 3: [3, 0, 2, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 1, 3, 2], 1: [0, 3, 1, 2], 2: [3, 2, 0, 1], 3: [1, 2, 0, 3]}\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 3, 0], 2: [1, 0, 3, 2], 3: [3, 0, 1, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 1, 0], 2: [0, 2, 3, 1], 3: [3, 1, 0, 2]}\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [0, 3, 1, 2], 3: [0, 2, 3, 1]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 0, 1, 3], 1: [0, 2, 1, 3], 2: [2, 3, 1, 0], 3: [0, 2, 1, 3]}\n", + "{0: [2, 1, 0, 3], 1: [2, 1, 0, 3], 2: [0, 2, 3, 1], 3: [3, 1, 0, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [3, 0, 2, 1], 1: [0, 1, 3, 2], 2: [2, 1, 3, 0], 3: [2, 3, 0, 1]}\n", + "{0: [2, 1, 0, 3], 1: [0, 2, 1, 3], 2: [3, 0, 1, 2], 3: [3, 0, 2, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 3, 1, 0], 1: [3, 2, 1, 0], 2: [1, 0, 2, 3], 3: [3, 1, 2, 0]}\n", + "{0: [0, 1, 3, 2], 1: [3, 2, 1, 0], 2: [2, 0, 3, 1], 3: [0, 2, 3, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 2, 0, 1], 1: [0, 1, 3, 2], 2: [1, 0, 2, 3], 3: [1, 3, 2, 0]}\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 0, 1], 2: [1, 2, 3, 0], 3: [2, 1, 3, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 1, 2], 2: [1, 2, 0, 3], 3: [0, 1, 2, 3]}\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 0, 1], 2: [3, 1, 2, 0], 3: [2, 3, 1, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 3, 2], 1: [2, 0, 3, 1], 2: [2, 1, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [2, 1, 0, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 2, 3], 2: [0, 3, 2, 1], 3: [2, 3, 0, 1]}\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 2, 0], 2: [3, 1, 2, 0], 3: [2, 0, 3, 1]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 1, 2], 2: [1, 3, 0, 2], 3: [0, 1, 3, 2]}\n", + "{0: [2, 3, 1, 0], 1: [2, 3, 0, 1], 2: [2, 0, 1, 3], 3: [0, 3, 1, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 2, 3], 2: [2, 0, 3, 1], 3: [1, 2, 3, 0]}\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 3, 0], 2: [2, 1, 0, 3], 3: [2, 3, 1, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 2, 3], 2: [2, 0, 1, 3], 3: [3, 1, 2, 0]}\n", + "{0: [0, 2, 1, 3], 1: [0, 1, 2, 3], 2: [3, 1, 2, 0], 3: [1, 3, 2, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 2, 3, 1], 1: [3, 0, 1, 2], 2: [1, 0, 2, 3], 3: [0, 3, 2, 1]}\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [2, 0, 3, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [0, 2, 3, 1], 2: [2, 1, 3, 0], 3: [2, 3, 0, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 2, 3], 2: [3, 1, 2, 0], 3: [1, 2, 3, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 0, 3], 2: [1, 0, 2, 3], 3: [2, 1, 3, 0]}\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 1, 2], 2: [0, 3, 2, 1], 3: [0, 3, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [0, 3, 1, 2]}\n", + "{0: [1, 2, 3, 0], 1: [2, 1, 0, 3], 2: [1, 3, 0, 2], 3: [0, 3, 2, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 3, 1, 0], 1: [2, 3, 1, 0], 2: [2, 0, 3, 1], 3: [0, 2, 3, 1]}\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 0, 1], 2: [0, 1, 2, 3], 3: [0, 3, 1, 2]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 3, 0], 2: [1, 3, 2, 0], 3: [1, 3, 2, 0]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 1, 0], 2: [3, 1, 0, 2], 3: [2, 0, 1, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 3, 1], 2: [0, 2, 1, 3], 3: [2, 0, 1, 3]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 0, 3], 2: [2, 0, 3, 1], 3: [1, 3, 0, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 1, 2, 0], 1: [1, 3, 2, 0], 2: [0, 1, 2, 3], 3: [2, 0, 1, 3]}\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 2, 3], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 1, 0, 2], 1: [1, 3, 2, 0], 2: [0, 3, 2, 1], 3: [0, 2, 3, 1]}\n", + "{0: [0, 2, 3, 1], 1: [0, 2, 1, 3], 2: [0, 3, 2, 1], 3: [2, 3, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 0, 3], 2: [1, 2, 3, 0], 3: [0, 3, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [3, 2, 0, 1], 2: [2, 0, 1, 3], 3: [2, 3, 0, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 2, 3], 2: [0, 3, 2, 1], 3: [1, 0, 3, 2]}\n", + "{0: [1, 0, 3, 2], 1: [2, 0, 3, 1], 2: [3, 0, 2, 1], 3: [1, 3, 0, 2]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 1, 3], 2: [0, 3, 1, 2], 3: [3, 2, 1, 0]}\n", + "{0: [3, 0, 1, 2], 1: [0, 1, 2, 3], 2: [1, 2, 3, 0], 3: [0, 3, 2, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 1, 2], 2: [0, 1, 2, 3], 3: [2, 3, 0, 1]}\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 1, 3], 2: [1, 2, 3, 0], 3: [3, 2, 1, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 0, 2, 1], 1: [2, 1, 0, 3], 2: [3, 0, 2, 1], 3: [0, 1, 3, 2]}\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 2, 0], 2: [2, 0, 3, 1], 3: [2, 1, 0, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 1, 3], 2: [0, 3, 1, 2], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 2, 3], 2: [1, 0, 3, 2], 3: [1, 3, 2, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 0, 2, 1], 1: [0, 3, 1, 2], 2: [0, 1, 2, 3], 3: [2, 1, 0, 3]}\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 3, 1], 2: [1, 2, 3, 0], 3: [1, 2, 0, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 1, 2], 2: [3, 2, 1, 0], 3: [1, 3, 0, 2]}\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 2, 1], 2: [0, 1, 2, 3], 3: [2, 1, 0, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 1, 3, 0], 1: [3, 1, 0, 2], 2: [0, 2, 3, 1], 3: [1, 2, 0, 3]}\n", + "{0: [3, 1, 0, 2], 1: [1, 3, 0, 2], 2: [1, 2, 0, 3], 3: [3, 1, 2, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 3, 2], 2: [0, 2, 3, 1], 3: [1, 3, 0, 2]}\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 1, 3], 2: [0, 3, 1, 2], 3: [0, 3, 2, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 0, 1], 2: [1, 0, 2, 3], 3: [2, 1, 0, 3]}\n", + "{0: [2, 3, 0, 1], 1: [0, 2, 3, 1], 2: [3, 1, 0, 2], 3: [1, 0, 2, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 3, 2, 1], 1: [0, 1, 3, 2], 2: [2, 1, 0, 3], 3: [2, 3, 0, 1]}\n", + "{0: [1, 0, 3, 2], 1: [3, 0, 2, 1], 2: [2, 3, 0, 1], 3: [1, 2, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 1, 2, 0], 1: [3, 1, 2, 0], 2: [0, 3, 2, 1], 3: [1, 0, 2, 3]}\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 1, 2], 2: [1, 3, 0, 2], 3: [0, 3, 2, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 2, 3], 2: [1, 3, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [2, 0, 1, 3], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [2, 1, 3, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 0, 3], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "{0: [2, 0, 3, 1], 1: [0, 2, 3, 1], 2: [3, 0, 2, 1], 3: [0, 3, 2, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 0, 1, 3], 1: [3, 2, 1, 0], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "{0: [3, 0, 1, 2], 1: [0, 3, 1, 2], 2: [1, 2, 0, 3], 3: [2, 3, 0, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 1, 0, 2], 1: [1, 0, 3, 2], 2: [3, 0, 1, 2], 3: [3, 2, 0, 1]}\n", + "{0: [2, 1, 3, 0], 1: [3, 1, 2, 0], 2: [0, 2, 3, 1], 3: [2, 0, 1, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 3, 2], 1: [0, 3, 2, 1], 2: [3, 2, 1, 0], 3: [1, 3, 0, 2]}\n", + "{0: [1, 0, 3, 2], 1: [0, 3, 2, 1], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 2, 3], 2: [3, 0, 2, 1], 3: [3, 2, 1, 0]}\n", + "{0: [2, 1, 3, 0], 1: [3, 2, 1, 0], 2: [1, 3, 2, 0], 3: [2, 1, 3, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [2, 3, 0, 1]}\n", + "{0: [1, 3, 2, 0], 1: [2, 1, 3, 0], 2: [1, 2, 3, 0], 3: [1, 3, 0, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 3, 0, 2], 1: [0, 3, 2, 1], 2: [1, 2, 0, 3], 3: [2, 0, 1, 3]}\n", + "{0: [2, 3, 0, 1], 1: [2, 0, 1, 3], 2: [3, 2, 0, 1], 3: [3, 0, 2, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 2, 0], 2: [0, 2, 3, 1], 3: [2, 3, 0, 1]}\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [1, 3, 2, 0], 3: [0, 1, 2, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 2, 1, 3], 1: [3, 1, 0, 2], 2: [0, 1, 2, 3], 3: [2, 0, 3, 1]}\n", + "{0: [0, 1, 2, 3], 1: [1, 0, 3, 2], 2: [0, 2, 1, 3], 3: [1, 2, 0, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 0, 2], 2: [3, 0, 2, 1], 3: [1, 2, 0, 3]}\n", + "{0: [2, 0, 1, 3], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [2, 0, 1, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 3, 1], 2: [3, 2, 1, 0], 3: [0, 3, 2, 1]}\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 0, 1], 2: [2, 1, 0, 3], 3: [1, 2, 3, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [2, 1, 3, 0]}\n", + "{0: [1, 0, 2, 3], 1: [3, 0, 2, 1], 2: [3, 1, 0, 2], 3: [0, 1, 3, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 0, 3], 2: [2, 0, 3, 1], 3: [0, 2, 1, 3]}\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 2, 3], 2: [0, 3, 1, 2], 3: [0, 2, 1, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 0, 3], 2: [0, 3, 1, 2], 3: [3, 0, 2, 1]}\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 3, 0], 2: [1, 2, 3, 0], 3: [2, 1, 0, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 2, 1, 3], 1: [2, 0, 1, 3], 2: [1, 2, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [2, 1, 3, 0], 1: [2, 3, 1, 0], 2: [0, 2, 1, 3], 3: [3, 1, 2, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 1, 0], 2: [2, 3, 1, 0], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [1, 0, 3, 2], 3: [2, 0, 1, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 1, 0, 3], 1: [2, 0, 3, 1], 2: [2, 0, 3, 1], 3: [0, 2, 1, 3]}\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 3, 0], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [3, 0, 1, 2], 1: [0, 1, 2, 3], 2: [1, 0, 2, 3], 3: [0, 1, 3, 2]}\n", + "{0: [1, 0, 2, 3], 1: [0, 3, 2, 1], 2: [0, 3, 1, 2], 3: [0, 3, 1, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [2, 3, 0, 1], 1: [0, 1, 3, 2], 2: [2, 0, 1, 3], 3: [0, 1, 2, 3]}\n", + "{0: [1, 3, 0, 2], 1: [0, 3, 1, 2], 2: [0, 2, 3, 1], 3: [2, 0, 3, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 1, 0], 2: [2, 0, 3, 1], 3: [2, 3, 0, 1]}\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 3, 0], 2: [0, 1, 2, 3], 3: [1, 0, 3, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 1, 2], 2: [3, 2, 0, 1], 3: [1, 2, 3, 0]}\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 3, 2], 2: [3, 2, 0, 1], 3: [1, 2, 3, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 0, 3], 2: [0, 1, 2, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 0, 3, 2], 1: [1, 3, 0, 2], 2: [3, 0, 2, 1], 3: [1, 2, 3, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 1, 0], 2: [0, 3, 2, 1], 3: [1, 3, 0, 2]}\n", + "{0: [0, 2, 3, 1], 1: [0, 2, 1, 3], 2: [3, 1, 0, 2], 3: [0, 2, 1, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 2, 0, 1], 1: [3, 0, 2, 1], 2: [3, 1, 0, 2], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 3, 2], 2: [2, 0, 1, 3], 3: [3, 1, 0, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [1, 0, 3, 2], 1: [0, 1, 3, 2], 2: [0, 2, 1, 3], 3: [1, 0, 3, 2]}\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 1, 3], 2: [3, 0, 2, 1], 3: [2, 1, 0, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [3, 0, 1, 2]}\n", + "{0: [1, 2, 3, 0], 1: [1, 3, 2, 0], 2: [2, 3, 1, 0], 3: [2, 3, 1, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 1, 2, 0], 1: [0, 1, 2, 3], 2: [0, 3, 2, 1], 3: [1, 0, 2, 3]}\n", + "{0: [3, 0, 1, 2], 1: [0, 2, 1, 3], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 3, 0], 2: [3, 0, 1, 2], 3: [1, 3, 2, 0]}\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 3, 2], 2: [3, 0, 1, 2], 3: [1, 3, 2, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 3, 2], 2: [0, 1, 2, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 3, 1], 2: [0, 3, 1, 2], 3: [0, 2, 3, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 3, 0, 1], 1: [1, 0, 2, 3], 2: [0, 3, 2, 1], 3: [3, 1, 2, 0]}\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 1, 2], 2: [0, 1, 2, 3], 3: [2, 1, 3, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [3, 1, 0, 2], 3: [3, 2, 1, 0]}\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 0, 2], 2: [0, 3, 1, 2], 3: [3, 1, 0, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [0, 2, 1, 3]}\n", + "{0: [0, 1, 3, 2], 1: [2, 3, 0, 1], 2: [2, 1, 0, 3], 3: [0, 3, 2, 1]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 2, 0, 1], 1: [2, 0, 3, 1], 2: [0, 1, 3, 2], 3: [2, 1, 3, 0]}\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 1, 0], 2: [0, 3, 2, 1], 3: [0, 2, 3, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [3, 1, 0, 2], 2: [2, 1, 0, 3], 3: [0, 3, 2, 1]}\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 2, 1], 2: [2, 3, 0, 1], 3: [1, 2, 0, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 3, 0], 2: [2, 3, 0, 1], 3: [2, 3, 0, 1]}\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 3, 1], 2: [3, 2, 0, 1], 3: [0, 2, 3, 1]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 0, 1], 2: [2, 0, 1, 3], 3: [3, 1, 2, 0]}\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 3, 1], 2: [1, 2, 0, 3], 3: [2, 1, 0, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 0, 2], 2: [1, 2, 3, 0], 3: [3, 2, 1, 0]}\n", + "{0: [1, 0, 2, 3], 1: [3, 1, 2, 0], 2: [1, 0, 2, 3], 3: [1, 0, 3, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 1, 3, 0], 1: [1, 3, 0, 2], 2: [2, 3, 1, 0], 3: [1, 0, 2, 3]}\n", + "{0: [3, 1, 2, 0], 1: [3, 1, 2, 0], 2: [1, 0, 3, 2], 3: [2, 3, 0, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [1, 2, 0, 3]}\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 0, 3], 2: [0, 1, 2, 3], 3: [0, 1, 3, 2]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 3, 0], 2: [2, 0, 3, 1], 3: [0, 1, 2, 3]}\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 1, 2], 2: [0, 2, 1, 3], 3: [1, 2, 0, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 1, 2], 2: [3, 0, 2, 1], 3: [3, 0, 1, 2]}\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 2, 3], 2: [0, 2, 3, 1], 3: [0, 2, 3, 1]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 1, 3, 2], 1: [3, 0, 1, 2], 2: [2, 1, 3, 0], 3: [1, 2, 0, 3]}\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [3, 0, 2, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 2, 3, 1], 1: [3, 0, 2, 1], 2: [2, 0, 3, 1], 3: [2, 3, 1, 0]}\n", + "{0: [1, 3, 2, 0], 1: [1, 0, 2, 3], 2: [3, 0, 1, 2], 3: [2, 3, 1, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 2, 0], 2: [0, 3, 1, 2], 3: [2, 3, 1, 0]}\n", + "{0: [2, 3, 1, 0], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [2, 3, 0, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 1, 0], 2: [2, 1, 0, 3], 3: [0, 2, 1, 3]}\n", + "{0: [0, 1, 2, 3], 1: [0, 3, 1, 2], 2: [0, 1, 2, 3], 3: [2, 1, 3, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 0, 2], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 0, 3], 2: [2, 3, 0, 1], 3: [3, 0, 1, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 1, 3, 2], 1: [3, 0, 1, 2], 2: [2, 1, 0, 3], 3: [0, 2, 1, 3]}\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 2, 1], 2: [3, 2, 0, 1], 3: [0, 3, 1, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 2, 3, 0], 1: [0, 2, 3, 1], 2: [3, 1, 2, 0], 3: [1, 3, 0, 2]}\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 1, 2], 2: [1, 3, 2, 0], 3: [1, 0, 2, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 1, 2], 2: [1, 3, 2, 0], 3: [0, 2, 1, 3]}\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 3, 1], 2: [2, 1, 0, 3], 3: [0, 2, 1, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 0, 2], 2: [0, 1, 3, 2], 3: [2, 1, 0, 3]}\n", + "{0: [2, 3, 1, 0], 1: [1, 3, 0, 2], 2: [2, 0, 1, 3], 3: [3, 0, 2, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 2, 0], 1: [3, 1, 0, 2], 2: [2, 3, 0, 1], 3: [2, 1, 3, 0]}\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 0, 1], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 3, 1, 0], 1: [3, 0, 2, 1], 2: [1, 0, 3, 2], 3: [1, 3, 2, 0]}\n", + "{0: [1, 0, 2, 3], 1: [3, 0, 2, 1], 2: [2, 1, 3, 0], 3: [3, 0, 2, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 0, 3], 2: [2, 1, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [0, 3, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 0, 1], 2: [1, 3, 2, 0], 3: [1, 3, 2, 0]}\n", + "{0: [1, 3, 0, 2], 1: [3, 2, 1, 0], 2: [0, 3, 2, 1], 3: [1, 3, 2, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 3, 0, 2], 1: [2, 3, 1, 0], 2: [3, 1, 0, 2], 3: [0, 3, 1, 2]}\n", + "{0: [0, 3, 2, 1], 1: [1, 2, 3, 0], 2: [3, 2, 1, 0], 3: [1, 3, 0, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 3, 1, 0], 1: [1, 0, 3, 2], 2: [3, 1, 2, 0], 3: [2, 3, 0, 1]}\n", + "{0: [3, 0, 1, 2], 1: [1, 0, 3, 2], 2: [3, 1, 0, 2], 3: [3, 1, 2, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 1, 2], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [0, 3, 1, 2], 2: [2, 1, 0, 3], 3: [3, 2, 0, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 0, 3], 2: [3, 2, 1, 0], 3: [3, 0, 2, 1]}\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 0, 2], 2: [2, 3, 1, 0], 3: [3, 1, 2, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 0, 3], 2: [3, 1, 0, 2], 3: [3, 0, 2, 1]}\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 1, 3], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [1, 0, 2, 3], 1: [1, 3, 2, 0], 2: [3, 2, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [3, 0, 1, 2], 1: [1, 3, 2, 0], 2: [3, 1, 2, 0], 3: [0, 1, 3, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 1, 0], 2: [0, 1, 2, 3], 3: [2, 0, 3, 1]}\n", + "{0: [3, 0, 1, 2], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [1, 0, 3, 2]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 0, 1, 3], 1: [3, 0, 2, 1], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 3, 1], 2: [3, 2, 1, 0], 3: [0, 3, 1, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 2, 1, 3], 1: [2, 3, 1, 0], 2: [3, 0, 2, 1], 3: [1, 3, 0, 2]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 1, 3], 2: [2, 0, 1, 3], 3: [3, 1, 2, 0]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 3, 1, 0], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [3, 1, 2, 0]}\n", + "{0: [3, 1, 2, 0], 1: [0, 3, 2, 1], 2: [0, 1, 2, 3], 3: [3, 0, 1, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 0, 2], 2: [2, 1, 0, 3], 3: [3, 1, 2, 0]}\n", + "{0: [2, 0, 1, 3], 1: [3, 2, 0, 1], 2: [2, 3, 1, 0], 3: [0, 1, 3, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 1, 2, 0], 1: [2, 1, 3, 0], 2: [1, 3, 2, 0], 3: [3, 0, 1, 2]}\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 0, 2], 2: [2, 3, 0, 1], 3: [1, 3, 0, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 1, 0], 2: [3, 0, 1, 2], 3: [2, 0, 1, 3]}\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 3, 0], 2: [0, 2, 1, 3], 3: [2, 1, 3, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 3, 2], 1: [3, 1, 2, 0], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [0, 2, 1, 3], 1: [1, 0, 3, 2], 2: [0, 3, 1, 2], 3: [1, 0, 2, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 0, 3, 2], 1: [0, 3, 2, 1], 2: [1, 3, 2, 0], 3: [0, 1, 2, 3]}\n", + "{0: [3, 0, 1, 2], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [3, 2, 0, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 1, 0], 2: [0, 1, 3, 2], 3: [0, 1, 3, 2]}\n", + "{0: [0, 1, 2, 3], 1: [1, 2, 0, 3], 2: [3, 0, 1, 2], 3: [1, 3, 2, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 0, 2], 2: [2, 0, 1, 3], 3: [2, 3, 0, 1]}\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 1, 2], 2: [0, 3, 2, 1], 3: [0, 1, 2, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 1, 0], 2: [3, 1, 2, 0], 3: [0, 1, 2, 3]}\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 0, 2], 2: [2, 1, 3, 0], 3: [2, 1, 3, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 2, 3], 2: [1, 2, 3, 0], 3: [3, 0, 2, 1]}\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 1, 3], 2: [2, 1, 0, 3], 3: [3, 1, 2, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 0, 1], 2: [0, 2, 3, 1], 3: [3, 0, 1, 2]}\n", + "{0: [2, 0, 3, 1], 1: [2, 3, 1, 0], 2: [1, 0, 3, 2], 3: [0, 1, 3, 2]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 3, 0, 1], 1: [3, 0, 2, 1], 2: [2, 3, 0, 1], 3: [2, 3, 0, 1]}\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 0, 2], 2: [3, 1, 0, 2], 3: [1, 2, 3, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 1, 2, 3], 1: [3, 2, 0, 1], 2: [1, 3, 0, 2], 3: [0, 3, 2, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 3, 2], 2: [2, 0, 3, 1], 3: [2, 3, 0, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 1, 3], 2: [0, 3, 2, 1], 3: [2, 3, 0, 1]}\n", + "{0: [2, 0, 3, 1], 1: [1, 2, 3, 0], 2: [0, 3, 2, 1], 3: [2, 1, 0, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 2, 1], 1: [2, 0, 1, 3], 2: [2, 0, 1, 3], 3: [0, 2, 1, 3]}\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 3, 2], 2: [1, 3, 2, 0], 3: [2, 0, 3, 1]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 2, 1], 2: [1, 3, 2, 0], 3: [1, 3, 0, 2]}\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 3, 1], 2: [1, 2, 3, 0], 3: [2, 0, 3, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 2, 1, 0], 1: [0, 2, 1, 3], 2: [3, 1, 2, 0], 3: [0, 2, 3, 1]}\n", + "{0: [2, 0, 3, 1], 1: [1, 2, 3, 0], 2: [1, 0, 2, 3], 3: [3, 0, 1, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 2, 1], 2: [1, 2, 3, 0], 3: [2, 1, 0, 3]}\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 1, 0], 2: [3, 1, 2, 0], 3: [1, 3, 0, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 1, 2], 2: [1, 0, 2, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 1, 2], 2: [0, 2, 3, 1], 3: [2, 0, 1, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 3, 2], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "{0: [2, 1, 3, 0], 1: [1, 3, 2, 0], 2: [0, 3, 1, 2], 3: [3, 2, 0, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 3, 0], 2: [1, 0, 3, 2], 3: [0, 2, 3, 1]}\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 1, 2], 2: [1, 3, 0, 2], 3: [0, 3, 1, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 1, 0], 2: [2, 0, 1, 3], 3: [2, 1, 3, 0]}\n", + "{0: [0, 2, 3, 1], 1: [0, 3, 2, 1], 2: [1, 3, 0, 2], 3: [2, 0, 1, 3]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 1, 0, 2], 1: [3, 2, 0, 1], 2: [1, 0, 2, 3], 3: [0, 3, 2, 1]}\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 1, 2], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 3, 2], 2: [0, 2, 1, 3], 3: [2, 0, 1, 3]}\n", + "{0: [0, 2, 1, 3], 1: [1, 0, 3, 2], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 2, 1, 0], 1: [2, 1, 0, 3], 2: [2, 1, 3, 0], 3: [0, 2, 1, 3]}\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 2, 1], 2: [0, 3, 2, 1], 3: [1, 2, 0, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [3, 1, 2, 0], 2: [3, 1, 2, 0], 3: [1, 2, 3, 0]}\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 3, 0], 2: [2, 0, 1, 3], 3: [1, 0, 3, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 0, 3], 2: [2, 3, 1, 0], 3: [0, 2, 3, 1]}\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 2, 0], 2: [0, 3, 1, 2], 3: [1, 0, 3, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 3, 0, 1], 1: [0, 1, 2, 3], 2: [1, 0, 3, 2], 3: [0, 1, 2, 3]}\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 0, 2], 2: [3, 1, 2, 0], 3: [3, 2, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 1, 3, 2], 1: [2, 3, 1, 0], 2: [2, 3, 0, 1], 3: [2, 3, 1, 0]}\n", + "{0: [1, 0, 2, 3], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [2, 1, 0, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 1, 0, 2], 1: [1, 3, 0, 2], 2: [0, 1, 3, 2], 3: [3, 1, 2, 0]}\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 3, 1], 2: [2, 3, 1, 0], 3: [3, 1, 0, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 0, 1, 2], 1: [3, 2, 1, 0], 2: [0, 2, 1, 3], 3: [1, 0, 2, 3]}\n", + "{0: [1, 0, 3, 2], 1: [2, 0, 1, 3], 2: [2, 0, 3, 1], 3: [0, 2, 3, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 3, 1, 0], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [3, 0, 2, 1]}\n", + "{0: [2, 3, 1, 0], 1: [3, 0, 2, 1], 2: [0, 2, 1, 3], 3: [1, 3, 0, 2]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 0, 1, 3], 1: [0, 3, 1, 2], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 3, 2], 2: [1, 2, 0, 3], 3: [0, 3, 2, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 2, 3], 2: [3, 1, 0, 2], 3: [3, 1, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [1, 0, 2, 3], 2: [0, 2, 1, 3], 3: [2, 3, 0, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 2, 0], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "{0: [0, 1, 3, 2], 1: [3, 1, 0, 2], 2: [0, 1, 3, 2], 3: [0, 2, 1, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 0, 3], 2: [0, 1, 2, 3], 3: [0, 1, 3, 2]}\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 3, 2], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 0, 2], 2: [1, 2, 3, 0], 3: [1, 3, 2, 0]}\n", + "{0: [0, 1, 2, 3], 1: [0, 3, 2, 1], 2: [0, 2, 3, 1], 3: [2, 1, 3, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 3, 0, 1], 1: [0, 1, 2, 3], 2: [1, 0, 2, 3], 3: [0, 2, 3, 1]}\n", + "{0: [1, 0, 3, 2], 1: [2, 1, 0, 3], 2: [0, 1, 2, 3], 3: [3, 0, 2, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 3, 0, 1], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [3, 0, 1, 2]}\n", + "{0: [0, 3, 1, 2], 1: [0, 1, 2, 3], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 0, 1], 1: [2, 0, 1, 3], 2: [3, 1, 0, 2], 3: [2, 1, 3, 0]}\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 1, 3], 2: [3, 1, 2, 0], 3: [2, 0, 1, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 2, 3], 2: [3, 2, 0, 1], 3: [1, 0, 3, 2]}\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 1, 0], 2: [0, 1, 3, 2], 3: [3, 2, 0, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 0, 2], 2: [1, 0, 2, 3], 3: [2, 1, 0, 3]}\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [2, 3, 0, 1], 3: [2, 1, 3, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 1, 0], 2: [1, 2, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 3, 0], 1: [2, 3, 0, 1], 2: [0, 1, 2, 3], 3: [1, 3, 2, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 2, 1], 2: [0, 2, 1, 3], 3: [1, 0, 2, 3]}\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 3, 2], 2: [0, 1, 2, 3], 3: [2, 3, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 0, 3], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 3, 0, 1], 1: [2, 1, 3, 0], 2: [3, 2, 0, 1], 3: [0, 1, 2, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [1, 3, 0, 2], 1: [2, 1, 0, 3], 2: [2, 1, 0, 3], 3: [0, 2, 3, 1]}\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [2, 0, 1, 3], 3: [0, 1, 3, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 1, 0], 2: [0, 2, 3, 1], 3: [2, 3, 0, 1]}\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 3, 0], 2: [0, 3, 1, 2], 3: [3, 0, 1, 2]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 2, 3], 2: [0, 2, 3, 1], 3: [3, 1, 0, 2]}\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 1, 2], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 2, 0], 2: [1, 0, 3, 2], 3: [3, 1, 2, 0]}\n", + "{0: [0, 3, 1, 2], 1: [2, 3, 0, 1], 2: [0, 1, 3, 2], 3: [1, 2, 3, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 0, 1, 3], 1: [3, 0, 1, 2], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 2, 3], 2: [0, 2, 1, 3], 3: [1, 2, 3, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 3, 0, 1], 1: [0, 2, 3, 1], 2: [2, 0, 1, 3], 3: [0, 1, 3, 2]}\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 3, 0], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 0, 1], 2: [2, 1, 0, 3], 3: [3, 0, 1, 2]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 3, 2], 2: [3, 0, 1, 2], 3: [1, 0, 2, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 3, 1, 0], 1: [2, 0, 3, 1], 2: [1, 0, 3, 2], 3: [0, 2, 1, 3]}\n", + "{0: [0, 1, 3, 2], 1: [3, 0, 2, 1], 2: [0, 1, 3, 2], 3: [0, 2, 3, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 1, 3], 2: [1, 2, 3, 0], 3: [2, 0, 1, 3]}\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 2, 1], 2: [3, 2, 0, 1], 3: [3, 0, 1, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [3, 2, 1, 0], 2: [2, 0, 1, 3], 3: [3, 2, 1, 0]}\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 1, 2], 2: [2, 3, 0, 1], 3: [1, 2, 0, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 1, 0], 2: [3, 2, 1, 0], 3: [1, 2, 3, 0]}\n", + "{0: [1, 2, 0, 3], 1: [2, 3, 1, 0], 2: [3, 0, 2, 1], 3: [2, 0, 3, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 1, 3], 2: [0, 3, 2, 1], 3: [3, 0, 1, 2]}\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 1, 0], 2: [3, 0, 1, 2], 3: [0, 1, 2, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 2, 1], 2: [2, 3, 1, 0], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 3, 2], 2: [1, 3, 0, 2], 3: [1, 3, 0, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 2, 1, 3], 1: [3, 0, 2, 1], 2: [0, 2, 3, 1], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 0, 3], 2: [0, 2, 1, 3], 3: [0, 1, 3, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 1, 0, 2], 1: [2, 1, 0, 3], 2: [2, 3, 0, 1], 3: [1, 3, 0, 2]}\n", + "{0: [0, 3, 1, 2], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [1, 3, 0, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 2, 1], 2: [3, 1, 0, 2], 3: [2, 3, 1, 0]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 1, 3], 2: [1, 2, 3, 0], 3: [2, 3, 1, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 0, 2], 2: [2, 1, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [2, 1, 3, 0], 1: [2, 3, 1, 0], 2: [2, 0, 3, 1], 3: [3, 2, 0, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [2, 3, 0, 1]}\n", + "{0: [1, 0, 2, 3], 1: [3, 0, 2, 1], 2: [2, 0, 1, 3], 3: [1, 0, 3, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [2, 1, 3, 0], 3: [0, 1, 3, 2]}\n", + "{0: [3, 2, 0, 1], 1: [1, 2, 3, 0], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 3, 2, 1], 1: [1, 2, 0, 3], 2: [0, 1, 3, 2], 3: [1, 3, 0, 2]}\n", + "{0: [0, 2, 1, 3], 1: [1, 0, 3, 2], 2: [2, 1, 0, 3], 3: [3, 1, 2, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 1, 3, 0], 1: [1, 2, 0, 3], 2: [2, 0, 3, 1], 3: [2, 3, 1, 0]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 3, 1], 2: [2, 1, 0, 3], 3: [2, 3, 1, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [2, 0, 3, 1], 3: [3, 2, 1, 0]}\n", + "{0: [2, 1, 0, 3], 1: [2, 0, 1, 3], 2: [3, 2, 0, 1], 3: [0, 1, 2, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 2, 1], 2: [0, 2, 1, 3], 3: [2, 1, 0, 3]}\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 1, 3], 2: [1, 3, 2, 0], 3: [1, 0, 2, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 1, 3], 2: [3, 1, 0, 2], 3: [0, 3, 2, 1]}\n", + "{0: [2, 0, 3, 1], 1: [2, 3, 0, 1], 2: [1, 3, 0, 2], 3: [2, 1, 0, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 0, 3], 2: [2, 3, 0, 1], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 0, 1], 1: [0, 2, 1, 3], 2: [2, 1, 3, 0], 3: [3, 2, 0, 1]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 1, 0], 2: [0, 2, 3, 1], 3: [0, 3, 2, 1]}\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 3, 1], 2: [1, 2, 3, 0], 3: [1, 3, 2, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 1, 2, 3], 1: [0, 3, 1, 2], 2: [2, 3, 0, 1], 3: [2, 3, 0, 1]}\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 3, 0], 2: [2, 3, 0, 1], 3: [2, 1, 0, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 1, 2, 0], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [0, 1, 2, 3]}\n", + "{0: [0, 1, 2, 3], 1: [2, 1, 3, 0], 2: [3, 0, 1, 2], 3: [0, 1, 3, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 3, 1], 2: [0, 1, 3, 2], 3: [1, 2, 3, 0]}\n", + "{0: [1, 0, 2, 3], 1: [0, 1, 3, 2], 2: [2, 1, 3, 0], 3: [3, 1, 2, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 3, 1, 0], 1: [0, 3, 2, 1], 2: [2, 1, 3, 0], 3: [2, 0, 1, 3]}\n", + "{0: [3, 0, 2, 1], 1: [0, 1, 3, 2], 2: [2, 3, 0, 1], 3: [1, 0, 2, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 0, 1, 2], 1: [3, 2, 1, 0], 2: [3, 0, 1, 2], 3: [3, 0, 1, 2]}\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 2, 0], 2: [3, 2, 1, 0], 3: [0, 1, 2, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 0, 1], 2: [3, 1, 0, 2], 3: [3, 2, 1, 0]}\n", + "{0: [3, 2, 0, 1], 1: [3, 0, 1, 2], 2: [1, 0, 3, 2], 3: [1, 3, 2, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [3, 1, 2, 0], 3: [0, 3, 2, 1]}\n", + "{0: [2, 3, 0, 1], 1: [0, 2, 3, 1], 2: [3, 0, 1, 2], 3: [0, 3, 2, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 0, 2], 2: [0, 1, 3, 2], 3: [3, 0, 1, 2]}\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 2, 0], 2: [0, 1, 3, 2], 3: [1, 2, 3, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 1, 2, 0], 1: [1, 3, 2, 0], 2: [0, 1, 2, 3], 3: [0, 3, 2, 1]}\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 1, 3], 2: [3, 1, 0, 2], 3: [3, 2, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 2, 3], 2: [3, 0, 1, 2], 3: [0, 2, 1, 3]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [0, 1, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 0, 3, 2], 1: [0, 1, 2, 3], 2: [0, 2, 1, 3], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 2, 0], 1: [1, 0, 3, 2], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 1, 0, 2], 1: [3, 2, 1, 0], 2: [1, 0, 2, 3], 3: [3, 2, 1, 0]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 2, 3], 2: [0, 3, 2, 1], 3: [3, 1, 0, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 2, 0], 2: [2, 0, 3, 1], 3: [2, 1, 3, 0]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 3, 1], 2: [2, 1, 0, 3], 3: [1, 3, 0, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 3, 2, 1], 1: [2, 3, 0, 1], 2: [3, 2, 1, 0], 3: [1, 3, 0, 2]}\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 1, 3], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 3, 1, 2], 1: [3, 1, 0, 2], 2: [1, 3, 2, 0], 3: [0, 3, 1, 2]}\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 0, 1], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 0, 3, 2], 1: [2, 0, 1, 3], 2: [2, 3, 0, 1], 3: [3, 2, 0, 1]}\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 1, 3], 2: [3, 0, 2, 1], 3: [0, 2, 1, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 0, 2], 2: [1, 3, 0, 2], 3: [2, 0, 1, 3]}\n", + "{0: [3, 0, 2, 1], 1: [0, 3, 2, 1], 2: [1, 3, 0, 2], 3: [1, 2, 0, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [1, 2, 0, 3], 1: [2, 1, 0, 3], 2: [0, 2, 3, 1], 3: [1, 2, 3, 0]}\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 0, 3], 2: [1, 2, 0, 3], 3: [3, 2, 0, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 1, 0], 2: [2, 0, 1, 3], 3: [2, 1, 3, 0]}\n", + "{0: [0, 1, 3, 2], 1: [2, 3, 1, 0], 2: [3, 0, 1, 2], 3: [3, 0, 2, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 3, 0], 2: [3, 0, 2, 1], 3: [0, 1, 2, 3]}\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 0, 1], 2: [3, 0, 1, 2], 3: [2, 0, 1, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 3, 2], 2: [2, 3, 0, 1], 3: [1, 0, 2, 3]}\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [1, 0, 2, 3], 3: [0, 3, 2, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 1, 2, 3], 1: [1, 0, 2, 3], 2: [1, 3, 2, 0], 3: [3, 0, 2, 1]}\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 1, 2], 2: [1, 2, 3, 0], 3: [3, 2, 1, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 3, 1, 0], 1: [1, 0, 3, 2], 2: [3, 0, 2, 1], 3: [0, 3, 2, 1]}\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 0, 3], 2: [2, 1, 3, 0], 3: [1, 3, 2, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 2, 0], 2: [2, 0, 3, 1], 3: [0, 1, 3, 2]}\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 3, 0], 2: [3, 1, 2, 0], 3: [1, 3, 2, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 1, 2, 0], 1: [0, 1, 2, 3], 2: [3, 0, 2, 1], 3: [2, 1, 0, 3]}\n", + "{0: [3, 2, 0, 1], 1: [3, 2, 0, 1], 2: [1, 2, 0, 3], 3: [1, 2, 0, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [0, 1, 2, 3], 3: [3, 1, 0, 2]}\n", + "{0: [2, 0, 3, 1], 1: [3, 0, 1, 2], 2: [0, 2, 1, 3], 3: [1, 3, 2, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 0, 3], 2: [0, 3, 2, 1], 3: [0, 2, 3, 1]}\n", + "{0: [1, 3, 2, 0], 1: [3, 2, 0, 1], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 2, 0, 1], 1: [0, 2, 3, 1], 2: [2, 3, 0, 1], 3: [3, 1, 0, 2]}\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 2, 1], 2: [3, 1, 2, 0], 3: [0, 2, 3, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 2, 0], 2: [2, 0, 1, 3], 3: [1, 2, 0, 3]}\n", + "{0: [3, 0, 2, 1], 1: [0, 3, 1, 2], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 2, 1, 3], 1: [3, 0, 1, 2], 2: [2, 3, 1, 0], 3: [1, 0, 3, 2]}\n", + "{0: [1, 3, 0, 2], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [3, 1, 0, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 0, 3], 2: [2, 1, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 0, 1], 1: [2, 1, 0, 3], 2: [1, 0, 3, 2], 3: [2, 0, 1, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 0, 2, 3], 1: [2, 3, 1, 0], 2: [1, 2, 3, 0], 3: [0, 1, 2, 3]}\n", + "{0: [3, 2, 1, 0], 1: [0, 2, 3, 1], 2: [0, 1, 2, 3], 3: [0, 1, 3, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [3, 0, 1, 2], 1: [2, 3, 0, 1], 2: [1, 2, 0, 3], 3: [1, 3, 0, 2]}\n", + "{0: [3, 0, 2, 1], 1: [0, 2, 1, 3], 2: [3, 1, 0, 2], 3: [1, 3, 2, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [0, 2, 3, 1], 2: [1, 0, 3, 2], 3: [3, 1, 0, 2]}\n", + "{0: [0, 2, 3, 1], 1: [2, 1, 0, 3], 2: [3, 1, 0, 2], 3: [3, 1, 2, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 0, 2], 2: [3, 2, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [3, 0, 2, 1], 1: [3, 0, 2, 1], 2: [2, 1, 3, 0], 3: [1, 0, 2, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 2, 3], 2: [2, 3, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 0, 2], 2: [1, 0, 2, 3], 3: [3, 0, 1, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 1, 2, 3], 1: [2, 3, 0, 1], 2: [1, 0, 2, 3], 3: [0, 2, 3, 1]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 3, 2], 2: [2, 0, 1, 3], 3: [3, 2, 0, 1]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 3, 0], 2: [0, 3, 1, 2], 3: [3, 2, 1, 0]}\n", + "{0: [1, 3, 0, 2], 1: [3, 2, 0, 1], 2: [0, 1, 3, 2], 3: [0, 2, 3, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [2, 0, 1, 3], 3: [3, 1, 2, 0]}\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 2, 3], 2: [2, 3, 1, 0], 3: [3, 2, 1, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 1, 3, 0], 1: [2, 3, 0, 1], 2: [2, 1, 0, 3], 3: [0, 2, 1, 3]}\n", + "{0: [3, 1, 0, 2], 1: [3, 0, 1, 2], 2: [1, 3, 2, 0], 3: [1, 3, 2, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 3, 2, 1], 1: [0, 1, 3, 2], 2: [1, 2, 3, 0], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [1, 3, 0, 2], 3: [1, 3, 0, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 1, 2], 2: [2, 1, 0, 3], 3: [1, 2, 3, 0]}\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 2, 1], 2: [0, 2, 1, 3], 3: [3, 1, 2, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 0, 2], 2: [2, 0, 3, 1], 3: [0, 1, 2, 3]}\n", + "{0: [0, 2, 1, 3], 1: [0, 1, 2, 3], 2: [2, 1, 0, 3], 3: [0, 1, 2, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 2, 1], 2: [1, 3, 0, 2], 3: [0, 1, 3, 2]}\n", + "{0: [1, 0, 3, 2], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [3, 0, 1, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 3, 0], 2: [2, 0, 3, 1], 3: [1, 3, 2, 0]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [0, 3, 1, 2], 3: [2, 3, 1, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 1, 2], 2: [3, 0, 1, 2], 3: [2, 3, 0, 1]}\n", + "{0: [1, 2, 0, 3], 1: [3, 0, 1, 2], 2: [1, 3, 2, 0], 3: [1, 3, 2, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [2, 0, 3, 1], 2: [1, 0, 3, 2], 3: [0, 1, 2, 3]}\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 3, 2, 1], 1: [1, 0, 3, 2], 2: [2, 0, 1, 3], 3: [3, 2, 1, 0]}\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 2, 3], 2: [1, 3, 2, 0], 3: [0, 1, 3, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 2, 0], 2: [3, 0, 1, 2], 3: [0, 3, 1, 2]}\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 1, 2], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 0, 3], 2: [0, 1, 2, 3], 3: [1, 3, 2, 0]}\n", + "{0: [2, 1, 3, 0], 1: [2, 3, 1, 0], 2: [2, 1, 0, 3], 3: [0, 2, 1, 3]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 1, 2, 0], 1: [0, 1, 2, 3], 2: [3, 0, 2, 1], 3: [1, 3, 0, 2]}\n", + "{0: [2, 1, 0, 3], 1: [2, 0, 3, 1], 2: [0, 3, 2, 1], 3: [3, 1, 0, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 3, 0, 1], 1: [1, 2, 3, 0], 2: [0, 1, 2, 3], 3: [2, 3, 0, 1]}\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 2, 0], 2: [3, 1, 0, 2], 3: [0, 1, 2, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 2, 0], 2: [2, 3, 0, 1], 3: [3, 1, 2, 0]}\n", + "{0: [3, 0, 2, 1], 1: [0, 2, 1, 3], 2: [2, 3, 0, 1], 3: [0, 1, 3, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 0, 3], 2: [0, 2, 1, 3], 3: [2, 1, 3, 0]}\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 0, 2], 2: [0, 3, 2, 1], 3: [2, 0, 1, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [1, 0, 3, 2], 1: [2, 1, 3, 0], 2: [2, 0, 1, 3], 3: [2, 3, 0, 1]}\n", + "{0: [1, 0, 2, 3], 1: [1, 0, 2, 3], 2: [1, 2, 0, 3], 3: [2, 0, 1, 3]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 0, 2, 1], 1: [3, 0, 2, 1], 2: [0, 1, 3, 2], 3: [2, 0, 3, 1]}\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 0, 3], 2: [2, 1, 0, 3], 3: [1, 2, 3, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 2, 3], 2: [1, 2, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 1, 2], 2: [2, 0, 1, 3], 3: [1, 2, 0, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [0, 2, 1, 3]}\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [3, 0, 2, 1], 3: [0, 3, 2, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 1, 3], 2: [0, 2, 3, 1], 3: [0, 2, 1, 3]}\n", + "{0: [3, 0, 1, 2], 1: [2, 3, 0, 1], 2: [0, 3, 1, 2], 3: [1, 0, 3, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [1, 3, 2, 0], 2: [3, 1, 2, 0], 3: [2, 1, 0, 3]}\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 1, 2], 2: [1, 0, 3, 2], 3: [3, 0, 1, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 3, 1], 2: [2, 0, 3, 1], 3: [0, 2, 1, 3]}\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [2, 0, 1, 3], 3: [0, 1, 2, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 0, 1], 2: [0, 2, 3, 1], 3: [3, 2, 1, 0]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 3, 2], 2: [0, 2, 1, 3], 3: [3, 1, 2, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 1, 2], 2: [0, 3, 2, 1], 3: [0, 3, 2, 1]}\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 1, 3], 2: [2, 0, 1, 3], 3: [2, 1, 3, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 1, 2], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [1, 2, 0, 3], 3: [3, 2, 0, 1]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 0, 3], 2: [1, 3, 0, 2], 3: [1, 3, 0, 2]}\n", + "{0: [3, 2, 0, 1], 1: [1, 2, 0, 3], 2: [0, 2, 1, 3], 3: [0, 1, 3, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 2, 0], 2: [0, 3, 2, 1], 3: [0, 2, 3, 1]}\n", + "{0: [1, 0, 3, 2], 1: [1, 3, 0, 2], 2: [3, 0, 2, 1], 3: [0, 3, 1, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 1, 3], 2: [3, 0, 2, 1], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [3, 2, 1, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 3, 0, 2], 1: [1, 3, 2, 0], 2: [0, 2, 1, 3], 3: [3, 2, 1, 0]}\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 3, 0], 2: [1, 3, 2, 0], 3: [2, 0, 3, 1]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 3, 2], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [0, 2, 1, 3]}\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 0, 1], 2: [3, 1, 2, 0], 3: [1, 0, 3, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 3, 2], 2: [0, 1, 2, 3], 3: [0, 3, 1, 2]}\n", + "{0: [3, 2, 0, 1], 1: [2, 0, 1, 3], 2: [0, 3, 1, 2], 3: [2, 3, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 3, 2], 1: [2, 1, 3, 0], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 0, 2], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 0, 2], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 3, 2], 2: [3, 0, 2, 1], 3: [0, 1, 2, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 0, 3, 2], 1: [1, 3, 2, 0], 2: [3, 2, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 1, 3], 2: [1, 0, 2, 3], 3: [0, 2, 1, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 1, 3, 2], 1: [2, 1, 0, 3], 2: [1, 2, 0, 3], 3: [2, 0, 3, 1]}\n", + "{0: [3, 1, 2, 0], 1: [2, 1, 3, 0], 2: [2, 3, 1, 0], 3: [3, 1, 2, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 3, 2, 0], 1: [2, 1, 3, 0], 2: [1, 2, 3, 0], 3: [1, 0, 3, 2]}\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 3, 2], 2: [2, 0, 3, 1], 3: [1, 3, 2, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 2, 1, 3], 1: [2, 3, 0, 1], 2: [0, 1, 2, 3], 3: [0, 2, 3, 1]}\n", + "{0: [0, 3, 1, 2], 1: [3, 2, 1, 0], 2: [3, 1, 0, 2], 3: [2, 0, 1, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 1, 2], 2: [0, 3, 2, 1], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 0, 1], 2: [3, 2, 1, 0], 3: [0, 1, 2, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 3, 1, 0], 1: [0, 1, 2, 3], 2: [0, 1, 3, 2], 3: [3, 1, 2, 0]}\n", + "{0: [0, 1, 3, 2], 1: [0, 3, 2, 1], 2: [3, 0, 2, 1], 3: [1, 0, 2, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 3, 1, 0], 1: [3, 0, 1, 2], 2: [0, 3, 2, 1], 3: [1, 2, 0, 3]}\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 1, 2], 2: [1, 2, 3, 0], 3: [2, 1, 3, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 2, 1], 2: [2, 3, 1, 0], 3: [0, 1, 2, 3]}\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 1, 3], 2: [2, 3, 0, 1], 3: [3, 2, 0, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 0, 2, 3], 1: [0, 3, 2, 1], 2: [3, 0, 2, 1], 3: [3, 1, 0, 2]}\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 3, 1], 2: [3, 0, 1, 2], 3: [1, 2, 3, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [1, 2, 3, 0], 1: [2, 1, 0, 3], 2: [1, 2, 3, 0], 3: [0, 3, 1, 2]}\n", + "{0: [3, 0, 2, 1], 1: [2, 3, 0, 1], 2: [2, 3, 1, 0], 3: [0, 3, 1, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [1, 2, 3, 0], 2: [0, 2, 1, 3], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 0, 2], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [0, 2, 1, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 2, 1, 0], 1: [3, 2, 0, 1], 2: [1, 2, 3, 0], 3: [0, 3, 2, 1]}\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 0, 1], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 0, 3], 2: [0, 1, 2, 3], 3: [0, 3, 1, 2]}\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 1, 3], 2: [0, 3, 1, 2], 3: [0, 2, 1, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 3, 0, 1], 1: [2, 0, 1, 3], 2: [0, 1, 2, 3], 3: [3, 0, 1, 2]}\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 0, 1], 2: [2, 3, 0, 1], 3: [3, 1, 2, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 3, 0], 2: [0, 2, 1, 3], 3: [2, 0, 1, 3]}\n", + "{0: [1, 3, 2, 0], 1: [1, 0, 2, 3], 2: [2, 3, 0, 1], 3: [3, 2, 0, 1]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 3, 0], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 3, 0], 2: [2, 3, 0, 1], 3: [1, 2, 3, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [1, 3, 0, 2], 3: [2, 0, 1, 3]}\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [0, 2, 3, 1], 3: [3, 2, 0, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 3, 2, 1], 1: [2, 3, 1, 0], 2: [1, 2, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [2, 0, 1, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 0, 1], 2: [0, 3, 2, 1], 3: [2, 0, 3, 1]}\n", + "{0: [0, 2, 1, 3], 1: [1, 0, 3, 2], 2: [1, 3, 2, 0], 3: [3, 0, 2, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 2, 3, 0], 1: [1, 3, 0, 2], 2: [1, 3, 0, 2], 3: [1, 2, 0, 3]}\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 3, 2], 2: [0, 2, 3, 1], 3: [3, 2, 1, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 3, 0, 1], 1: [3, 1, 0, 2], 2: [3, 2, 0, 1], 3: [2, 0, 1, 3]}\n", + "{0: [0, 2, 1, 3], 1: [1, 3, 2, 0], 2: [1, 2, 3, 0], 3: [0, 3, 1, 2]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 3, 1], 2: [0, 2, 3, 1], 3: [2, 3, 1, 0]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 3, 0], 2: [0, 3, 1, 2], 3: [0, 2, 1, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 1, 0], 2: [0, 2, 3, 1], 3: [0, 3, 1, 2]}\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 2, 0], 2: [0, 1, 2, 3], 3: [3, 1, 2, 0]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 1, 3], 2: [2, 3, 0, 1], 3: [0, 3, 1, 2]}\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 1, 2], 2: [0, 1, 2, 3], 3: [3, 2, 0, 1]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 3, 1, 0], 1: [1, 3, 2, 0], 2: [2, 1, 3, 0], 3: [1, 0, 3, 2]}\n", + "{0: [2, 3, 1, 0], 1: [2, 0, 3, 1], 2: [2, 1, 0, 3], 3: [1, 2, 3, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 0, 2, 1], 1: [0, 2, 1, 3], 2: [0, 2, 3, 1], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 1, 0], 1: [0, 2, 3, 1], 2: [1, 0, 2, 3], 3: [0, 1, 2, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [3, 2, 1, 0], 2: [3, 1, 0, 2], 3: [3, 2, 0, 1]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 1, 2], 2: [1, 0, 2, 3], 3: [2, 0, 3, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 2, 0], 2: [1, 0, 2, 3], 3: [3, 0, 1, 2]}\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 2, 1], 2: [2, 1, 0, 3], 3: [3, 0, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [1, 2, 0, 3]}\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 3, 1], 2: [1, 3, 0, 2], 3: [0, 2, 3, 1]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 1, 2, 0], 1: [0, 2, 1, 3], 2: [0, 2, 3, 1], 3: [3, 2, 1, 0]}\n", + "{0: [0, 3, 1, 2], 1: [3, 2, 0, 1], 2: [1, 2, 3, 0], 3: [0, 1, 2, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 3, 2], 2: [1, 2, 0, 3], 3: [2, 0, 1, 3]}\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 1, 2], 2: [1, 3, 2, 0], 3: [1, 0, 2, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 2, 3], 2: [0, 1, 2, 3], 3: [1, 0, 2, 3]}\n", + "{0: [1, 3, 2, 0], 1: [3, 2, 1, 0], 2: [2, 0, 1, 3], 3: [0, 2, 1, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 1, 2], 1: [3, 0, 1, 2], 2: [3, 0, 2, 1], 3: [3, 1, 2, 0]}\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 0, 3], 2: [0, 1, 2, 3], 3: [2, 3, 0, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 3, 0, 1], 1: [0, 2, 3, 1], 2: [2, 3, 1, 0], 3: [0, 3, 1, 2]}\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 3, 2], 2: [0, 2, 1, 3], 3: [0, 2, 3, 1]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [3, 2, 1, 0], 1: [1, 3, 0, 2], 2: [0, 3, 1, 2], 3: [3, 0, 2, 1]}\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 1, 3], 2: [1, 2, 0, 3], 3: [0, 2, 3, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 0, 2], 2: [1, 0, 2, 3], 3: [0, 1, 3, 2]}\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 3, 1], 2: [1, 3, 0, 2], 3: [0, 2, 3, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 1, 3, 2], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [0, 3, 2, 1]}\n", + "{0: [0, 2, 3, 1], 1: [0, 2, 1, 3], 2: [0, 2, 1, 3], 3: [0, 1, 2, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 2, 3], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "{0: [1, 0, 3, 2], 1: [3, 1, 0, 2], 2: [3, 1, 2, 0], 3: [3, 1, 0, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [1, 2, 0, 3]}\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 2, 3], 2: [0, 3, 2, 1], 3: [2, 1, 3, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 2, 1], 2: [2, 1, 3, 0], 3: [1, 2, 0, 3]}\n", + "{0: [2, 3, 1, 0], 1: [1, 0, 2, 3], 2: [3, 1, 0, 2], 3: [0, 3, 2, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [3, 0, 1, 2], 2: [1, 3, 0, 2], 3: [1, 0, 3, 2]}\n", + "{0: [2, 0, 3, 1], 1: [3, 2, 0, 1], 2: [0, 2, 3, 1], 3: [2, 0, 3, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 3, 2], 2: [2, 0, 3, 1], 3: [1, 2, 3, 0]}\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [2, 0, 1, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [2, 0, 1, 3], 2: [3, 1, 0, 2], 3: [0, 1, 3, 2]}\n", + "{0: [0, 2, 1, 3], 1: [3, 1, 2, 0], 2: [1, 2, 3, 0], 3: [1, 0, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 3, 2], 2: [1, 2, 0, 3], 3: [2, 1, 0, 3]}\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 2, 1], 2: [0, 2, 1, 3], 3: [0, 2, 3, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 0, 2], 2: [0, 3, 2, 1], 3: [0, 2, 1, 3]}\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 0, 3], 2: [0, 1, 3, 2], 3: [2, 1, 3, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 0, 2], 2: [3, 1, 0, 2], 3: [2, 0, 1, 3]}\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 1, 0], 2: [1, 3, 0, 2], 3: [2, 1, 3, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 0, 3], 2: [1, 0, 2, 3], 3: [3, 0, 1, 2]}\n", + "{0: [1, 0, 3, 2], 1: [1, 0, 3, 2], 2: [2, 0, 3, 1], 3: [1, 0, 3, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "{0: [3, 0, 1, 2], 1: [0, 3, 1, 2], 2: [3, 1, 2, 0], 3: [0, 1, 2, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 1, 2], 2: [3, 2, 0, 1], 3: [2, 3, 0, 1]}\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 3, 0], 2: [2, 3, 1, 0], 3: [0, 2, 1, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 1, 2, 3], 1: [2, 1, 0, 3], 2: [2, 1, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [0, 2, 1, 3], 1: [3, 0, 2, 1], 2: [1, 0, 2, 3], 3: [1, 3, 0, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 0, 3, 2], 1: [3, 1, 2, 0], 2: [0, 2, 3, 1], 3: [3, 2, 0, 1]}\n", + "{0: [2, 1, 3, 0], 1: [1, 2, 3, 0], 2: [2, 1, 0, 3], 3: [1, 0, 2, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 1, 2], 2: [2, 1, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [3, 0, 1, 2]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 0, 3], 2: [3, 0, 1, 2], 3: [2, 0, 1, 3]}\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 3, 1], 2: [2, 0, 1, 3], 3: [3, 0, 2, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 3, 1, 2], 1: [1, 3, 0, 2], 2: [3, 1, 0, 2], 3: [3, 1, 2, 0]}\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 1, 2], 2: [2, 0, 3, 1], 3: [0, 3, 2, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 3, 0], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [2, 1, 3, 0], 1: [3, 1, 2, 0], 2: [2, 3, 1, 0], 3: [1, 3, 0, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 2, 3, 0], 1: [2, 1, 3, 0], 2: [1, 3, 0, 2], 3: [3, 1, 0, 2]}\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 1, 3], 2: [1, 3, 0, 2], 3: [2, 1, 0, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 0, 3], 2: [3, 2, 1, 0], 3: [0, 1, 2, 3]}\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 1, 3], 2: [3, 0, 1, 2], 3: [1, 3, 2, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 1, 0], 2: [1, 2, 3, 0], 3: [1, 2, 0, 3]}\n", + "{0: [1, 0, 3, 2], 1: [2, 1, 0, 3], 2: [1, 0, 2, 3], 3: [3, 1, 2, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 0, 1], 2: [2, 1, 0, 3], 3: [0, 2, 1, 3]}\n", + "{0: [1, 2, 3, 0], 1: [0, 3, 2, 1], 2: [3, 0, 2, 1], 3: [0, 2, 3, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 1, 3, 2], 1: [0, 2, 3, 1], 2: [2, 3, 0, 1], 3: [0, 1, 2, 3]}\n", + "{0: [0, 2, 1, 3], 1: [0, 2, 3, 1], 2: [0, 3, 2, 1], 3: [0, 1, 3, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 0, 2], 2: [2, 3, 0, 1], 3: [0, 2, 3, 1]}\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 3, 1], 2: [0, 2, 3, 1], 3: [0, 1, 3, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 3, 1], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "{0: [0, 3, 2, 1], 1: [2, 3, 0, 1], 2: [2, 3, 1, 0], 3: [1, 0, 3, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 2, 0], 2: [2, 3, 1, 0], 3: [3, 0, 1, 2]}\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 3, 1], 2: [2, 1, 0, 3], 3: [3, 1, 0, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 3, 2, 1], 1: [1, 2, 0, 3], 2: [2, 1, 3, 0], 3: [0, 3, 1, 2]}\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 0, 3], 2: [2, 0, 3, 1], 3: [2, 0, 1, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 0, 2], 2: [2, 3, 0, 1], 3: [3, 1, 2, 0]}\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [2, 1, 0, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 1, 3], 2: [3, 1, 2, 0], 3: [2, 1, 0, 3]}\n", + "{0: [0, 1, 3, 2], 1: [3, 0, 1, 2], 2: [2, 1, 3, 0], 3: [0, 3, 2, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 0, 1], 2: [3, 2, 1, 0], 3: [1, 2, 3, 0]}\n", + "{0: [3, 0, 2, 1], 1: [2, 3, 1, 0], 2: [2, 0, 1, 3], 3: [0, 2, 1, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 3, 1, 2], 1: [0, 2, 3, 1], 2: [3, 2, 0, 1], 3: [1, 2, 0, 3]}\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 2, 1], 2: [0, 3, 2, 1], 3: [1, 2, 0, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 0, 1, 2], 1: [3, 2, 0, 1], 2: [2, 1, 0, 3], 3: [3, 2, 0, 1]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [1, 3, 2, 0], 3: [0, 2, 1, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 3, 0, 2], 1: [2, 0, 1, 3], 2: [3, 0, 1, 2], 3: [3, 2, 1, 0]}\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 1, 3], 2: [3, 1, 2, 0], 3: [2, 3, 1, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 0, 1, 3], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [3, 2, 1, 0]}\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 3, 0], 2: [2, 1, 0, 3], 3: [2, 3, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [0, 2, 3, 1]}\n", + "{0: [2, 1, 3, 0], 1: [2, 3, 1, 0], 2: [2, 3, 0, 1], 3: [0, 1, 2, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 3, 0, 1], 1: [1, 0, 2, 3], 2: [2, 3, 1, 0], 3: [0, 2, 1, 3]}\n", + "{0: [2, 3, 0, 1], 1: [0, 2, 3, 1], 2: [0, 3, 1, 2], 3: [0, 1, 3, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 1, 2], 2: [1, 3, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 3, 0, 2], 1: [3, 0, 1, 2], 2: [1, 0, 3, 2], 3: [0, 2, 3, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 1, 3, 2], 1: [2, 3, 1, 0], 2: [1, 0, 3, 2], 3: [3, 1, 2, 0]}\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 1, 0], 2: [1, 2, 0, 3], 3: [0, 3, 1, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 2, 0], 2: [1, 3, 2, 0], 3: [1, 2, 0, 3]}\n", + "{0: [2, 3, 1, 0], 1: [3, 1, 2, 0], 2: [2, 0, 1, 3], 3: [1, 0, 2, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 0, 3], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [2, 0, 1, 3], 1: [0, 3, 2, 1], 2: [1, 2, 0, 3], 3: [1, 2, 0, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 2, 0], 2: [2, 3, 0, 1], 3: [3, 0, 2, 1]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [1, 2, 0, 3], 3: [2, 0, 1, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 2, 3, 0], 1: [2, 3, 0, 1], 2: [3, 0, 1, 2], 3: [0, 2, 1, 3]}\n", + "{0: [2, 0, 1, 3], 1: [2, 0, 1, 3], 2: [3, 1, 2, 0], 3: [3, 0, 1, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 0, 3, 1], 1: [1, 2, 0, 3], 2: [2, 1, 3, 0], 3: [3, 0, 1, 2]}\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 2, 0], 2: [1, 3, 2, 0], 3: [0, 2, 1, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 2, 1, 3], 1: [2, 3, 1, 0], 2: [2, 3, 0, 1], 3: [1, 2, 0, 3]}\n", + "{0: [0, 1, 3, 2], 1: [3, 0, 1, 2], 2: [1, 3, 0, 2], 3: [3, 1, 0, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 1, 2, 0], 1: [0, 2, 3, 1], 2: [0, 2, 1, 3], 3: [1, 3, 0, 2]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 1, 0], 2: [3, 0, 1, 2], 3: [3, 1, 2, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 2, 3], 2: [1, 2, 0, 3], 3: [3, 0, 1, 2]}\n", + "{0: [3, 1, 0, 2], 1: [1, 0, 3, 2], 2: [0, 3, 1, 2], 3: [2, 1, 0, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 3, 2], 2: [2, 3, 0, 1], 3: [2, 3, 1, 0]}\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 1, 3], 2: [0, 2, 3, 1], 3: [2, 1, 0, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 2, 3], 2: [1, 2, 3, 0], 3: [0, 1, 3, 2]}\n", + "{0: [3, 1, 2, 0], 1: [1, 0, 3, 2], 2: [2, 3, 1, 0], 3: [3, 0, 2, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 3, 1], 2: [3, 0, 2, 1], 3: [0, 1, 3, 2]}\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 1, 3], 2: [1, 2, 0, 3], 3: [0, 1, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [3, 1, 2, 0], 1: [1, 0, 2, 3], 2: [1, 3, 0, 2], 3: [1, 2, 0, 3]}\n", + "{0: [2, 3, 0, 1], 1: [3, 1, 2, 0], 2: [1, 0, 2, 3], 3: [0, 3, 2, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [1, 3, 2, 0]}\n", + "{0: [2, 1, 3, 0], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [3, 0, 1, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 2, 3], 2: [2, 3, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 1, 3], 2: [1, 0, 2, 3], 3: [1, 2, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 1, 3], 2: [1, 2, 3, 0], 3: [3, 0, 1, 2]}\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [3, 2, 1, 0], 3: [2, 0, 3, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 0, 3], 2: [0, 3, 2, 1], 3: [1, 0, 3, 2]}\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 3, 0], 2: [3, 2, 0, 1], 3: [1, 2, 0, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 0, 2], 2: [3, 2, 1, 0], 3: [1, 0, 3, 2]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 2, 0], 2: [3, 1, 0, 2], 3: [3, 1, 2, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 1, 0], 2: [0, 1, 3, 2], 3: [0, 1, 3, 2]}\n", + "{0: [2, 0, 3, 1], 1: [2, 3, 0, 1], 2: [0, 2, 1, 3], 3: [0, 3, 2, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 1, 0, 2], 1: [1, 3, 2, 0], 2: [3, 0, 2, 1], 3: [0, 1, 3, 2]}\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 2, 3], 2: [3, 1, 0, 2], 3: [3, 0, 1, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 0, 1, 3], 1: [3, 2, 1, 0], 2: [0, 3, 2, 1], 3: [2, 1, 0, 3]}\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 2, 3], 2: [3, 0, 2, 1], 3: [3, 1, 2, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 3, 0, 1], 1: [3, 1, 2, 0], 2: [3, 1, 0, 2], 3: [0, 1, 3, 2]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [3, 1, 2, 0], 3: [0, 1, 3, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [0, 1, 3, 2], 3: [1, 3, 0, 2]}\n", + "{0: [0, 1, 3, 2], 1: [3, 0, 2, 1], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 3, 1], 2: [3, 2, 0, 1], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 2, 0], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 2, 1], 1: [2, 0, 3, 1], 2: [3, 1, 2, 0], 3: [0, 1, 2, 3]}\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [2, 0, 1, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 3, 2], 2: [3, 1, 0, 2], 3: [1, 3, 0, 2]}\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 0, 1], 2: [0, 3, 2, 1], 3: [3, 2, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [3, 1, 0, 2], 3: [0, 2, 3, 1]}\n", + "{0: [0, 1, 2, 3], 1: [2, 1, 0, 3], 2: [3, 0, 2, 1], 3: [1, 2, 0, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 3, 2], 1: [3, 1, 2, 0], 2: [0, 3, 2, 1], 3: [1, 2, 3, 0]}\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 1, 0], 2: [1, 0, 3, 2], 3: [0, 1, 2, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 1, 3, 0], 1: [3, 2, 0, 1], 2: [3, 0, 1, 2], 3: [1, 2, 0, 3]}\n", + "{0: [0, 3, 2, 1], 1: [2, 3, 0, 1], 2: [1, 3, 0, 2], 3: [0, 3, 2, 1]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 2, 1, 3], 1: [0, 1, 3, 2], 2: [3, 1, 0, 2], 3: [3, 2, 1, 0]}\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [0, 1, 3, 2], 3: [2, 3, 1, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 3, 0], 2: [2, 0, 3, 1], 3: [0, 1, 2, 3]}\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 2, 0], 2: [2, 0, 1, 3], 3: [0, 2, 1, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 2, 3, 1], 1: [3, 0, 1, 2], 2: [3, 2, 0, 1], 3: [1, 3, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [1, 0, 3, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 1, 2, 0], 1: [0, 3, 2, 1], 2: [3, 1, 2, 0], 3: [3, 1, 0, 2]}\n", + "{0: [1, 3, 2, 0], 1: [0, 2, 3, 1], 2: [2, 1, 0, 3], 3: [1, 3, 0, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 2, 1, 0], 1: [2, 1, 3, 0], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 3, 0], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 2, 0], 2: [1, 0, 2, 3], 3: [1, 2, 3, 0]}\n", + "{0: [3, 1, 0, 2], 1: [3, 2, 1, 0], 2: [2, 3, 0, 1], 3: [0, 2, 1, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 1, 2, 0], 1: [1, 0, 3, 2], 2: [2, 3, 1, 0], 3: [0, 1, 3, 2]}\n", + "{0: [0, 3, 2, 1], 1: [2, 3, 1, 0], 2: [0, 2, 1, 3], 3: [3, 0, 1, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 3, 2], 2: [0, 1, 3, 2], 3: [0, 1, 2, 3]}\n", + "{0: [0, 3, 1, 2], 1: [2, 3, 0, 1], 2: [1, 3, 2, 0], 3: [2, 1, 3, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 3, 1], 2: [1, 3, 0, 2], 3: [2, 3, 0, 1]}\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 0, 2], 2: [0, 1, 2, 3], 3: [2, 1, 3, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [3, 2, 0, 1], 1: [3, 2, 1, 0], 2: [3, 2, 0, 1], 3: [2, 3, 0, 1]}\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 1, 3], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 2, 0, 1], 1: [3, 0, 1, 2], 2: [2, 3, 1, 0], 3: [1, 0, 2, 3]}\n", + "{0: [2, 1, 0, 3], 1: [0, 2, 1, 3], 2: [3, 0, 1, 2], 3: [2, 3, 1, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 0, 2, 3], 1: [1, 3, 2, 0], 2: [0, 2, 1, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [2, 0, 1, 3], 3: [3, 2, 1, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 0, 3], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "{0: [0, 3, 1, 2], 1: [0, 2, 1, 3], 2: [0, 2, 3, 1], 3: [2, 3, 1, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 0, 3], 2: [2, 0, 1, 3], 3: [0, 2, 3, 1]}\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 0, 2], 2: [3, 2, 0, 1], 3: [3, 2, 1, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 1, 2, 0], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [1, 2, 3, 0]}\n", + "{0: [1, 2, 3, 0], 1: [0, 2, 3, 1], 2: [2, 3, 1, 0], 3: [3, 1, 0, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 1, 0, 3], 1: [2, 1, 3, 0], 2: [2, 1, 0, 3], 3: [3, 2, 0, 1]}\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 2, 0], 2: [3, 0, 2, 1], 3: [3, 2, 0, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 0, 1, 2], 1: [3, 0, 2, 1], 2: [0, 3, 2, 1], 3: [3, 0, 2, 1]}\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 2, 3], 2: [3, 0, 1, 2], 3: [0, 2, 3, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 3, 2], 2: [0, 3, 1, 2], 3: [3, 1, 2, 0]}\n", + "{0: [0, 2, 1, 3], 1: [2, 0, 1, 3], 2: [3, 0, 1, 2], 3: [3, 2, 1, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 2, 1, 0], 1: [0, 2, 3, 1], 2: [1, 2, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [3, 0, 2, 1], 1: [0, 3, 1, 2], 2: [2, 3, 1, 0], 3: [2, 0, 1, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 1, 2], 2: [0, 2, 3, 1], 3: [2, 3, 0, 1]}\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [2, 0, 1, 3], 3: [3, 1, 2, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 1, 2], 2: [3, 0, 1, 2], 3: [0, 1, 2, 3]}\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [3, 0, 2, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 2, 1, 3], 1: [3, 0, 1, 2], 2: [1, 3, 0, 2], 3: [3, 2, 0, 1]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 0, 3], 2: [2, 0, 1, 3], 3: [2, 1, 0, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 0, 2], 2: [3, 2, 0, 1], 3: [0, 3, 1, 2]}\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 2, 0], 2: [0, 3, 2, 1], 3: [2, 3, 1, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 2, 1, 3], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [3, 1, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 1, 2], 2: [3, 2, 1, 0], 3: [2, 3, 0, 1]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 2, 1], 2: [1, 2, 0, 3], 3: [0, 3, 2, 1]}\n", + "{0: [1, 3, 0, 2], 1: [2, 3, 1, 0], 2: [1, 3, 2, 0], 3: [1, 3, 0, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [3, 0, 1, 2], 3: [0, 1, 2, 3]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 1, 3], 2: [0, 1, 3, 2], 3: [2, 0, 3, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 1, 0], 1: [3, 2, 1, 0], 2: [2, 0, 1, 3], 3: [2, 1, 0, 3]}\n", + "{0: [0, 1, 2, 3], 1: [2, 3, 1, 0], 2: [2, 1, 3, 0], 3: [3, 1, 0, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 1, 0, 3], 1: [1, 0, 3, 2], 2: [1, 3, 0, 2], 3: [3, 0, 2, 1]}\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 1, 0], 2: [0, 1, 2, 3], 3: [0, 3, 1, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 1, 2], 2: [2, 1, 0, 3], 3: [0, 3, 2, 1]}\n", + "{0: [1, 0, 3, 2], 1: [2, 1, 3, 0], 2: [0, 1, 3, 2], 3: [3, 1, 0, 2]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 2, 0], 2: [2, 3, 1, 0], 3: [2, 1, 3, 0]}\n", + "{0: [0, 2, 3, 1], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [1, 2, 3, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 1, 3, 2], 1: [1, 0, 3, 2], 2: [1, 0, 3, 2], 3: [1, 2, 3, 0]}\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [0, 2, 1, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 0, 2], 2: [2, 0, 1, 3], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 0, 3], 1: [3, 1, 2, 0], 2: [0, 2, 1, 3], 3: [2, 3, 0, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 2, 3, 1], 1: [1, 3, 2, 0], 2: [0, 2, 3, 1], 3: [1, 0, 2, 3]}\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [2, 3, 0, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 1, 0, 3], 1: [1, 0, 2, 3], 2: [3, 0, 2, 1], 3: [1, 0, 3, 2]}\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 1, 2], 2: [0, 1, 3, 2], 3: [0, 3, 2, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 0, 2], 2: [0, 1, 2, 3], 3: [0, 2, 1, 3]}\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 1, 0], 2: [0, 2, 1, 3], 3: [1, 0, 3, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 2, 3], 1: [1, 0, 3, 2], 2: [1, 2, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 2, 1], 2: [2, 3, 0, 1], 3: [3, 0, 1, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 3, 2], 2: [1, 3, 0, 2], 3: [1, 3, 0, 2]}\n", + "{0: [0, 3, 1, 2], 1: [2, 3, 0, 1], 2: [0, 1, 2, 3], 3: [2, 3, 1, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 0, 2, 1], 1: [0, 3, 1, 2], 2: [0, 1, 2, 3], 3: [2, 0, 3, 1]}\n", + "{0: [0, 2, 3, 1], 1: [2, 1, 0, 3], 2: [2, 0, 1, 3], 3: [0, 1, 3, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 2, 1], 2: [0, 1, 2, 3], 3: [1, 0, 3, 2]}\n", + "{0: [3, 2, 0, 1], 1: [0, 2, 1, 3], 2: [0, 3, 1, 2], 3: [3, 1, 2, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 1, 2], 2: [0, 3, 2, 1], 3: [0, 1, 3, 2]}\n", + "{0: [3, 2, 0, 1], 1: [0, 1, 3, 2], 2: [2, 3, 0, 1], 3: [0, 2, 3, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 3, 2], 2: [3, 2, 0, 1], 3: [2, 1, 3, 0]}\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 3, 1], 2: [2, 3, 0, 1], 3: [3, 2, 0, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [0, 2, 1, 3], 3: [2, 1, 0, 3]}\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 2, 1], 2: [2, 3, 0, 1], 3: [1, 3, 2, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 1, 0], 2: [3, 2, 0, 1], 3: [1, 2, 3, 0]}\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 3, 1], 2: [3, 0, 1, 2], 3: [2, 1, 3, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 3, 0], 2: [3, 1, 2, 0], 3: [3, 2, 0, 1]}\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [3, 1, 2, 0], 3: [3, 2, 1, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 2, 3], 2: [0, 3, 1, 2], 3: [0, 3, 2, 1]}\n", + "{0: [1, 0, 3, 2], 1: [3, 0, 1, 2], 2: [0, 1, 2, 3], 3: [3, 1, 2, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 0, 1, 2], 1: [2, 3, 0, 1], 2: [2, 1, 3, 0], 3: [1, 2, 3, 0]}\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 0, 1], 2: [0, 2, 3, 1], 3: [2, 0, 1, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 0, 3, 2], 1: [2, 0, 3, 1], 2: [0, 3, 2, 1], 3: [1, 0, 2, 3]}\n", + "{0: [2, 1, 0, 3], 1: [2, 1, 0, 3], 2: [0, 3, 1, 2], 3: [0, 3, 2, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 2, 3], 2: [0, 3, 2, 1], 3: [2, 1, 0, 3]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 2, 3], 2: [2, 1, 0, 3], 3: [1, 0, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 0, 3, 1], 1: [2, 3, 0, 1], 2: [2, 3, 1, 0], 3: [3, 0, 1, 2]}\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 3, 2], 2: [2, 0, 3, 1], 3: [3, 0, 2, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 1, 0, 2], 1: [3, 0, 1, 2], 2: [0, 3, 2, 1], 3: [1, 0, 3, 2]}\n", + "{0: [2, 0, 3, 1], 1: [1, 0, 3, 2], 2: [0, 2, 1, 3], 3: [3, 2, 1, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 2, 0, 3], 1: [3, 1, 0, 2], 2: [1, 2, 3, 0], 3: [3, 2, 0, 1]}\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 0, 1], 2: [2, 3, 1, 0], 3: [2, 3, 0, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 0, 1, 3], 1: [1, 3, 0, 2], 2: [3, 1, 2, 0], 3: [0, 3, 2, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 2, 3, 0], 2: [2, 0, 3, 1], 3: [2, 1, 3, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 3, 1, 2], 1: [0, 1, 2, 3], 2: [3, 1, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [2, 1, 0, 3], 1: [0, 2, 3, 1], 2: [3, 2, 1, 0], 3: [2, 1, 3, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 1, 2, 3], 1: [1, 2, 3, 0], 2: [0, 3, 2, 1], 3: [0, 3, 2, 1]}\n", + "{0: [1, 0, 2, 3], 1: [3, 1, 0, 2], 2: [2, 3, 0, 1], 3: [0, 3, 2, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 3, 1, 2], 1: [0, 1, 2, 3], 2: [1, 3, 0, 2], 3: [3, 2, 0, 1]}\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 3, 1], 2: [1, 3, 2, 0], 3: [0, 2, 3, 1]}\n", + "{0: [3, 0, 2, 1], 1: [0, 2, 3, 1], 2: [3, 2, 1, 0], 3: [2, 3, 0, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 1, 2, 0], 1: [2, 1, 3, 0], 2: [2, 1, 3, 0], 3: [2, 1, 0, 3]}\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 3, 2], 2: [3, 1, 0, 2], 3: [1, 3, 0, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 2, 1], 2: [2, 0, 1, 3], 3: [0, 1, 3, 2]}\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 3, 0], 2: [1, 0, 2, 3], 3: [0, 3, 1, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 3, 1, 2], 1: [1, 2, 0, 3], 2: [2, 1, 3, 0], 3: [3, 0, 2, 1]}\n", + "{0: [3, 0, 1, 2], 1: [0, 3, 2, 1], 2: [0, 1, 2, 3], 3: [2, 0, 3, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 3, 0], 2: [0, 1, 2, 3], 3: [2, 0, 3, 1]}\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 3, 1], 2: [3, 1, 0, 2], 3: [0, 2, 1, 3]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 3, 0], 2: [0, 1, 3, 2], 3: [2, 3, 1, 0]}\n", + "{0: [2, 0, 1, 3], 1: [3, 0, 1, 2], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 2, 0, 3], 2: [0, 2, 1, 3], 3: [1, 0, 2, 3]}\n", + "{0: [3, 2, 1, 0], 1: [0, 2, 3, 1], 2: [0, 1, 3, 2], 3: [3, 2, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 2, 0], 2: [3, 0, 1, 2], 3: [3, 1, 0, 2]}\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 1, 0], 2: [0, 1, 3, 2], 3: [2, 1, 0, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [2, 0, 3, 1]}\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 1, 2], 2: [2, 1, 0, 3], 3: [0, 3, 2, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 0, 2], 2: [2, 1, 3, 0], 3: [3, 1, 2, 0]}\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 0, 1], 2: [0, 1, 2, 3], 3: [2, 1, 0, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 1, 3, 2], 1: [1, 0, 2, 3], 2: [2, 1, 0, 3], 3: [1, 3, 2, 0]}\n", + "{0: [1, 0, 3, 2], 1: [3, 0, 1, 2], 2: [3, 1, 2, 0], 3: [3, 0, 1, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 2, 3], 2: [0, 1, 2, 3], 3: [0, 1, 2, 3]}\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 1, 3], 2: [0, 2, 3, 1], 3: [0, 1, 2, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [1, 0, 2, 3], 1: [1, 0, 3, 2], 2: [2, 3, 0, 1], 3: [3, 0, 1, 2]}\n", + "{0: [0, 3, 2, 1], 1: [0, 1, 2, 3], 2: [2, 3, 1, 0], 3: [2, 3, 0, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 3, 2], 2: [0, 3, 1, 2], 3: [2, 0, 3, 1]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 0, 3], 2: [1, 2, 0, 3], 3: [3, 2, 0, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [1, 0, 2, 3], 2: [0, 1, 2, 3], 3: [3, 2, 0, 1]}\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 0, 2], 2: [0, 2, 3, 1], 3: [0, 1, 3, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 0, 2], 2: [3, 2, 0, 1], 3: [0, 2, 3, 1]}\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 1, 0], 2: [2, 0, 3, 1], 3: [0, 3, 1, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 0, 1, 3], 1: [3, 2, 1, 0], 2: [1, 3, 0, 2], 3: [3, 1, 0, 2]}\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 2, 3], 2: [2, 3, 0, 1], 3: [0, 1, 3, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 1, 3], 2: [3, 2, 0, 1], 3: [1, 2, 0, 3]}\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 2, 0], 2: [3, 2, 0, 1], 3: [3, 1, 0, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [1, 0, 3, 2], 2: [0, 2, 1, 3], 3: [1, 2, 3, 0]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 1, 2, 3], 1: [2, 3, 1, 0], 2: [0, 2, 1, 3], 3: [3, 2, 0, 1]}\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 1, 3], 2: [1, 0, 2, 3], 3: [2, 3, 1, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [2, 3, 1, 0], 1: [3, 1, 0, 2], 2: [0, 1, 2, 3], 3: [1, 0, 3, 2]}\n", + "{0: [0, 1, 2, 3], 1: [1, 2, 3, 0], 2: [0, 2, 3, 1], 3: [2, 1, 0, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [0, 3, 2, 1], 2: [1, 3, 2, 0], 3: [3, 2, 1, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 3, 0, 1], 1: [3, 0, 2, 1], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 3, 1], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 3, 0], 2: [0, 1, 2, 3], 3: [1, 2, 0, 3]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [0, 3, 2, 1], 3: [0, 3, 2, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 0, 1, 2], 1: [1, 3, 2, 0], 2: [2, 3, 1, 0], 3: [1, 2, 3, 0]}\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 1, 0], 2: [0, 1, 3, 2], 3: [1, 0, 2, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 3, 0, 1], 1: [2, 0, 3, 1], 2: [1, 0, 3, 2], 3: [0, 3, 1, 2]}\n", + "{0: [1, 2, 3, 0], 1: [0, 3, 2, 1], 2: [1, 2, 3, 0], 3: [3, 2, 0, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 2, 1, 3], 1: [2, 3, 0, 1], 2: [2, 3, 1, 0], 3: [0, 3, 1, 2]}\n", + "{0: [2, 1, 3, 0], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 2, 0, 3], 1: [3, 1, 2, 0], 2: [2, 1, 0, 3], 3: [0, 3, 1, 2]}\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 1, 0], 2: [2, 3, 1, 0], 3: [2, 1, 3, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 0, 3], 2: [2, 3, 1, 0], 3: [1, 3, 0, 2]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 0, 3], 2: [0, 1, 2, 3], 3: [0, 3, 1, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 3, 1], 2: [3, 0, 2, 1], 3: [2, 3, 0, 1]}\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [0, 1, 3, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [1, 2, 3, 0], 2: [1, 3, 0, 2], 3: [0, 1, 2, 3]}\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 1, 3], 2: [0, 2, 1, 3], 3: [2, 1, 3, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 2, 1], 2: [3, 0, 1, 2], 3: [1, 2, 0, 3]}\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 3, 0], 2: [3, 1, 2, 0], 3: [0, 2, 3, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 3, 2], 1: [0, 2, 1, 3], 2: [3, 2, 1, 0], 3: [1, 3, 2, 0]}\n", + "{0: [3, 0, 2, 1], 1: [2, 1, 0, 3], 2: [1, 3, 0, 2], 3: [2, 1, 0, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [1, 3, 2, 0], 3: [1, 3, 0, 2]}\n", + "{0: [2, 3, 0, 1], 1: [0, 1, 2, 3], 2: [0, 1, 3, 2], 3: [3, 0, 2, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 1, 3, 2], 1: [2, 3, 0, 1], 2: [2, 1, 3, 0], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 3, 2], 2: [1, 2, 3, 0], 3: [0, 3, 2, 1]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 2, 0], 2: [0, 2, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 2, 0], 2: [1, 0, 2, 3], 3: [1, 2, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 1, 3], 2: [2, 3, 0, 1], 3: [3, 2, 0, 1]}\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 3, 0], 2: [0, 3, 2, 1], 3: [2, 0, 3, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 1, 0, 3], 1: [1, 0, 2, 3], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [1, 0, 2, 3], 3: [0, 2, 3, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 1, 3], 2: [2, 3, 0, 1], 3: [2, 0, 1, 3]}\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 2, 3], 2: [0, 3, 1, 2], 3: [3, 1, 2, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 0, 3], 2: [3, 1, 2, 0], 3: [2, 0, 3, 1]}\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 2, 3], 2: [0, 3, 1, 2], 3: [2, 0, 3, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 2, 0], 2: [1, 3, 0, 2], 3: [0, 1, 2, 3]}\n", + "{0: [0, 2, 1, 3], 1: [1, 3, 0, 2], 2: [1, 3, 2, 0], 3: [2, 1, 0, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 0, 2], 2: [2, 0, 3, 1], 3: [3, 2, 1, 0]}\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 2, 1], 2: [0, 2, 1, 3], 3: [1, 2, 3, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 3, 1], 2: [2, 3, 0, 1], 3: [0, 2, 3, 1]}\n", + "{0: [0, 2, 3, 1], 1: [0, 3, 1, 2], 2: [1, 2, 3, 0], 3: [3, 1, 2, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [1, 0, 3, 2], 2: [3, 0, 2, 1], 3: [0, 2, 1, 3]}\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 3, 2], 2: [1, 2, 3, 0], 3: [0, 3, 2, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 0, 3], 2: [0, 1, 2, 3], 3: [0, 1, 3, 2]}\n", + "{0: [1, 3, 2, 0], 1: [0, 2, 1, 3], 2: [1, 2, 0, 3], 3: [1, 2, 0, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 1, 0], 2: [2, 1, 3, 0], 3: [3, 2, 1, 0]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 2, 1], 2: [3, 0, 1, 2], 3: [1, 0, 3, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 1, 3], 2: [2, 3, 0, 1], 3: [2, 1, 0, 3]}\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 0, 2], 2: [2, 0, 1, 3], 3: [2, 0, 1, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 3, 1, 0], 1: [1, 0, 3, 2], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "{0: [1, 2, 0, 3], 1: [3, 0, 1, 2], 2: [3, 1, 0, 2], 3: [0, 1, 2, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [0, 3, 2, 1], 3: [1, 2, 3, 0]}\n", + "{0: [2, 0, 1, 3], 1: [2, 0, 3, 1], 2: [0, 3, 2, 1], 3: [2, 0, 3, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 1, 2], 2: [0, 3, 2, 1], 3: [3, 1, 0, 2]}\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 2, 0], 2: [0, 3, 2, 1], 3: [2, 0, 1, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [3, 2, 1, 0], 2: [1, 0, 2, 3], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 0, 2], 2: [2, 1, 3, 0], 3: [1, 3, 2, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 3, 1, 0], 1: [1, 2, 3, 0], 2: [0, 3, 2, 1], 3: [2, 0, 1, 3]}\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 3, 1], 2: [2, 0, 1, 3], 3: [0, 1, 3, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [1, 2, 3, 0], 1: [0, 3, 1, 2], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "{0: [3, 2, 0, 1], 1: [1, 2, 3, 0], 2: [2, 0, 1, 3], 3: [0, 1, 3, 2]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 2, 3], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [2, 1, 3, 0], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 0, 1, 2], 1: [1, 0, 3, 2], 2: [1, 0, 3, 2], 3: [0, 3, 2, 1]}\n", + "{0: [2, 3, 0, 1], 1: [1, 2, 0, 3], 2: [2, 0, 1, 3], 3: [1, 0, 2, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [1, 2, 3, 0], 3: [2, 3, 1, 0]}\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [1, 2, 0, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 0, 2, 3], 1: [3, 1, 2, 0], 2: [2, 1, 0, 3], 3: [2, 0, 3, 1]}\n", + "{0: [1, 0, 2, 3], 1: [2, 1, 0, 3], 2: [1, 2, 0, 3], 3: [3, 0, 1, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 0, 1], 2: [3, 0, 2, 1], 3: [3, 1, 0, 2]}\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 3, 2], 2: [1, 0, 3, 2], 3: [3, 2, 0, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 0, 2], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 1, 3], 2: [3, 1, 2, 0], 3: [3, 1, 0, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 0, 3], 2: [0, 1, 2, 3], 3: [2, 3, 0, 1]}\n", + "{0: [2, 3, 1, 0], 1: [0, 2, 1, 3], 2: [1, 3, 0, 2], 3: [1, 0, 3, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 3, 1, 0], 1: [1, 3, 0, 2], 2: [2, 1, 3, 0], 3: [0, 1, 2, 3]}\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 2, 1], 2: [3, 1, 0, 2], 3: [1, 2, 3, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 0, 1, 3], 1: [0, 3, 1, 2], 2: [0, 1, 3, 2], 3: [2, 3, 1, 0]}\n", + "{0: [3, 1, 2, 0], 1: [0, 1, 3, 2], 2: [2, 0, 1, 3], 3: [2, 1, 0, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 2, 1], 2: [2, 0, 1, 3], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 0, 2], 2: [1, 0, 2, 3], 3: [0, 3, 1, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 3, 2, 1], 1: [2, 0, 3, 1], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "{0: [3, 2, 1, 0], 1: [3, 2, 0, 1], 2: [1, 3, 2, 0], 3: [0, 3, 1, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 1, 3], 2: [3, 2, 0, 1], 3: [2, 0, 1, 3]}\n", + "{0: [3, 2, 0, 1], 1: [3, 0, 1, 2], 2: [0, 2, 1, 3], 3: [1, 3, 0, 2]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 2, 0, 1], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [2, 1, 0, 3]}\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [3, 1, 2, 0], 3: [1, 2, 3, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 1, 2], 2: [1, 0, 3, 2], 3: [0, 1, 3, 2]}\n", + "{0: [0, 2, 3, 1], 1: [2, 0, 1, 3], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [3, 0, 2, 1]}\n", + "{0: [0, 1, 2, 3], 1: [2, 3, 1, 0], 2: [2, 3, 1, 0], 3: [3, 0, 1, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 2, 0], 2: [0, 1, 3, 2], 3: [0, 2, 3, 1]}\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 1, 2], 2: [0, 2, 1, 3], 3: [2, 1, 3, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 2, 1, 3], 1: [3, 1, 2, 0], 2: [1, 0, 3, 2], 3: [2, 1, 0, 3]}\n", + "{0: [2, 3, 1, 0], 1: [0, 1, 3, 2], 2: [2, 0, 3, 1], 3: [0, 3, 1, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 0, 1, 2], 1: [0, 3, 2, 1], 2: [1, 2, 0, 3], 3: [2, 1, 0, 3]}\n", + "{0: [0, 2, 1, 3], 1: [3, 1, 2, 0], 2: [2, 1, 3, 0], 3: [3, 0, 1, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 3, 0], 2: [1, 2, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 1, 3], 2: [2, 1, 3, 0], 3: [3, 2, 1, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [1, 0, 3, 2]}\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [0, 2, 3, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [0, 1, 2, 3], 1: [3, 2, 1, 0], 2: [1, 3, 0, 2], 3: [2, 1, 3, 0]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 1, 2], 2: [0, 2, 3, 1], 3: [2, 1, 0, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 2, 0], 2: [1, 2, 3, 0], 3: [3, 2, 0, 1]}\n", + "{0: [2, 0, 3, 1], 1: [3, 0, 1, 2], 2: [0, 1, 2, 3], 3: [0, 2, 1, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 0, 2], 2: [3, 1, 2, 0], 3: [3, 0, 2, 1]}\n", + "{0: [1, 0, 2, 3], 1: [2, 1, 0, 3], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 3, 0], 1: [1, 3, 0, 2], 2: [2, 1, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 2, 3], 2: [2, 0, 3, 1], 3: [1, 3, 2, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 1, 2], 2: [2, 1, 3, 0], 3: [1, 0, 2, 3]}\n", + "{0: [2, 1, 0, 3], 1: [0, 2, 3, 1], 2: [2, 0, 3, 1], 3: [0, 2, 1, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 1, 2], 2: [0, 3, 1, 2], 3: [0, 3, 2, 1]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [2, 3, 0, 1], 3: [3, 2, 1, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 3, 0], 2: [1, 3, 2, 0], 3: [0, 2, 1, 3]}\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 2, 0], 2: [2, 0, 3, 1], 3: [2, 0, 3, 1]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 2, 1], 2: [2, 1, 3, 0], 3: [3, 0, 1, 2]}\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 3, 0], 2: [3, 2, 1, 0], 3: [0, 3, 1, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [0, 2, 3, 1]}\n", + "{0: [3, 1, 2, 0], 1: [1, 0, 3, 2], 2: [3, 0, 2, 1], 3: [3, 0, 2, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 0, 2], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 1, 2], 2: [1, 3, 2, 0], 3: [3, 2, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 1, 2, 0], 1: [2, 0, 3, 1], 2: [0, 2, 1, 3], 3: [2, 0, 1, 3]}\n", + "{0: [0, 2, 3, 1], 1: [2, 3, 1, 0], 2: [1, 3, 2, 0], 3: [0, 3, 1, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 1, 2], 2: [0, 3, 1, 2], 3: [0, 1, 3, 2]}\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 2, 1], 2: [2, 3, 1, 0], 3: [2, 1, 3, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 0, 3], 2: [1, 0, 3, 2], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 0, 2], 1: [3, 2, 1, 0], 2: [1, 2, 0, 3], 3: [0, 3, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 2, 0], 2: [3, 1, 0, 2], 3: [1, 0, 3, 2]}\n", + "{0: [3, 0, 1, 2], 1: [0, 2, 1, 3], 2: [0, 2, 1, 3], 3: [1, 0, 2, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 2, 3], 2: [2, 3, 1, 0], 3: [2, 3, 0, 1]}\n", + "{0: [2, 3, 1, 0], 1: [2, 3, 0, 1], 2: [3, 0, 1, 2], 3: [3, 0, 1, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 2, 3], 2: [0, 3, 1, 2], 3: [1, 2, 0, 3]}\n", + "{0: [2, 0, 3, 1], 1: [1, 0, 3, 2], 2: [3, 0, 1, 2], 3: [1, 0, 2, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 2, 0], 1: [0, 3, 1, 2], 2: [1, 2, 0, 3], 3: [1, 3, 2, 0]}\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 2, 0], 2: [1, 0, 2, 3], 3: [2, 3, 0, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 1, 0, 2], 1: [1, 3, 0, 2], 2: [3, 1, 2, 0], 3: [0, 1, 3, 2]}\n", + "{0: [0, 2, 3, 1], 1: [2, 3, 1, 0], 2: [0, 1, 2, 3], 3: [1, 3, 0, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 1, 3], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 0, 3, 2], 1: [3, 0, 1, 2], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 3, 1, 0], 1: [3, 0, 2, 1], 2: [0, 1, 3, 2], 3: [3, 1, 0, 2]}\n", + "{0: [3, 2, 1, 0], 1: [1, 3, 2, 0], 2: [0, 1, 2, 3], 3: [0, 2, 3, 1]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 3, 1], 2: [0, 1, 2, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 1, 2], 2: [1, 0, 3, 2], 3: [1, 3, 2, 0]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 0, 3], 2: [3, 2, 0, 1], 3: [0, 1, 2, 3]}\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 2, 1], 2: [1, 0, 2, 3], 3: [0, 1, 2, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [0, 3, 1, 2], 2: [0, 3, 2, 1], 3: [2, 3, 1, 0]}\n", + "{0: [3, 2, 1, 0], 1: [3, 2, 1, 0], 2: [3, 0, 1, 2], 3: [3, 2, 1, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [0, 1, 2, 3]}\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 2, 1], 2: [1, 0, 3, 2], 3: [1, 2, 3, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 1, 2, 0], 1: [2, 1, 3, 0], 2: [1, 2, 0, 3], 3: [3, 2, 0, 1]}\n", + "{0: [1, 2, 3, 0], 1: [0, 3, 2, 1], 2: [3, 1, 2, 0], 3: [1, 0, 3, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 0, 3], 2: [0, 1, 3, 2], 3: [3, 0, 1, 2]}\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 1, 2], 2: [0, 2, 3, 1], 3: [0, 2, 1, 3]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 3, 0, 1], 1: [3, 1, 0, 2], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 0, 1], 2: [1, 2, 3, 0], 3: [2, 0, 1, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 3, 1, 0], 1: [1, 2, 3, 0], 2: [2, 3, 1, 0], 3: [0, 2, 3, 1]}\n", + "{0: [2, 1, 0, 3], 1: [2, 0, 1, 3], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 0, 1, 3], 1: [3, 0, 1, 2], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "{0: [2, 1, 0, 3], 1: [2, 3, 0, 1], 2: [1, 3, 2, 0], 3: [2, 1, 0, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 3, 1, 2], 1: [2, 3, 0, 1], 2: [0, 3, 1, 2], 3: [3, 1, 0, 2]}\n", + "{0: [0, 1, 3, 2], 1: [0, 3, 1, 2], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 0, 2], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "{0: [3, 2, 0, 1], 1: [1, 2, 3, 0], 2: [2, 0, 1, 3], 3: [3, 2, 0, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [3, 1, 0, 2], 2: [0, 1, 3, 2], 3: [1, 3, 2, 0]}\n", + "{0: [2, 1, 0, 3], 1: [2, 1, 0, 3], 2: [3, 2, 1, 0], 3: [3, 2, 1, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 3, 2], 2: [1, 2, 0, 3], 3: [3, 2, 1, 0]}\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 0, 3], 2: [0, 1, 2, 3], 3: [1, 0, 3, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [2, 3, 1, 0], 3: [0, 3, 1, 2]}\n", + "{0: [3, 0, 2, 1], 1: [3, 0, 2, 1], 2: [2, 3, 0, 1], 3: [1, 0, 2, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 0, 3, 2], 1: [0, 3, 1, 2], 2: [3, 2, 1, 0], 3: [2, 0, 3, 1]}\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 3, 1], 2: [0, 2, 1, 3], 3: [0, 2, 3, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 3, 2, 1], 1: [0, 1, 3, 2], 2: [0, 2, 1, 3], 3: [3, 1, 2, 0]}\n", + "{0: [1, 2, 3, 0], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 0, 1], 2: [3, 1, 0, 2], 3: [1, 0, 3, 2]}\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 3, 1], 2: [1, 2, 3, 0], 3: [1, 3, 2, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 3, 2], 2: [3, 2, 1, 0], 3: [0, 2, 3, 1]}\n", + "{0: [1, 0, 3, 2], 1: [1, 0, 3, 2], 2: [3, 1, 2, 0], 3: [2, 0, 3, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 3, 1, 2], 1: [0, 1, 3, 2], 2: [2, 0, 3, 1], 3: [2, 1, 3, 0]}\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 3, 0], 2: [2, 0, 3, 1], 3: [2, 3, 0, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 1, 3, 0], 1: [1, 2, 3, 0], 2: [3, 0, 2, 1], 3: [3, 1, 2, 0]}\n", + "{0: [2, 1, 0, 3], 1: [3, 1, 0, 2], 2: [1, 0, 3, 2], 3: [0, 2, 1, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [2, 3, 1, 0], 3: [3, 2, 0, 1]}\n", + "{0: [2, 3, 1, 0], 1: [2, 0, 1, 3], 2: [0, 2, 1, 3], 3: [0, 2, 1, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 1, 0, 2], 1: [3, 0, 1, 2], 2: [0, 3, 2, 1], 3: [3, 2, 1, 0]}\n", + "{0: [3, 0, 1, 2], 1: [1, 3, 2, 0], 2: [1, 3, 0, 2], 3: [1, 3, 2, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 3, 2], 2: [0, 2, 3, 1], 3: [3, 1, 0, 2]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 0, 3], 2: [0, 1, 3, 2], 3: [1, 0, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [3, 2, 1, 0], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 1, 3], 2: [0, 2, 3, 1], 3: [2, 3, 0, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [1, 3, 0, 2], 3: [3, 0, 2, 1]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 0, 3], 2: [3, 2, 0, 1], 3: [0, 2, 1, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [0, 1, 3, 2], 1: [1, 0, 3, 2], 2: [2, 3, 0, 1], 3: [3, 0, 2, 1]}\n", + "{0: [2, 0, 1, 3], 1: [0, 2, 1, 3], 2: [3, 2, 0, 1], 3: [1, 2, 0, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 0, 1, 3], 1: [1, 3, 2, 0], 2: [1, 2, 3, 0], 3: [2, 0, 3, 1]}\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 1, 2], 2: [0, 2, 1, 3], 3: [2, 0, 3, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 0, 1], 2: [1, 3, 0, 2], 3: [3, 2, 1, 0]}\n", + "{0: [1, 3, 0, 2], 1: [3, 0, 1, 2], 2: [3, 2, 1, 0], 3: [3, 2, 0, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 1, 3, 0], 1: [0, 2, 1, 3], 2: [2, 1, 0, 3], 3: [0, 2, 3, 1]}\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 2, 1], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 3, 0, 1], 1: [3, 1, 2, 0], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "{0: [0, 2, 1, 3], 1: [0, 2, 1, 3], 2: [0, 1, 3, 2], 3: [2, 3, 1, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 3, 0, 1], 1: [1, 2, 0, 3], 2: [1, 2, 0, 3], 3: [3, 1, 2, 0]}\n", + "{0: [0, 3, 2, 1], 1: [2, 0, 1, 3], 2: [2, 3, 1, 0], 3: [2, 3, 1, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 3, 1], 2: [3, 0, 1, 2], 3: [0, 3, 1, 2]}\n", + "{0: [1, 0, 2, 3], 1: [3, 0, 2, 1], 2: [1, 0, 2, 3], 3: [0, 2, 1, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 3, 1], 2: [3, 2, 0, 1], 3: [0, 3, 1, 2]}\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 1, 0], 2: [3, 1, 2, 0], 3: [2, 0, 3, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 1, 2], 2: [0, 1, 3, 2], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 1, 0], 1: [2, 1, 0, 3], 2: [3, 1, 0, 2], 3: [0, 2, 3, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 0, 1], 2: [3, 2, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 0, 1], 2: [1, 0, 3, 2], 3: [0, 1, 3, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [0, 3, 2, 1]}\n", + "{0: [1, 0, 3, 2], 1: [1, 3, 0, 2], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 0, 2, 3], 1: [3, 0, 2, 1], 2: [3, 0, 2, 1], 3: [3, 2, 0, 1]}\n", + "{0: [1, 2, 3, 0], 1: [2, 3, 0, 1], 2: [0, 1, 3, 2], 3: [3, 1, 0, 2]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 0, 2, 1], 1: [2, 1, 0, 3], 2: [0, 3, 2, 1], 3: [3, 0, 1, 2]}\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 0, 1], 2: [2, 0, 3, 1], 3: [2, 3, 1, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 1, 3], 2: [2, 0, 3, 1], 3: [2, 1, 3, 0]}\n", + "{0: [0, 2, 1, 3], 1: [2, 3, 1, 0], 2: [1, 2, 3, 0], 3: [2, 3, 0, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 0, 2], 2: [0, 1, 3, 2], 3: [3, 0, 1, 2]}\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 1, 2], 2: [3, 2, 0, 1], 3: [0, 3, 2, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 0, 3, 1], 1: [2, 3, 0, 1], 2: [1, 0, 3, 2], 3: [3, 1, 2, 0]}\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 1, 3], 2: [2, 3, 1, 0], 3: [1, 0, 3, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 2, 0, 1], 1: [0, 1, 2, 3], 2: [2, 0, 3, 1], 3: [2, 1, 3, 0]}\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 3, 2], 2: [0, 1, 2, 3], 3: [3, 0, 2, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [1, 0, 2, 3], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 0, 3], 2: [2, 3, 0, 1], 3: [1, 2, 3, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 2, 0], 2: [1, 3, 2, 0], 3: [0, 3, 2, 1]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 1, 3], 2: [1, 0, 2, 3], 3: [2, 3, 1, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 2, 3], 2: [0, 2, 1, 3], 3: [1, 2, 3, 0]}\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 0, 3], 2: [0, 2, 1, 3], 3: [0, 1, 2, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 2, 1], 2: [0, 2, 1, 3], 3: [2, 1, 3, 0]}\n", + "{0: [0, 1, 2, 3], 1: [3, 2, 0, 1], 2: [1, 3, 0, 2], 3: [3, 1, 2, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 2, 3], 2: [2, 1, 0, 3], 3: [3, 2, 0, 1]}\n", + "{0: [3, 2, 1, 0], 1: [2, 1, 0, 3], 2: [3, 0, 2, 1], 3: [3, 2, 0, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 1, 2], 1: [0, 1, 3, 2], 2: [1, 2, 3, 0], 3: [1, 3, 2, 0]}\n", + "{0: [2, 0, 3, 1], 1: [3, 2, 0, 1], 2: [1, 2, 0, 3], 3: [1, 2, 3, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [1, 2, 0, 3], 1: [3, 1, 2, 0], 2: [3, 2, 0, 1], 3: [3, 0, 2, 1]}\n", + "{0: [2, 3, 0, 1], 1: [1, 0, 2, 3], 2: [3, 0, 1, 2], 3: [1, 0, 3, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 3, 0], 2: [3, 0, 2, 1], 3: [1, 3, 0, 2]}\n", + "{0: [0, 2, 1, 3], 1: [3, 2, 0, 1], 2: [0, 2, 1, 3], 3: [1, 3, 2, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 3, 0], 2: [1, 3, 2, 0], 3: [1, 2, 0, 3]}\n", + "{0: [0, 3, 1, 2], 1: [2, 3, 0, 1], 2: [1, 0, 3, 2], 3: [2, 1, 3, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 0, 1], 2: [1, 3, 0, 2], 3: [1, 0, 2, 3]}\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 3, 2], 2: [0, 3, 2, 1], 3: [0, 2, 1, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [2, 0, 1, 3], 2: [0, 3, 1, 2], 3: [2, 0, 3, 1]}\n", + "{0: [2, 1, 0, 3], 1: [0, 2, 1, 3], 2: [0, 1, 2, 3], 3: [1, 0, 2, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 3, 0, 1], 1: [3, 0, 1, 2], 2: [0, 3, 2, 1], 3: [0, 2, 1, 3]}\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 3, 2], 2: [2, 1, 0, 3], 3: [1, 0, 3, 2]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 1, 3, 2], 1: [2, 0, 3, 1], 2: [3, 0, 2, 1], 3: [3, 1, 2, 0]}\n", + "{0: [2, 3, 1, 0], 1: [0, 2, 3, 1], 2: [3, 2, 0, 1], 3: [2, 1, 0, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 1, 2], 2: [3, 2, 1, 0], 3: [3, 2, 1, 0]}\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [0, 3, 1, 2], 3: [0, 3, 1, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 0, 2], 2: [3, 1, 2, 0], 3: [1, 0, 2, 3]}\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 3, 2], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 2, 3, 1], 1: [2, 3, 0, 1], 2: [0, 1, 3, 2], 3: [3, 0, 2, 1]}\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 1, 3], 2: [0, 2, 1, 3], 3: [3, 1, 2, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 3, 2], 2: [3, 2, 0, 1], 3: [1, 3, 2, 0]}\n", + "{0: [0, 3, 1, 2], 1: [1, 3, 2, 0], 2: [3, 2, 0, 1], 3: [1, 0, 3, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 2, 3], 2: [3, 0, 1, 2], 3: [2, 3, 1, 0]}\n", + "{0: [1, 0, 2, 3], 1: [3, 2, 1, 0], 2: [3, 2, 1, 0], 3: [1, 0, 3, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 1, 0, 3], 1: [2, 3, 1, 0], 2: [3, 0, 1, 2], 3: [2, 1, 0, 3]}\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 0, 3], 2: [0, 3, 1, 2], 3: [0, 1, 2, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 2, 0, 3], 1: [2, 1, 0, 3], 2: [1, 0, 2, 3], 3: [0, 1, 2, 3]}\n", + "{0: [3, 0, 1, 2], 1: [2, 3, 0, 1], 2: [2, 3, 0, 1], 3: [2, 1, 3, 0]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 2, 3], 2: [2, 0, 1, 3], 3: [0, 2, 3, 1]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 1, 3], 2: [1, 2, 0, 3], 3: [0, 2, 3, 1]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 2, 3], 2: [3, 0, 1, 2], 3: [3, 1, 0, 2]}\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 1, 2], 2: [0, 1, 3, 2], 3: [1, 0, 2, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [1, 0, 2, 3], 1: [3, 2, 0, 1], 2: [1, 3, 0, 2], 3: [0, 1, 3, 2]}\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 3, 0], 2: [3, 1, 2, 0], 3: [0, 3, 2, 1]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 0, 3], 2: [3, 2, 0, 1], 3: [0, 3, 2, 1]}\n", + "{0: [0, 1, 3, 2], 1: [2, 1, 3, 0], 2: [0, 2, 3, 1], 3: [0, 1, 2, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 3, 0, 1], 1: [2, 0, 1, 3], 2: [1, 2, 0, 3], 3: [0, 1, 3, 2]}\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 1, 2], 2: [2, 0, 3, 1], 3: [2, 0, 1, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 0, 1], 2: [3, 2, 0, 1], 3: [3, 0, 1, 2]}\n", + "{0: [1, 3, 0, 2], 1: [2, 1, 3, 0], 2: [2, 3, 0, 1], 3: [1, 3, 2, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [3, 2, 0, 1], 2: [0, 2, 3, 1], 3: [1, 0, 2, 3]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [2, 3, 0, 1], 3: [0, 2, 3, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 1, 3, 0], 1: [2, 3, 0, 1], 2: [1, 0, 2, 3], 3: [2, 1, 0, 3]}\n", + "{0: [3, 1, 0, 2], 1: [3, 0, 2, 1], 2: [1, 2, 3, 0], 3: [0, 3, 1, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [2, 3, 1, 0], 3: [0, 2, 3, 1]}\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 1, 2], 2: [0, 1, 2, 3], 3: [0, 2, 3, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 0, 1], 2: [0, 3, 2, 1], 3: [0, 3, 1, 2]}\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [0, 3, 2, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 0, 3, 1], 1: [1, 2, 3, 0], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "{0: [2, 1, 0, 3], 1: [2, 3, 1, 0], 2: [2, 1, 0, 3], 3: [3, 0, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 3, 1, 2], 1: [3, 2, 0, 1], 2: [2, 1, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [3, 0, 1, 2], 1: [1, 3, 0, 2], 2: [0, 1, 3, 2], 3: [0, 1, 3, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 0, 3], 2: [2, 3, 0, 1], 3: [3, 1, 0, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 2, 3, 1], 1: [3, 0, 2, 1], 2: [2, 0, 3, 1], 3: [1, 2, 0, 3]}\n", + "{0: [2, 3, 1, 0], 1: [0, 1, 3, 2], 2: [2, 0, 1, 3], 3: [2, 3, 0, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 3, 0], 2: [2, 0, 1, 3], 3: [1, 0, 2, 3]}\n", + "{0: [3, 1, 2, 0], 1: [1, 2, 0, 3], 2: [1, 0, 2, 3], 3: [1, 0, 2, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 0, 2, 1], 1: [2, 3, 1, 0], 2: [0, 3, 1, 2], 3: [3, 0, 2, 1]}\n", + "{0: [3, 2, 0, 1], 1: [2, 0, 1, 3], 2: [0, 3, 1, 2], 3: [2, 1, 3, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 2, 3, 0], 1: [2, 1, 0, 3], 2: [0, 2, 3, 1], 3: [3, 0, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 2, 1], 2: [1, 2, 3, 0], 3: [2, 1, 0, 3]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 3, 1, 2], 1: [1, 3, 0, 2], 2: [0, 3, 1, 2], 3: [2, 1, 3, 0]}\n", + "{0: [2, 3, 1, 0], 1: [1, 2, 3, 0], 2: [0, 2, 1, 3], 3: [2, 1, 0, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 2, 3], 2: [3, 2, 0, 1], 3: [0, 3, 2, 1]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 3, 0], 2: [0, 1, 3, 2], 3: [3, 0, 2, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 0, 2], 2: [1, 0, 2, 3], 3: [1, 3, 2, 0]}\n", + "{0: [3, 0, 1, 2], 1: [1, 0, 3, 2], 2: [2, 1, 3, 0], 3: [0, 2, 3, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [1, 2, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 2, 0], 2: [0, 3, 2, 1], 3: [3, 0, 1, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [0, 1, 2, 3], 1: [2, 3, 0, 1], 2: [2, 3, 1, 0], 3: [1, 2, 3, 0]}\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 2, 1], 2: [0, 3, 2, 1], 3: [0, 2, 3, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [2, 3, 0, 1], 3: [3, 2, 0, 1]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [3, 2, 0, 1], 2: [1, 0, 2, 3], 3: [3, 1, 0, 2]}\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 0, 1], 2: [3, 0, 1, 2], 3: [3, 2, 0, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 2, 1, 3], 1: [2, 3, 1, 0], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 2, 0], 2: [3, 2, 0, 1], 3: [1, 3, 2, 0]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 1, 3, 0], 1: [3, 2, 0, 1], 2: [3, 1, 0, 2], 3: [1, 0, 2, 3]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [2, 3, 0, 1], 3: [0, 1, 3, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 1, 3], 2: [3, 1, 2, 0], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 2, 1], 2: [3, 0, 1, 2], 3: [2, 1, 3, 0]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 2, 0], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [3, 0, 1, 2], 1: [2, 3, 1, 0], 2: [1, 2, 0, 3], 3: [3, 0, 2, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 1, 0], 2: [2, 3, 1, 0], 3: [3, 2, 0, 1]}\n", + "{0: [0, 3, 1, 2], 1: [1, 2, 3, 0], 2: [0, 3, 2, 1], 3: [0, 3, 2, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 1, 3, 0], 1: [3, 0, 1, 2], 2: [1, 2, 3, 0], 3: [0, 3, 1, 2]}\n", + "{0: [1, 2, 3, 0], 1: [0, 2, 1, 3], 2: [0, 1, 2, 3], 3: [2, 1, 0, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [1, 3, 2, 0], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "{0: [1, 0, 2, 3], 1: [2, 3, 0, 1], 2: [1, 0, 2, 3], 3: [1, 2, 3, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 3, 1], 2: [1, 0, 2, 3], 3: [3, 0, 2, 1]}\n", + "{0: [2, 3, 1, 0], 1: [1, 2, 0, 3], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 1, 2, 0], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [0, 2, 3, 1]}\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 2, 3], 2: [0, 1, 2, 3], 3: [1, 0, 2, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 2, 0], 2: [3, 0, 2, 1], 3: [0, 1, 2, 3]}\n", + "{0: [0, 2, 3, 1], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [0, 1, 2, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 2, 0, 1], 1: [2, 0, 1, 3], 2: [0, 1, 3, 2], 3: [1, 3, 2, 0]}\n", + "{0: [2, 0, 3, 1], 1: [3, 2, 0, 1], 2: [1, 0, 3, 2], 3: [0, 3, 2, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 3, 2, 0], 1: [2, 0, 1, 3], 2: [3, 2, 1, 0], 3: [2, 0, 1, 3]}\n", + "{0: [1, 0, 2, 3], 1: [2, 1, 0, 3], 2: [0, 2, 1, 3], 3: [0, 3, 1, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [2, 0, 1, 3], 2: [1, 0, 2, 3], 3: [0, 2, 1, 3]}\n", + "{0: [1, 3, 2, 0], 1: [1, 0, 3, 2], 2: [1, 2, 3, 0], 3: [0, 2, 1, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 1, 0, 2], 1: [3, 0, 2, 1], 2: [2, 0, 3, 1], 3: [1, 3, 0, 2]}\n", + "{0: [3, 0, 2, 1], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [0, 3, 2, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 0, 1], 2: [1, 0, 2, 3], 3: [2, 3, 0, 1]}\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 0, 2], 2: [2, 3, 1, 0], 3: [0, 3, 2, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 0, 3], 1: [2, 3, 0, 1], 2: [3, 2, 0, 1], 3: [1, 3, 2, 0]}\n", + "{0: [0, 2, 1, 3], 1: [1, 3, 2, 0], 2: [0, 1, 2, 3], 3: [3, 1, 2, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [3, 1, 0, 2], 2: [2, 0, 1, 3], 3: [1, 2, 0, 3]}\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 2, 3], 2: [1, 0, 2, 3], 3: [2, 3, 0, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 1, 2, 3], 1: [2, 3, 0, 1], 2: [3, 0, 1, 2], 3: [0, 2, 1, 3]}\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 2, 1], 2: [0, 2, 3, 1], 3: [3, 0, 2, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 0, 1], 2: [3, 1, 0, 2], 3: [3, 0, 2, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 2, 0, 3], 2: [1, 3, 2, 0], 3: [3, 1, 2, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [1, 3, 2, 0], 3: [3, 0, 2, 1]}\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 1, 3], 2: [2, 0, 3, 1], 3: [0, 3, 2, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 2, 3], 2: [3, 0, 2, 1], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 0, 3], 2: [2, 0, 3, 1], 3: [2, 3, 1, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [1, 0, 3, 2], 3: [0, 1, 3, 2]}\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 1, 2], 2: [1, 3, 0, 2], 3: [2, 1, 3, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 3, 1, 0], 1: [2, 3, 0, 1], 2: [2, 3, 0, 1], 3: [0, 1, 3, 2]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 3, 1], 2: [3, 0, 2, 1], 3: [1, 2, 0, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [1, 2, 0, 3], 3: [3, 2, 1, 0]}\n", + "{0: [3, 1, 2, 0], 1: [1, 0, 3, 2], 2: [2, 3, 0, 1], 3: [1, 0, 2, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 0, 3, 1], 1: [1, 0, 3, 2], 2: [0, 2, 3, 1], 3: [2, 1, 3, 0]}\n", + "{0: [2, 1, 3, 0], 1: [3, 1, 0, 2], 2: [1, 0, 3, 2], 3: [0, 3, 1, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 1, 3], 2: [3, 2, 1, 0], 3: [2, 0, 3, 1]}\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 3, 2], 2: [0, 1, 2, 3], 3: [2, 0, 1, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 3, 0], 2: [1, 2, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 0, 2], 2: [0, 1, 3, 2], 3: [1, 0, 3, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 0, 1, 3], 1: [2, 0, 3, 1], 2: [2, 3, 0, 1], 3: [0, 1, 2, 3]}\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 3, 2], 2: [1, 2, 0, 3], 3: [3, 2, 0, 1]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 3, 2], 2: [0, 2, 1, 3], 3: [3, 1, 0, 2]}\n", + "{0: [0, 1, 3, 2], 1: [1, 2, 0, 3], 2: [3, 0, 1, 2], 3: [2, 3, 1, 0]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 3, 1, 0], 1: [0, 2, 3, 1], 2: [1, 2, 0, 3], 3: [1, 0, 3, 2]}\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 1, 0], 2: [1, 2, 3, 0], 3: [2, 3, 0, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 1, 2], 2: [0, 1, 3, 2], 3: [2, 1, 0, 3]}\n", + "{0: [2, 0, 1, 3], 1: [2, 1, 0, 3], 2: [3, 1, 2, 0], 3: [0, 1, 2, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 3, 2], 2: [0, 1, 2, 3], 3: [3, 2, 0, 1]}\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 3, 0], 2: [0, 1, 3, 2], 3: [2, 1, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [3, 1, 2, 0], 2: [3, 0, 2, 1], 3: [0, 1, 3, 2]}\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 3, 2], 2: [0, 3, 1, 2], 3: [1, 2, 0, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 3, 1], 2: [1, 3, 2, 0], 3: [1, 0, 3, 2]}\n", + "{0: [1, 0, 3, 2], 1: [0, 1, 3, 2], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 2, 1], 2: [2, 1, 3, 0], 3: [0, 1, 2, 3]}\n", + "{0: [1, 3, 0, 2], 1: [0, 3, 1, 2], 2: [3, 0, 2, 1], 3: [0, 1, 3, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 1, 0, 3], 1: [2, 0, 1, 3], 2: [2, 0, 1, 3], 3: [2, 0, 3, 1]}\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 3, 1], 2: [3, 1, 2, 0], 3: [1, 3, 0, 2]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [3, 2, 0, 1], 2: [3, 0, 1, 2], 3: [0, 1, 3, 2]}\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 2, 3], 2: [3, 1, 2, 0], 3: [3, 0, 1, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [2, 1, 3, 0], 3: [2, 3, 0, 1]}\n", + "{0: [3, 1, 2, 0], 1: [2, 0, 3, 1], 2: [1, 2, 0, 3], 3: [2, 1, 0, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 1, 0], 2: [0, 1, 2, 3], 3: [0, 2, 1, 3]}\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 2, 0], 2: [3, 0, 2, 1], 3: [1, 0, 3, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 0, 1, 3], 1: [3, 0, 1, 2], 2: [1, 0, 3, 2], 3: [2, 3, 1, 0]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [0, 1, 2, 3], 3: [1, 0, 2, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [1, 0, 2, 3], 3: [2, 0, 1, 3]}\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 3, 1], 2: [0, 2, 1, 3], 3: [2, 0, 3, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 3, 0], 2: [1, 2, 3, 0], 3: [3, 2, 0, 1]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [1, 3, 0, 2], 3: [0, 1, 3, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [1, 3, 0, 2], 1: [3, 0, 2, 1], 2: [2, 3, 1, 0], 3: [3, 0, 1, 2]}\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 3, 0], 2: [1, 3, 0, 2], 3: [0, 2, 3, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 1, 3, 0], 1: [0, 2, 1, 3], 2: [1, 3, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [3, 1, 2, 0], 1: [0, 2, 1, 3], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 2, 0], 2: [0, 1, 2, 3], 3: [1, 2, 0, 3]}\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 1, 3], 2: [3, 0, 1, 2], 3: [3, 1, 0, 2]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 0, 3, 1], 1: [1, 2, 3, 0], 2: [2, 0, 3, 1], 3: [2, 0, 3, 1]}\n", + "{0: [0, 2, 3, 1], 1: [1, 3, 2, 0], 2: [2, 3, 1, 0], 3: [1, 3, 2, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 3, 2], 2: [1, 3, 2, 0], 3: [1, 2, 3, 0]}\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 2, 3], 2: [0, 2, 3, 1], 3: [3, 1, 2, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 0, 2, 1], 1: [3, 0, 2, 1], 2: [1, 2, 0, 3], 3: [1, 3, 0, 2]}\n", + "{0: [1, 3, 0, 2], 1: [2, 3, 1, 0], 2: [0, 1, 3, 2], 3: [2, 3, 1, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 1, 3], 1: [3, 1, 0, 2], 2: [2, 3, 0, 1], 3: [0, 2, 3, 1]}\n", + "{0: [0, 3, 2, 1], 1: [0, 2, 1, 3], 2: [0, 2, 1, 3], 3: [2, 1, 0, 3]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 3, 1, 2], 1: [3, 1, 0, 2], 2: [1, 3, 0, 2], 3: [3, 2, 1, 0]}\n", + "{0: [3, 1, 2, 0], 1: [2, 1, 3, 0], 2: [2, 1, 0, 3], 3: [0, 3, 2, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 2, 3], 2: [1, 2, 3, 0], 3: [3, 1, 2, 0]}\n", + "{0: [0, 2, 1, 3], 1: [2, 0, 3, 1], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 1, 3, 0], 1: [3, 0, 1, 2], 2: [2, 1, 0, 3], 3: [1, 3, 0, 2]}\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 1, 2], 2: [1, 3, 2, 0], 3: [0, 1, 3, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 2, 3], 2: [2, 0, 3, 1], 3: [2, 3, 0, 1]}\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 2, 0], 2: [1, 3, 0, 2], 3: [1, 3, 2, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 3, 2], 2: [2, 1, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [0, 1, 2, 3], 3: [3, 2, 1, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 3, 0, 2], 1: [2, 1, 0, 3], 2: [2, 0, 3, 1], 3: [2, 3, 1, 0]}\n", + "{0: [3, 0, 2, 1], 1: [2, 1, 0, 3], 2: [3, 1, 0, 2], 3: [0, 3, 1, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [3, 0, 1, 2], 3: [3, 1, 2, 0]}\n", + "{0: [2, 3, 1, 0], 1: [0, 2, 3, 1], 2: [3, 1, 0, 2], 3: [3, 0, 1, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 2, 3], 2: [0, 3, 2, 1], 3: [1, 0, 3, 2]}\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 2, 3], 2: [1, 3, 0, 2], 3: [2, 3, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 3, 2], 1: [1, 0, 2, 3], 2: [3, 0, 2, 1], 3: [2, 0, 3, 1]}\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 3, 2], 2: [1, 3, 2, 0], 3: [0, 3, 2, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 3, 0, 1], 1: [0, 2, 1, 3], 2: [3, 0, 1, 2], 3: [0, 3, 2, 1]}\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 0, 2], 2: [3, 1, 0, 2], 3: [1, 2, 3, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 0, 1], 2: [1, 2, 3, 0], 3: [1, 3, 0, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 0, 1, 2], 1: [3, 0, 2, 1], 2: [3, 0, 2, 1], 3: [3, 0, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 2, 3], 2: [1, 2, 0, 3], 3: [1, 3, 0, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 2, 3], 2: [3, 1, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 2, 3, 0], 1: [2, 0, 1, 3], 2: [0, 3, 1, 2], 3: [1, 3, 2, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 1, 3], 1: [0, 1, 3, 2], 2: [3, 1, 0, 2], 3: [1, 3, 0, 2]}\n", + "{0: [3, 0, 2, 1], 1: [0, 1, 2, 3], 2: [0, 1, 3, 2], 3: [2, 1, 0, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 1, 2], 2: [2, 0, 3, 1], 3: [2, 0, 1, 3]}\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 3, 2], 2: [0, 2, 1, 3], 3: [3, 2, 1, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 2, 0], 2: [0, 2, 1, 3], 3: [0, 1, 2, 3]}\n", + "{0: [0, 2, 3, 1], 1: [0, 2, 3, 1], 2: [2, 3, 1, 0], 3: [3, 2, 1, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 2, 0, 3], 1: [2, 3, 1, 0], 2: [3, 2, 0, 1], 3: [3, 0, 2, 1]}\n", + "{0: [2, 0, 3, 1], 1: [0, 2, 1, 3], 2: [0, 3, 2, 1], 3: [0, 1, 3, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 1, 0, 3], 1: [2, 3, 1, 0], 2: [1, 2, 3, 0], 3: [2, 0, 1, 3]}\n", + "{0: [2, 0, 3, 1], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [1, 2, 0, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 3, 1, 2], 1: [0, 1, 2, 3], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [0, 2, 3, 1], 1: [0, 2, 3, 1], 2: [0, 3, 2, 1], 3: [0, 2, 1, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [2, 1, 0, 3], 3: [3, 0, 1, 2]}\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 2, 3], 2: [2, 3, 0, 1], 3: [2, 1, 0, 3]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 1, 2, 3], 1: [1, 2, 3, 0], 2: [3, 2, 0, 1], 3: [2, 1, 3, 0]}\n", + "{0: [2, 1, 0, 3], 1: [0, 2, 1, 3], 2: [2, 3, 1, 0], 3: [0, 3, 1, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 2, 0], 2: [1, 3, 0, 2], 3: [0, 1, 3, 2]}\n", + "{0: [3, 2, 0, 1], 1: [0, 1, 2, 3], 2: [0, 1, 2, 3], 3: [3, 2, 0, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [1, 3, 2, 0]}\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 1, 0], 2: [3, 2, 1, 0], 3: [2, 1, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 3, 0, 1], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 2, 3], 2: [3, 1, 2, 0], 3: [2, 1, 0, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 0, 2, 1], 1: [0, 3, 2, 1], 2: [3, 1, 2, 0], 3: [3, 0, 1, 2]}\n", + "{0: [1, 0, 2, 3], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [0, 1, 2, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [0, 2, 3, 1], 3: [2, 0, 3, 1]}\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 2, 0], 2: [2, 0, 1, 3], 3: [3, 2, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 0, 2], 2: [1, 0, 2, 3], 3: [2, 0, 1, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 1, 0], 2: [0, 3, 1, 2], 3: [0, 3, 2, 1]}\n", + "{0: [1, 2, 0, 3], 1: [3, 1, 0, 2], 2: [1, 2, 0, 3], 3: [3, 1, 2, 0]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 1, 3], 2: [0, 3, 2, 1], 3: [1, 2, 3, 0]}\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 1, 2], 2: [1, 0, 2, 3], 3: [1, 3, 0, 2]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [2, 0, 1, 3], 1: [1, 3, 0, 2], 2: [3, 1, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 3, 2], 2: [2, 1, 3, 0], 3: [1, 2, 3, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 0, 1], 1: [3, 2, 0, 1], 2: [1, 0, 2, 3], 3: [0, 1, 3, 2]}\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [1, 3, 2, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 2, 1], 2: [3, 1, 2, 0], 3: [1, 2, 0, 3]}\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 0, 2], 2: [3, 2, 1, 0], 3: [1, 3, 2, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 3, 0], 1: [2, 3, 1, 0], 2: [2, 3, 0, 1], 3: [1, 2, 3, 0]}\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 1, 0], 2: [2, 3, 1, 0], 3: [3, 2, 0, 1]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 3, 0], 2: [3, 1, 2, 0], 3: [3, 1, 0, 2]}\n", + "{0: [3, 0, 2, 1], 1: [1, 2, 0, 3], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 1, 0, 3], 1: [1, 0, 3, 2], 2: [3, 1, 0, 2], 3: [1, 0, 3, 2]}\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 0, 1], 2: [1, 2, 3, 0], 3: [1, 2, 3, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 3, 0], 2: [3, 1, 0, 2], 3: [3, 0, 1, 2]}\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 0, 1], 2: [1, 3, 2, 0], 3: [3, 1, 2, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 3, 1, 0], 1: [0, 1, 2, 3], 2: [3, 2, 0, 1], 3: [3, 2, 1, 0]}\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 2, 3], 2: [3, 0, 1, 2], 3: [1, 2, 0, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 3, 1], 2: [0, 3, 2, 1], 3: [1, 2, 3, 0]}\n", + "{0: [1, 0, 3, 2], 1: [3, 0, 2, 1], 2: [3, 0, 2, 1], 3: [2, 0, 1, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 2, 1, 0], 1: [2, 1, 0, 3], 2: [3, 0, 1, 2], 3: [2, 3, 0, 1]}\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 3, 1], 2: [0, 3, 2, 1], 3: [1, 3, 2, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [1, 3, 0, 2]}\n", + "{0: [2, 3, 1, 0], 1: [0, 1, 3, 2], 2: [0, 2, 3, 1], 3: [2, 1, 0, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 1, 2, 3], 1: [2, 1, 0, 3], 2: [2, 3, 1, 0], 3: [2, 0, 1, 3]}\n", + "{0: [0, 1, 2, 3], 1: [1, 3, 0, 2], 2: [1, 2, 3, 0], 3: [1, 0, 3, 2]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 1, 3, 0], 1: [3, 0, 2, 1], 2: [0, 3, 2, 1], 3: [3, 0, 2, 1]}\n", + "{0: [0, 2, 1, 3], 1: [3, 2, 1, 0], 2: [3, 2, 0, 1], 3: [2, 1, 3, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 2, 0, 1], 1: [1, 0, 2, 3], 2: [2, 1, 0, 3], 3: [3, 2, 0, 1]}\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [1, 3, 0, 2], 3: [3, 0, 2, 1]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 0, 3, 2], 1: [0, 2, 1, 3], 2: [3, 0, 1, 2], 3: [0, 1, 2, 3]}\n", + "{0: [0, 3, 1, 2], 1: [3, 2, 0, 1], 2: [2, 0, 1, 3], 3: [0, 1, 2, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 3, 1, 2], 1: [0, 1, 3, 2], 2: [1, 0, 2, 3], 3: [0, 1, 3, 2]}\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [0, 3, 1, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 3, 1], 2: [1, 0, 2, 3], 3: [0, 1, 2, 3]}\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 1, 2], 2: [3, 1, 2, 0], 3: [2, 0, 3, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 2, 1], 2: [1, 3, 2, 0], 3: [1, 3, 2, 0]}\n", + "{0: [3, 0, 1, 2], 1: [1, 0, 2, 3], 2: [1, 3, 0, 2], 3: [3, 2, 0, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 3, 1, 0], 1: [2, 1, 3, 0], 2: [2, 3, 1, 0], 3: [3, 2, 0, 1]}\n", + "{0: [1, 3, 0, 2], 1: [3, 0, 2, 1], 2: [3, 0, 2, 1], 3: [3, 0, 1, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [3, 2, 1, 0], 2: [0, 1, 2, 3], 3: [3, 1, 2, 0]}\n", + "{0: [0, 1, 3, 2], 1: [2, 0, 1, 3], 2: [1, 0, 3, 2], 3: [2, 0, 1, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 0, 1, 2], 1: [3, 2, 0, 1], 2: [1, 2, 0, 3], 3: [1, 3, 0, 2]}\n", + "{0: [3, 2, 1, 0], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [0, 1, 3, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 1, 3, 2], 1: [2, 0, 3, 1], 2: [0, 1, 3, 2], 3: [2, 1, 3, 0]}\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [2, 1, 0, 3]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 1, 0], 2: [0, 1, 3, 2], 3: [3, 1, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [2, 1, 3, 0], 3: [2, 0, 3, 1]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 3, 1, 0], 1: [0, 1, 2, 3], 2: [3, 1, 0, 2], 3: [2, 1, 0, 3]}\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 1, 2], 2: [3, 0, 2, 1], 3: [1, 0, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 0, 1], 2: [0, 3, 1, 2], 3: [0, 3, 1, 2]}\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [0, 1, 3, 2], 3: [1, 3, 2, 0]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [0, 3, 1, 2], 3: [0, 3, 1, 2]}\n", + "{0: [1, 3, 2, 0], 1: [0, 3, 2, 1], 2: [3, 1, 2, 0], 3: [3, 1, 0, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 0, 1, 2], 1: [3, 0, 2, 1], 2: [3, 1, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 2, 0], 2: [0, 2, 3, 1], 3: [3, 2, 1, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 0, 2], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 1, 3], 2: [1, 0, 3, 2], 3: [3, 2, 0, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [1, 3, 2, 0], 3: [1, 2, 0, 3]}\n", + "{0: [0, 1, 3, 2], 1: [3, 1, 0, 2], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 2, 3], 2: [0, 2, 1, 3], 3: [3, 2, 1, 0]}\n", + "{0: [3, 2, 1, 0], 1: [1, 0, 3, 2], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 3, 1, 2], 1: [1, 3, 2, 0], 2: [1, 2, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 3, 2], 2: [3, 2, 1, 0], 3: [2, 0, 3, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 3, 2, 0], 1: [1, 0, 3, 2], 2: [1, 2, 0, 3], 3: [1, 0, 2, 3]}\n", + "{0: [3, 1, 0, 2], 1: [1, 0, 3, 2], 2: [2, 0, 3, 1], 3: [1, 3, 2, 0]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [0, 1, 2, 3], 1: [0, 3, 1, 2], 2: [1, 0, 2, 3], 3: [0, 2, 1, 3]}\n", + "{0: [0, 3, 1, 2], 1: [0, 2, 3, 1], 2: [1, 0, 3, 2], 3: [0, 2, 1, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 2, 0], 2: [3, 2, 0, 1], 3: [2, 0, 1, 3]}\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 0, 3], 2: [1, 0, 3, 2], 3: [1, 3, 2, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 3, 2], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 2, 1], 2: [1, 3, 2, 0], 3: [2, 0, 3, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 2, 1], 2: [0, 2, 1, 3], 3: [1, 0, 3, 2]}\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 0, 3], 2: [3, 0, 2, 1], 3: [0, 3, 1, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 1, 3, 2], 1: [0, 3, 1, 2], 2: [3, 0, 2, 1], 3: [2, 0, 3, 1]}\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 1, 3], 2: [0, 3, 1, 2], 3: [0, 3, 1, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [3, 0, 2, 1], 2: [1, 3, 0, 2], 3: [2, 1, 3, 0]}\n", + "{0: [1, 2, 0, 3], 1: [2, 1, 3, 0], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 3, 2], 2: [0, 2, 1, 3], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 3, 0], 2: [0, 2, 1, 3], 3: [1, 2, 3, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 3, 1], 2: [2, 1, 0, 3], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 0, 3], 1: [1, 0, 3, 2], 2: [1, 2, 3, 0], 3: [1, 2, 0, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 2, 1], 2: [0, 1, 2, 3], 3: [2, 1, 3, 0]}\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 3, 0], 2: [0, 2, 3, 1], 3: [2, 1, 0, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 2, 3], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [0, 2, 1, 3]}\n", + "{0: [3, 1, 2, 0], 1: [0, 2, 1, 3], 2: [1, 0, 2, 3], 3: [1, 3, 0, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 0, 2], 2: [1, 3, 2, 0], 3: [2, 0, 1, 3]}\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 2, 1], 2: [3, 2, 1, 0], 3: [1, 2, 0, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "{0: [2, 0, 1, 3], 1: [0, 2, 1, 3], 2: [1, 2, 3, 0], 3: [0, 2, 3, 1]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 3, 0], 2: [3, 1, 2, 0], 3: [3, 2, 1, 0]}\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 0, 3], 2: [2, 3, 0, 1], 3: [2, 3, 1, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 3, 0], 2: [3, 2, 0, 1], 3: [1, 2, 3, 0]}\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 3, 0], 2: [1, 3, 0, 2], 3: [2, 0, 3, 1]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 2, 3], 1: [3, 2, 1, 0], 2: [3, 2, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [1, 3, 0, 2], 1: [2, 1, 0, 3], 2: [0, 2, 1, 3], 3: [2, 1, 3, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 3, 2], 2: [0, 2, 3, 1], 3: [2, 1, 0, 3]}\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 1, 0], 2: [0, 1, 3, 2], 3: [0, 1, 3, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 1, 3], 2: [0, 3, 2, 1], 3: [1, 0, 2, 3]}\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 1, 0], 2: [2, 1, 3, 0], 3: [3, 1, 0, 2]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 0, 1], 2: [0, 1, 3, 2], 3: [0, 1, 3, 2]}\n", + "{0: [2, 3, 1, 0], 1: [3, 1, 0, 2], 2: [1, 2, 0, 3], 3: [1, 2, 3, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 1, 3], 2: [2, 1, 3, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 0, 2, 3], 1: [3, 0, 2, 1], 2: [3, 0, 2, 1], 3: [1, 3, 2, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 0, 2], 2: [0, 1, 2, 3], 3: [3, 2, 1, 0]}\n", + "{0: [2, 1, 3, 0], 1: [3, 0, 1, 2], 2: [0, 1, 2, 3], 3: [1, 3, 2, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 3, 0, 1], 1: [2, 0, 3, 1], 2: [1, 0, 3, 2], 3: [3, 0, 1, 2]}\n", + "{0: [3, 2, 1, 0], 1: [1, 3, 0, 2], 2: [0, 1, 2, 3], 3: [1, 2, 3, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [3, 2, 1, 0], 3: [3, 0, 1, 2]}\n", + "{0: [3, 2, 0, 1], 1: [0, 1, 3, 2], 2: [2, 1, 3, 0], 3: [3, 1, 2, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 3, 2], 2: [3, 1, 2, 0], 3: [2, 1, 0, 3]}\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 1, 2], 2: [0, 1, 2, 3], 3: [1, 0, 2, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 3, 0], 2: [3, 1, 0, 2], 3: [0, 2, 1, 3]}\n", + "{0: [1, 2, 0, 3], 1: [2, 3, 0, 1], 2: [3, 2, 0, 1], 3: [2, 0, 1, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [1, 2, 0, 3], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [2, 0, 1, 3]}\n", + "{0: [1, 0, 2, 3], 1: [2, 1, 0, 3], 2: [2, 0, 1, 3], 3: [3, 1, 0, 2]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 3, 2], 1: [3, 1, 0, 2], 2: [2, 1, 3, 0], 3: [0, 3, 1, 2]}\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 3, 2], 2: [3, 0, 1, 2], 3: [0, 3, 1, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 1, 3, 0], 1: [3, 2, 1, 0], 2: [0, 2, 3, 1], 3: [1, 3, 0, 2]}\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 0, 2], 2: [3, 1, 2, 0], 3: [3, 1, 2, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 2, 3, 1], 1: [2, 1, 0, 3], 2: [2, 0, 1, 3], 3: [3, 2, 1, 0]}\n", + "{0: [2, 3, 0, 1], 1: [1, 2, 0, 3], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 0, 1, 2], 1: [3, 2, 1, 0], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 1, 3], 2: [0, 2, 1, 3], 3: [3, 0, 2, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [3, 2, 1, 0]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 3, 0], 2: [2, 1, 3, 0], 3: [3, 1, 0, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 1, 0], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "{0: [2, 1, 0, 3], 1: [2, 3, 1, 0], 2: [2, 0, 1, 3], 3: [2, 1, 3, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [3, 2, 1, 0]}\n", + "{0: [2, 3, 0, 1], 1: [1, 2, 3, 0], 2: [0, 3, 1, 2], 3: [1, 3, 0, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 3, 0], 1: [1, 3, 2, 0], 2: [2, 0, 1, 3], 3: [2, 0, 1, 3]}\n", + "{0: [3, 2, 0, 1], 1: [0, 2, 3, 1], 2: [2, 0, 3, 1], 3: [0, 1, 2, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 3, 2], 2: [0, 2, 1, 3], 3: [3, 2, 1, 0]}\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 3, 2], 2: [0, 3, 1, 2], 3: [2, 1, 0, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 0, 3, 1], 1: [2, 1, 0, 3], 2: [1, 0, 2, 3], 3: [1, 3, 2, 0]}\n", + "{0: [2, 3, 0, 1], 1: [1, 0, 2, 3], 2: [1, 3, 0, 2], 3: [0, 2, 1, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [1, 0, 3, 2], 1: [0, 3, 2, 1], 2: [1, 3, 2, 0], 3: [1, 2, 0, 3]}\n", + "{0: [1, 2, 3, 0], 1: [0, 3, 2, 1], 2: [2, 1, 0, 3], 3: [2, 3, 1, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [3, 2, 1, 0], 3: [1, 3, 2, 0]}\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 1, 0], 2: [3, 1, 0, 2], 3: [2, 3, 1, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [1, 0, 2, 3], 3: [3, 0, 2, 1]}\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 1, 0], 2: [0, 2, 1, 3], 3: [3, 1, 0, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 2, 0], 2: [1, 3, 2, 0], 3: [2, 0, 3, 1]}\n", + "{0: [1, 0, 3, 2], 1: [2, 3, 0, 1], 2: [0, 1, 2, 3], 3: [1, 0, 3, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 1, 2], 2: [0, 1, 2, 3], 3: [2, 0, 3, 1]}\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 1, 2], 2: [2, 1, 3, 0], 3: [0, 3, 2, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 0, 1], 2: [3, 0, 2, 1], 3: [0, 1, 3, 2]}\n", + "{0: [3, 1, 0, 2], 1: [3, 2, 0, 1], 2: [1, 0, 2, 3], 3: [0, 1, 2, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 0, 3, 1], 1: [3, 2, 1, 0], 2: [3, 1, 2, 0], 3: [1, 2, 0, 3]}\n", + "{0: [0, 1, 3, 2], 1: [2, 3, 0, 1], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 0, 1], 2: [0, 2, 1, 3], 3: [0, 1, 2, 3]}\n", + "{0: [3, 2, 0, 1], 1: [0, 2, 1, 3], 2: [3, 1, 0, 2], 3: [0, 3, 2, 1]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 1, 2, 3], 1: [2, 0, 1, 3], 2: [2, 3, 1, 0], 3: [2, 1, 3, 0]}\n", + "{0: [2, 3, 1, 0], 1: [0, 3, 1, 2], 2: [3, 0, 1, 2], 3: [1, 3, 2, 0]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 3, 0], 2: [0, 1, 2, 3], 3: [0, 3, 2, 1]}\n", + "{0: [1, 2, 0, 3], 1: [1, 0, 3, 2], 2: [2, 3, 1, 0], 3: [1, 3, 0, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [2, 0, 3, 1], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 0, 1], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 0, 2], 2: [1, 0, 2, 3], 3: [1, 0, 2, 3]}\n", + "{0: [2, 1, 3, 0], 1: [0, 2, 3, 1], 2: [2, 3, 1, 0], 3: [0, 3, 2, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 1, 0, 2], 1: [2, 1, 0, 3], 2: [0, 1, 2, 3], 3: [3, 0, 1, 2]}\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 2, 0], 2: [3, 2, 1, 0], 3: [2, 1, 0, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 1, 0, 2], 1: [3, 0, 1, 2], 2: [1, 3, 0, 2], 3: [0, 2, 3, 1]}\n", + "{0: [3, 1, 2, 0], 1: [0, 2, 1, 3], 2: [2, 3, 0, 1], 3: [1, 3, 0, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 2, 3], 2: [3, 0, 2, 1], 3: [1, 3, 0, 2]}\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 0, 1], 2: [0, 3, 2, 1], 3: [2, 1, 3, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 0, 2, 1], 1: [1, 0, 3, 2], 2: [1, 2, 0, 3], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 3, 1], 2: [3, 0, 1, 2], 3: [0, 1, 2, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 0, 3, 1], 1: [3, 2, 1, 0], 2: [1, 0, 2, 3], 3: [2, 3, 1, 0]}\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 1, 3], 2: [3, 2, 0, 1], 3: [3, 2, 1, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 1, 0, 2], 1: [3, 1, 0, 2], 2: [0, 2, 1, 3], 3: [0, 1, 3, 2]}\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 2, 3], 2: [2, 1, 3, 0], 3: [1, 0, 3, 2]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 1, 2], 2: [2, 0, 1, 3], 3: [2, 1, 0, 3]}\n", + "{0: [3, 1, 2, 0], 1: [2, 1, 0, 3], 2: [1, 0, 3, 2], 3: [0, 2, 3, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 0, 3, 1], 1: [1, 2, 0, 3], 2: [2, 3, 0, 1], 3: [0, 1, 2, 3]}\n", + "{0: [2, 3, 1, 0], 1: [2, 0, 3, 1], 2: [2, 1, 3, 0], 3: [3, 1, 2, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 1, 2, 0], 1: [1, 2, 3, 0], 2: [3, 0, 1, 2], 3: [3, 2, 1, 0]}\n", + "{0: [2, 3, 1, 0], 1: [1, 0, 3, 2], 2: [3, 0, 1, 2], 3: [0, 2, 1, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 1, 3], 2: [3, 1, 2, 0], 3: [1, 2, 0, 3]}\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 2, 1], 2: [0, 2, 3, 1], 3: [1, 3, 2, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [2, 0, 1, 3], 1: [1, 3, 0, 2], 2: [1, 2, 0, 3], 3: [1, 0, 2, 3]}\n", + "{0: [2, 1, 3, 0], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [0, 1, 2, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 1, 2], 2: [3, 2, 0, 1], 3: [2, 1, 0, 3]}\n", + "{0: [3, 2, 1, 0], 1: [1, 3, 0, 2], 2: [0, 1, 2, 3], 3: [2, 1, 0, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 1, 3, 2], 1: [0, 2, 3, 1], 2: [1, 2, 3, 0], 3: [3, 0, 2, 1]}\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 0, 3], 2: [3, 0, 2, 1], 3: [1, 3, 0, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 2, 3, 1], 1: [0, 3, 1, 2], 2: [3, 0, 2, 1], 3: [0, 3, 1, 2]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 2, 0], 2: [0, 3, 2, 1], 3: [0, 1, 3, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 3, 0, 1], 1: [2, 1, 3, 0], 2: [1, 0, 2, 3], 3: [3, 2, 1, 0]}\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 2, 3], 2: [3, 0, 2, 1], 3: [2, 3, 1, 0]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 3, 0], 2: [3, 2, 0, 1], 3: [0, 2, 3, 1]}\n", + "{0: [1, 0, 2, 3], 1: [2, 3, 0, 1], 2: [3, 0, 1, 2], 3: [3, 0, 1, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 2, 0], 2: [2, 1, 3, 0], 3: [3, 1, 0, 2]}\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [3, 1, 0, 2], 3: [3, 0, 1, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 3, 1], 2: [2, 1, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 2, 3], 2: [3, 0, 1, 2], 3: [0, 1, 3, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [2, 0, 3, 1], 1: [3, 1, 2, 0], 2: [3, 1, 0, 2], 3: [1, 3, 0, 2]}\n", + "{0: [1, 3, 0, 2], 1: [2, 3, 1, 0], 2: [3, 1, 0, 2], 3: [0, 1, 3, 2]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 0, 1], 2: [2, 3, 1, 0], 3: [0, 2, 1, 3]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 1, 2], 2: [0, 2, 3, 1], 3: [0, 1, 3, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [1, 3, 2, 0], 3: [0, 3, 1, 2]}\n", + "{0: [2, 0, 3, 1], 1: [0, 2, 3, 1], 2: [1, 2, 0, 3], 3: [3, 0, 2, 1]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [1, 0, 3, 2]}\n", + "{0: [1, 0, 3, 2], 1: [0, 1, 2, 3], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 2, 1], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [1, 3, 2, 0], 2: [2, 1, 0, 3], 3: [3, 2, 1, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 1, 2, 3], 1: [1, 2, 0, 3], 2: [2, 1, 3, 0], 3: [1, 3, 2, 0]}\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 3, 2], 2: [3, 2, 1, 0], 3: [0, 1, 3, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 3, 2], 2: [2, 0, 3, 1], 3: [3, 1, 2, 0]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 1, 3], 2: [2, 0, 3, 1], 3: [0, 1, 2, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 3, 1, 0], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [1, 2, 3, 0]}\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [3, 1, 2, 0], 3: [2, 1, 0, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 1, 2, 0], 1: [2, 0, 1, 3], 2: [2, 1, 3, 0], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 0, 3], 2: [2, 1, 0, 3], 3: [1, 3, 2, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 3, 1], 2: [3, 2, 0, 1], 3: [0, 3, 2, 1]}\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 2, 0], 2: [0, 2, 1, 3], 3: [0, 2, 3, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 2, 3, 1], 1: [1, 0, 3, 2], 2: [2, 1, 0, 3], 3: [2, 0, 1, 3]}\n", + "{0: [3, 1, 0, 2], 1: [3, 2, 0, 1], 2: [2, 1, 0, 3], 3: [0, 3, 2, 1]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 1, 3], 2: [3, 1, 2, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 3, 0, 2], 1: [0, 3, 2, 1], 2: [1, 3, 2, 0], 3: [0, 2, 1, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 0, 3], 2: [1, 3, 2, 0], 3: [0, 3, 1, 2]}\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 0, 1], 2: [0, 1, 2, 3], 3: [1, 3, 0, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 1, 0], 2: [2, 0, 3, 1], 3: [3, 2, 0, 1]}\n", + "{0: [0, 2, 3, 1], 1: [0, 2, 1, 3], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 1, 3], 2: [0, 3, 1, 2], 3: [1, 2, 3, 0]}\n", + "{0: [2, 3, 1, 0], 1: [3, 2, 1, 0], 2: [2, 1, 3, 0], 3: [0, 2, 3, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [1, 2, 3, 0], 1: [3, 0, 2, 1], 2: [1, 2, 3, 0], 3: [0, 2, 3, 1]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [1, 2, 0, 3], 3: [3, 1, 2, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [3, 1, 0, 2], 1: [1, 0, 3, 2], 2: [2, 0, 1, 3], 3: [0, 3, 1, 2]}\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 3, 2], 2: [2, 3, 0, 1], 3: [2, 3, 1, 0]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 2, 0], 2: [1, 0, 2, 3], 3: [1, 0, 3, 2]}\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 3, 1], 2: [1, 0, 3, 2], 3: [1, 0, 2, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 0, 3], 2: [3, 1, 0, 2], 3: [2, 3, 1, 0]}\n", + "{0: [2, 0, 3, 1], 1: [0, 3, 1, 2], 2: [0, 2, 1, 3], 3: [2, 3, 0, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [0, 1, 3, 2], 1: [2, 3, 1, 0], 2: [3, 1, 2, 0], 3: [3, 1, 0, 2]}\n", + "{0: [1, 3, 0, 2], 1: [0, 1, 3, 2], 2: [3, 0, 1, 2], 3: [2, 0, 1, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 3, 2], 2: [1, 3, 2, 0], 3: [1, 0, 3, 2]}\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 1, 0], 2: [3, 1, 2, 0], 3: [1, 2, 0, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 2, 1], 2: [1, 0, 3, 2], 3: [0, 3, 1, 2]}\n", + "{0: [0, 1, 2, 3], 1: [1, 2, 3, 0], 2: [2, 3, 1, 0], 3: [2, 3, 1, 0]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 3, 2], 2: [2, 3, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 0, 3], 2: [0, 2, 3, 1], 3: [1, 0, 2, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 0, 3], 2: [3, 0, 2, 1], 3: [1, 2, 0, 3]}\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 2, 0], 2: [2, 1, 0, 3], 3: [2, 3, 0, 1]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 3, 1, 0], 1: [3, 1, 0, 2], 2: [1, 3, 2, 0], 3: [2, 0, 3, 1]}\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 3, 0], 2: [3, 2, 1, 0], 3: [3, 1, 2, 0]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [3, 0, 2, 1], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [0, 2, 1, 3]}\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 0, 2], 2: [1, 0, 3, 2], 3: [2, 3, 0, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [3, 1, 0, 2], 1: [0, 3, 1, 2], 2: [2, 3, 0, 1], 3: [3, 1, 0, 2]}\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 2, 0], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 0, 2], 2: [1, 2, 3, 0], 3: [3, 1, 2, 0]}\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 3, 0], 2: [0, 2, 1, 3], 3: [1, 0, 3, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 3, 2, 1], 1: [2, 1, 0, 3], 2: [0, 1, 3, 2], 3: [3, 1, 2, 0]}\n", + "{0: [3, 2, 0, 1], 1: [0, 3, 1, 2], 2: [2, 1, 3, 0], 3: [0, 3, 1, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 1, 0], 2: [3, 0, 2, 1], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 3, 0], 2: [2, 1, 0, 3], 3: [3, 2, 1, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 3, 1, 0], 1: [0, 1, 2, 3], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [3, 2, 0, 1], 1: [1, 2, 0, 3], 2: [1, 2, 3, 0], 3: [2, 0, 1, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 1, 2, 0], 1: [3, 1, 2, 0], 2: [1, 2, 3, 0], 3: [3, 2, 0, 1]}\n", + "{0: [2, 1, 0, 3], 1: [1, 2, 3, 0], 2: [0, 1, 2, 3], 3: [1, 3, 0, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 2, 0, 1], 1: [3, 2, 1, 0], 2: [1, 3, 0, 2], 3: [2, 0, 3, 1]}\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 2, 3], 2: [3, 0, 1, 2], 3: [1, 3, 0, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 2, 0], 2: [3, 2, 0, 1], 3: [2, 1, 0, 3]}\n", + "{0: [2, 0, 3, 1], 1: [3, 0, 1, 2], 2: [2, 1, 3, 0], 3: [1, 0, 2, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 3, 1], 2: [0, 1, 2, 3], 3: [3, 1, 2, 0]}\n", + "{0: [3, 0, 1, 2], 1: [0, 2, 1, 3], 2: [2, 3, 0, 1], 3: [0, 3, 2, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 1, 0, 3], 1: [3, 1, 0, 2], 2: [0, 3, 1, 2], 3: [3, 0, 1, 2]}\n", + "{0: [3, 0, 1, 2], 1: [3, 0, 1, 2], 2: [3, 1, 0, 2], 3: [2, 0, 1, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 3, 0], 2: [1, 3, 2, 0], 3: [1, 2, 3, 0]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [0, 2, 3, 1], 3: [2, 0, 1, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [0, 1, 3, 2], 1: [2, 0, 3, 1], 2: [3, 0, 1, 2], 3: [2, 3, 0, 1]}\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 0, 3], 2: [3, 1, 0, 2], 3: [1, 0, 2, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 2, 1], 2: [1, 2, 3, 0], 3: [1, 0, 2, 3]}\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 2, 3], 2: [1, 0, 2, 3], 3: [3, 2, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 1, 0, 2], 1: [0, 2, 1, 3], 2: [2, 0, 1, 3], 3: [2, 1, 0, 3]}\n", + "{0: [2, 3, 0, 1], 1: [1, 0, 2, 3], 2: [0, 3, 2, 1], 3: [0, 1, 3, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 1, 3], 2: [0, 3, 1, 2], 3: [2, 0, 3, 1]}\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 0, 3], 2: [2, 3, 1, 0], 3: [1, 3, 2, 0]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [3, 2, 0, 1], 3: [3, 2, 0, 1]}\n", + "{0: [3, 1, 0, 2], 1: [3, 0, 1, 2], 2: [0, 3, 1, 2], 3: [3, 1, 2, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 0, 1, 3], 1: [3, 1, 2, 0], 2: [0, 3, 1, 2], 3: [0, 1, 3, 2]}\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 3, 1], 2: [2, 3, 1, 0], 3: [0, 1, 2, 3]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [1, 2, 0, 3], 3: [3, 0, 1, 2]}\n", + "{0: [3, 1, 2, 0], 1: [1, 2, 3, 0], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 2, 0, 1], 1: [3, 1, 2, 0], 2: [1, 2, 0, 3], 3: [1, 0, 3, 2]}\n", + "{0: [3, 0, 1, 2], 1: [3, 0, 1, 2], 2: [3, 1, 0, 2], 3: [0, 1, 3, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [3, 1, 2, 0], 3: [0, 2, 3, 1]}\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 1, 2], 2: [3, 1, 2, 0], 3: [1, 2, 0, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [0, 1, 2, 3], 2: [3, 2, 1, 0], 3: [3, 1, 2, 0]}\n", + "{0: [0, 2, 3, 1], 1: [2, 3, 1, 0], 2: [3, 1, 0, 2], 3: [0, 2, 1, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 0, 2], 2: [0, 1, 3, 2], 3: [2, 1, 3, 0]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 1, 3], 2: [3, 2, 0, 1], 3: [2, 0, 3, 1]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 2, 0], 2: [3, 0, 1, 2], 3: [2, 1, 3, 0]}\n", + "{0: [3, 0, 1, 2], 1: [1, 0, 3, 2], 2: [2, 0, 3, 1], 3: [2, 0, 3, 1]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 1, 2, 0], 1: [1, 3, 0, 2], 2: [0, 1, 2, 3], 3: [3, 1, 2, 0]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [0, 2, 1, 3], 3: [1, 2, 3, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [1, 3, 0, 2], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [3, 2, 1, 0]}\n", + "{0: [1, 2, 3, 0], 1: [2, 1, 3, 0], 2: [2, 1, 3, 0], 3: [2, 0, 1, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 3, 2], 2: [1, 0, 2, 3], 3: [3, 0, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [1, 0, 2, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [1, 0, 3, 2]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [2, 0, 3, 1], 3: [0, 3, 1, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 0, 2, 3], 1: [1, 0, 2, 3], 2: [0, 2, 1, 3], 3: [0, 1, 2, 3]}\n", + "{0: [0, 1, 2, 3], 1: [3, 0, 2, 1], 2: [2, 3, 1, 0], 3: [2, 1, 0, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 2, 3, 0], 1: [2, 3, 1, 0], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 2, 3], 2: [2, 1, 3, 0], 3: [0, 3, 2, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 1, 0], 2: [0, 1, 2, 3], 3: [3, 0, 2, 1]}\n", + "{0: [3, 1, 0, 2], 1: [2, 0, 3, 1], 2: [3, 0, 1, 2], 3: [2, 1, 3, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [2, 1, 3, 0], 1: [0, 2, 1, 3], 2: [3, 2, 1, 0], 3: [2, 0, 1, 3]}\n", + "{0: [0, 3, 1, 2], 1: [2, 1, 3, 0], 2: [0, 3, 2, 1], 3: [3, 0, 1, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [3, 2, 1, 0], 1: [1, 3, 0, 2], 2: [0, 1, 2, 3], 3: [0, 3, 1, 2]}\n", + "{0: [0, 2, 1, 3], 1: [1, 3, 0, 2], 2: [3, 0, 2, 1], 3: [1, 2, 3, 0]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 1, 3, 2], 1: [0, 3, 2, 1], 2: [0, 3, 1, 2], 3: [3, 1, 2, 0]}\n", + "{0: [2, 3, 1, 0], 1: [1, 2, 0, 3], 2: [0, 3, 1, 2], 3: [0, 1, 2, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [3, 0, 1, 2], 1: [3, 1, 0, 2], 2: [3, 0, 1, 2], 3: [2, 1, 0, 3]}\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 3, 2], 2: [3, 1, 0, 2], 3: [2, 0, 1, 3]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [2, 0, 3, 1], 1: [2, 0, 1, 3], 2: [2, 3, 0, 1], 3: [0, 3, 2, 1]}\n", + "{0: [1, 0, 2, 3], 1: [3, 1, 0, 2], 2: [2, 0, 3, 1], 3: [1, 0, 2, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 1, 2, 3], 1: [0, 2, 3, 1], 2: [0, 2, 1, 3], 3: [0, 3, 1, 2]}\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 2, 0], 2: [1, 0, 3, 2], 3: [0, 1, 3, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 3, 2], 2: [3, 0, 2, 1], 3: [2, 1, 3, 0]}\n", + "{0: [1, 0, 2, 3], 1: [1, 0, 2, 3], 2: [0, 3, 1, 2], 3: [3, 2, 1, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [0, 2, 3, 1], 2: [2, 1, 3, 0], 3: [0, 3, 2, 1]}\n", + "{0: [2, 1, 0, 3], 1: [0, 3, 2, 1], 2: [1, 2, 3, 0], 3: [3, 2, 0, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 0, 1], 2: [3, 0, 1, 2], 3: [0, 3, 1, 2]}\n", + "{0: [3, 0, 1, 2], 1: [1, 2, 0, 3], 2: [3, 1, 2, 0], 3: [1, 0, 2, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 2, 3], 2: [2, 3, 0, 1], 3: [3, 1, 0, 2]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [2, 0, 1, 3], 3: [1, 0, 2, 3]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [2, 0, 1, 3], 1: [3, 0, 1, 2], 2: [3, 0, 1, 2], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 3, 0], 1: [3, 1, 0, 2], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [0, 2, 3, 1], 1: [2, 0, 1, 3], 2: [2, 3, 1, 0], 3: [2, 3, 0, 1]}\n", + "{0: [3, 1, 2, 0], 1: [1, 2, 0, 3], 2: [3, 2, 1, 0], 3: [1, 2, 3, 0]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 0, 3, 2], 1: [3, 0, 1, 2], 2: [0, 1, 3, 2], 3: [2, 0, 1, 3]}\n", + "{0: [2, 0, 3, 1], 1: [3, 1, 2, 0], 2: [3, 2, 1, 0], 3: [0, 1, 3, 2]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [0, 2, 1, 3], 1: [3, 0, 2, 1], 2: [0, 2, 3, 1], 3: [3, 1, 0, 2]}\n", + "{0: [1, 0, 2, 3], 1: [1, 2, 3, 0], 2: [3, 2, 1, 0], 3: [1, 0, 3, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 3, 1], 2: [2, 3, 0, 1], 3: [2, 1, 3, 0]}\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 3, 0], 2: [1, 2, 0, 3], 3: [0, 3, 1, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 3, 2], 2: [0, 2, 3, 1], 3: [3, 2, 0, 1]}\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [2, 3, 0, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [1, 0, 3, 2], 3: [3, 2, 0, 1]}\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 3, 2], 2: [1, 0, 3, 2], 3: [2, 1, 0, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [3, 0, 1, 2], 3: [0, 3, 2, 1]}\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 2, 1], 2: [2, 3, 0, 1], 3: [0, 2, 1, 3]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 3, 0, 2], 1: [2, 1, 0, 3], 2: [0, 3, 1, 2], 3: [2, 1, 3, 0]}\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 2, 3], 2: [0, 1, 3, 2], 3: [2, 1, 3, 0]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 0, 1, 3], 1: [0, 3, 2, 1], 2: [1, 3, 2, 0], 3: [0, 2, 3, 1]}\n", + "{0: [1, 2, 0, 3], 1: [2, 1, 3, 0], 2: [0, 1, 3, 2], 3: [0, 3, 2, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 1, 2, 3], 1: [1, 2, 0, 3], 2: [2, 3, 1, 0], 3: [0, 3, 1, 2]}\n", + "{0: [0, 3, 1, 2], 1: [3, 0, 1, 2], 2: [2, 3, 0, 1], 3: [0, 1, 2, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 2, 1, 3], 1: [1, 0, 2, 3], 2: [2, 3, 1, 0], 3: [3, 1, 2, 0]}\n", + "{0: [3, 0, 1, 2], 1: [0, 1, 2, 3], 2: [0, 1, 3, 2], 3: [0, 1, 3, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 1, 0, 2], 1: [0, 1, 3, 2], 2: [1, 3, 2, 0], 3: [3, 2, 0, 1]}\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 0, 2], 2: [0, 2, 1, 3], 3: [0, 1, 3, 2]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [2, 0, 1, 3], 1: [1, 0, 2, 3], 2: [1, 2, 3, 0], 3: [1, 3, 0, 2]}\n", + "{0: [3, 2, 0, 1], 1: [2, 3, 0, 1], 2: [1, 0, 3, 2], 3: [1, 2, 0, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [1, 0, 2, 3], 2: [1, 3, 0, 2], 3: [1, 2, 0, 3]}\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 2, 0], 2: [0, 1, 2, 3], 3: [3, 0, 1, 2]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [2, 3, 1, 0], 1: [3, 2, 0, 1], 2: [0, 2, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [1, 2, 3, 0], 1: [3, 2, 1, 0], 2: [2, 0, 3, 1], 3: [2, 0, 3, 1]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 2, 1, 0], 1: [2, 1, 3, 0], 2: [2, 3, 1, 0], 3: [0, 1, 2, 3]}\n", + "{0: [3, 1, 2, 0], 1: [0, 3, 2, 1], 2: [0, 3, 2, 1], 3: [0, 3, 2, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 1, 2], 2: [2, 0, 3, 1], 3: [1, 2, 3, 0]}\n", + "{0: [0, 1, 2, 3], 1: [0, 3, 1, 2], 2: [3, 0, 1, 2], 3: [3, 1, 2, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 0, 3], 2: [3, 0, 2, 1], 3: [3, 2, 0, 1]}\n", + "{0: [2, 3, 0, 1], 1: [2, 1, 0, 3], 2: [0, 2, 1, 3], 3: [3, 0, 2, 1]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [3, 2, 1, 0], 1: [2, 0, 3, 1], 2: [1, 2, 0, 3], 3: [2, 0, 1, 3]}\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 2, 0], 2: [2, 1, 3, 0], 3: [2, 0, 3, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [1, 2, 0, 3], 1: [3, 0, 2, 1], 2: [0, 1, 3, 2], 3: [0, 3, 1, 2]}\n", + "{0: [3, 2, 0, 1], 1: [1, 3, 2, 0], 2: [3, 2, 1, 0], 3: [2, 1, 0, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [3, 1, 0, 2], 1: [1, 0, 3, 2], 2: [3, 2, 0, 1], 3: [3, 0, 2, 1]}\n", + "{0: [3, 2, 1, 0], 1: [1, 0, 2, 3], 2: [3, 1, 2, 0], 3: [2, 3, 0, 1]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 2, 1, 0], 2: [0, 3, 2, 1], 3: [0, 1, 2, 3]}\n", + "{0: [1, 2, 3, 0], 1: [3, 1, 2, 0], 2: [3, 0, 1, 2], 3: [0, 2, 3, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 0, 2, 1], 1: [2, 0, 1, 3], 2: [0, 2, 1, 3], 3: [0, 1, 3, 2]}\n", + "{0: [2, 1, 0, 3], 1: [0, 2, 3, 1], 2: [1, 3, 2, 0], 3: [3, 0, 1, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 0, 1], 2: [1, 3, 0, 2], 3: [1, 2, 0, 3]}\n", + "{0: [1, 3, 0, 2], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [3, 2, 0, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 3, 1, 0], 1: [0, 3, 1, 2], 2: [3, 1, 2, 0], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 1, 3], 1: [1, 3, 0, 2], 2: [1, 2, 3, 0], 3: [0, 2, 3, 1]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [3, 2, 1, 0], 1: [3, 2, 0, 1], 2: [2, 3, 0, 1], 3: [2, 0, 3, 1]}\n", + "{0: [2, 3, 0, 1], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [2, 3, 0, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 0, 3, 2], 1: [2, 1, 0, 3], 2: [3, 0, 2, 1], 3: [2, 1, 3, 0]}\n", + "{0: [0, 1, 3, 2], 1: [3, 2, 0, 1], 2: [0, 1, 3, 2], 3: [3, 1, 0, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [1, 0, 2, 3], 1: [0, 2, 1, 3], 2: [3, 2, 1, 0], 3: [1, 3, 0, 2]}\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 2, 0], 2: [2, 3, 1, 0], 3: [0, 1, 3, 2]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [2, 0, 1, 3], 1: [1, 2, 3, 0], 2: [2, 3, 0, 1], 3: [1, 2, 3, 0]}\n", + "{0: [0, 1, 2, 3], 1: [0, 1, 3, 2], 2: [2, 1, 0, 3], 3: [1, 2, 3, 0]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 3, 0, 2], 1: [0, 2, 3, 1], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 3, 2, 0], 1: [0, 2, 1, 3], 2: [1, 0, 2, 3], 3: [3, 1, 2, 0]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 3, 0], 2: [2, 3, 0, 1], 3: [0, 1, 2, 3]}\n", + "{0: [0, 1, 3, 2], 1: [0, 1, 3, 2], 2: [0, 2, 1, 3], 3: [3, 0, 1, 2]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [1, 0, 3, 2], 1: [3, 0, 2, 1], 2: [2, 0, 3, 1], 3: [1, 2, 3, 0]}\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 1, 3], 2: [1, 0, 3, 2], 3: [2, 1, 3, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 2, 1, 3], 1: [0, 1, 3, 2], 2: [1, 2, 0, 3], 3: [3, 1, 0, 2]}\n", + "{0: [1, 2, 0, 3], 1: [3, 1, 0, 2], 2: [0, 1, 3, 2], 3: [3, 1, 0, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 0, 1], 2: [2, 3, 1, 0], 3: [1, 2, 3, 0]}\n", + "{0: [0, 2, 1, 3], 1: [0, 1, 3, 2], 2: [0, 2, 3, 1], 3: [3, 1, 0, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [3, 1, 0, 2], 3: [1, 2, 0, 3]}\n", + "{0: [0, 3, 2, 1], 1: [1, 2, 0, 3], 2: [2, 3, 0, 1], 3: [2, 1, 0, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 1, 3, 2], 1: [1, 0, 3, 2], 2: [2, 3, 0, 1], 3: [0, 3, 2, 1]}\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 2, 3], 2: [3, 2, 1, 0], 3: [1, 0, 3, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [3, 2, 1, 0], 1: [3, 0, 2, 1], 2: [1, 0, 2, 3], 3: [1, 0, 3, 2]}\n", + "{0: [1, 3, 0, 2], 1: [3, 1, 2, 0], 2: [3, 1, 0, 2], 3: [0, 1, 2, 3]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 2, 0, 1], 1: [1, 2, 3, 0], 2: [1, 2, 3, 0], 3: [1, 3, 2, 0]}\n", + "{0: [3, 0, 2, 1], 1: [3, 0, 1, 2], 2: [1, 0, 3, 2], 3: [0, 2, 1, 3]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [2, 1, 0, 3], 1: [0, 1, 2, 3], 2: [3, 2, 1, 0], 3: [0, 3, 2, 1]}\n", + "{0: [3, 0, 2, 1], 1: [3, 1, 2, 0], 2: [1, 2, 0, 3], 3: [1, 0, 2, 3]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [0, 2, 3, 1], 1: [3, 1, 0, 2], 2: [0, 2, 3, 1], 3: [0, 3, 2, 1]}\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 0, 1], 2: [1, 2, 0, 3], 3: [3, 2, 1, 0]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [0, 3, 1, 2], 1: [2, 0, 3, 1], 2: [2, 3, 0, 1], 3: [0, 2, 1, 3]}\n", + "{0: [2, 3, 1, 0], 1: [1, 0, 3, 2], 2: [3, 1, 2, 0], 3: [0, 1, 2, 3]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [3, 0, 1, 2], 1: [0, 3, 1, 2], 2: [0, 2, 1, 3], 3: [0, 1, 2, 3]}\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 1, 2], 2: [1, 2, 3, 0], 3: [2, 3, 1, 0]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 2, 3, 0], 1: [2, 3, 1, 0], 2: [2, 3, 1, 0], 3: [1, 2, 0, 3]}\n", + "{0: [3, 1, 2, 0], 1: [1, 3, 2, 0], 2: [0, 2, 3, 1], 3: [0, 1, 2, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 1, 2], 2: [2, 0, 1, 3], 3: [2, 1, 0, 3]}\n", + "{0: [3, 1, 2, 0], 1: [0, 1, 3, 2], 2: [1, 0, 2, 3], 3: [3, 0, 1, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [2, 1, 0, 3], 1: [1, 3, 2, 0], 2: [2, 0, 3, 1], 3: [1, 2, 0, 3]}\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 3, 0], 2: [1, 3, 2, 0], 3: [3, 1, 0, 2]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [2, 1, 0, 3], 1: [3, 2, 1, 0], 2: [1, 3, 0, 2], 3: [0, 2, 3, 1]}\n", + "{0: [2, 0, 3, 1], 1: [2, 3, 0, 1], 2: [0, 3, 1, 2], 3: [2, 1, 0, 3]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 0, 3, 1], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [2, 0, 3, 1]}\n", + "{0: [1, 3, 2, 0], 1: [2, 1, 3, 0], 2: [3, 2, 0, 1], 3: [1, 3, 2, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 0, 1], 2: [3, 2, 1, 0], 3: [0, 1, 2, 3]}\n", + "{0: [3, 2, 0, 1], 1: [0, 1, 3, 2], 2: [3, 2, 1, 0], 3: [0, 3, 2, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [3, 2, 1, 0], 1: [1, 3, 2, 0], 2: [1, 0, 3, 2], 3: [2, 3, 0, 1]}\n", + "{0: [1, 0, 2, 3], 1: [0, 1, 3, 2], 2: [2, 0, 1, 3], 3: [0, 2, 3, 1]}\n", + "[3, 1, 0, 2]\n", + "[2, 1, 3, 0]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 2, 0], 2: [2, 0, 3, 1], 3: [2, 0, 1, 3]}\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [3, 0, 2, 1], 3: [3, 0, 1, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 3, 1], 2: [3, 0, 1, 2], 3: [0, 2, 3, 1]}\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 0, 3], 2: [2, 0, 3, 1], 3: [0, 3, 2, 1]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 1, 2, 0], 1: [0, 2, 1, 3], 2: [2, 1, 0, 3], 3: [3, 0, 2, 1]}\n", + "{0: [0, 3, 2, 1], 1: [3, 0, 2, 1], 2: [3, 0, 2, 1], 3: [0, 1, 3, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 2, 1], 2: [2, 0, 1, 3], 3: [0, 3, 1, 2]}\n", + "{0: [2, 3, 1, 0], 1: [2, 3, 1, 0], 2: [3, 2, 1, 0], 3: [1, 0, 2, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 2, 1, 3], 1: [2, 1, 3, 0], 2: [3, 1, 0, 2], 3: [0, 3, 1, 2]}\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 0, 2], 2: [0, 1, 2, 3], 3: [2, 0, 3, 1]}\n", + "[0, 2, 3, 1]\n", + "[0, 3, 1, 2]\n", + "{0: [1, 0, 3, 2], 1: [1, 3, 2, 0], 2: [3, 2, 1, 0], 3: [2, 0, 1, 3]}\n", + "{0: [0, 1, 2, 3], 1: [1, 0, 3, 2], 2: [1, 2, 3, 0], 3: [0, 3, 2, 1]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 2, 3, 1], 1: [3, 2, 1, 0], 2: [0, 2, 3, 1], 3: [3, 1, 0, 2]}\n", + "{0: [1, 3, 0, 2], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [0, 3, 1, 2]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [3, 0, 2, 1], 3: [2, 1, 3, 0]}\n", + "{0: [2, 0, 3, 1], 1: [3, 2, 0, 1], 2: [0, 3, 1, 2], 3: [2, 3, 0, 1]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [1, 0, 3, 2], 1: [0, 1, 3, 2], 2: [0, 1, 3, 2], 3: [1, 0, 3, 2]}\n", + "{0: [3, 0, 1, 2], 1: [2, 0, 3, 1], 2: [2, 0, 3, 1], 3: [2, 0, 1, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [2, 1, 3, 0], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [3, 0, 2, 1]}\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 1, 0], 2: [3, 0, 2, 1], 3: [2, 3, 1, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 0, 2], 2: [3, 2, 0, 1], 3: [1, 0, 3, 2]}\n", + "{0: [0, 3, 1, 2], 1: [0, 1, 3, 2], 2: [0, 1, 3, 2], 3: [1, 3, 0, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 3, 2], 2: [0, 3, 2, 1], 3: [0, 2, 3, 1]}\n", + "{0: [1, 3, 0, 2], 1: [1, 0, 2, 3], 2: [0, 2, 1, 3], 3: [1, 3, 2, 0]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 2, 1, 0], 1: [0, 1, 2, 3], 2: [1, 0, 3, 2], 3: [2, 1, 3, 0]}\n", + "{0: [0, 3, 1, 2], 1: [3, 1, 2, 0], 2: [0, 2, 3, 1], 3: [0, 2, 3, 1]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [0, 2, 1, 3], 1: [0, 3, 2, 1], 2: [1, 0, 2, 3], 3: [2, 1, 3, 0]}\n", + "{0: [1, 3, 2, 0], 1: [1, 2, 3, 0], 2: [2, 3, 1, 0], 3: [1, 0, 3, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 1, 2, 3], 1: [1, 0, 2, 3], 2: [0, 2, 3, 1], 3: [1, 3, 0, 2]}\n", + "{0: [2, 0, 1, 3], 1: [2, 3, 1, 0], 2: [2, 1, 3, 0], 3: [1, 2, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 2, 3, 0], 1: [1, 0, 2, 3], 2: [2, 1, 3, 0], 3: [1, 0, 3, 2]}\n", + "{0: [2, 3, 0, 1], 1: [1, 3, 2, 0], 2: [2, 0, 1, 3], 3: [0, 3, 1, 2]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [1, 3, 0, 2], 1: [2, 0, 3, 1], 2: [3, 0, 2, 1], 3: [1, 2, 0, 3]}\n", + "{0: [2, 1, 3, 0], 1: [2, 0, 3, 1], 2: [1, 3, 0, 2], 3: [2, 1, 3, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 3, 1, 0], 1: [3, 0, 1, 2], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "{0: [1, 2, 3, 0], 1: [1, 3, 2, 0], 2: [1, 0, 2, 3], 3: [0, 3, 2, 1]}\n", + "[2, 3, 1, 0]\n", + "[3, 2, 0, 1]\n", + "{0: [2, 3, 0, 1], 1: [0, 3, 2, 1], 2: [1, 2, 0, 3], 3: [2, 1, 3, 0]}\n", + "{0: [0, 1, 2, 3], 1: [0, 3, 1, 2], 2: [3, 0, 2, 1], 3: [3, 2, 0, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 2, 0, 3], 1: [2, 0, 3, 1], 2: [2, 0, 3, 1], 3: [2, 0, 3, 1]}\n", + "{0: [2, 0, 3, 1], 1: [3, 2, 1, 0], 2: [3, 1, 2, 0], 3: [3, 0, 1, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [1, 0, 2, 3], 1: [1, 3, 0, 2], 2: [2, 1, 0, 3], 3: [1, 2, 3, 0]}\n", + "{0: [3, 0, 2, 1], 1: [2, 3, 0, 1], 2: [1, 3, 0, 2], 3: [3, 0, 1, 2]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 3, 1, 0], 1: [0, 2, 3, 1], 2: [0, 1, 2, 3], 3: [0, 2, 3, 1]}\n", + "{0: [3, 2, 1, 0], 1: [2, 3, 1, 0], 2: [0, 2, 3, 1], 3: [3, 2, 1, 0]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 1, 0], 2: [1, 3, 0, 2], 3: [0, 3, 2, 1]}\n", + "{0: [3, 1, 2, 0], 1: [1, 2, 0, 3], 2: [2, 1, 0, 3], 3: [2, 3, 0, 1]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 2, 3], 1: [3, 0, 1, 2], 2: [2, 0, 1, 3], 3: [0, 3, 2, 1]}\n", + "{0: [1, 3, 2, 0], 1: [2, 3, 0, 1], 2: [1, 2, 0, 3], 3: [1, 0, 2, 3]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [2, 3, 0, 1], 1: [1, 0, 3, 2], 2: [1, 3, 0, 2], 3: [3, 0, 2, 1]}\n", + "{0: [3, 1, 2, 0], 1: [2, 3, 0, 1], 2: [0, 3, 2, 1], 3: [0, 2, 1, 3]}\n", + "[2, 1, 3, 0]\n", + "[3, 1, 0, 2]\n", + "{0: [1, 2, 3, 0], 1: [2, 1, 3, 0], 2: [0, 3, 2, 1], 3: [2, 3, 0, 1]}\n", + "{0: [3, 0, 2, 1], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [2, 3, 0, 1]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [2, 3, 0, 1], 1: [2, 0, 3, 1], 2: [1, 3, 2, 0], 3: [3, 0, 2, 1]}\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 3, 2], 2: [0, 1, 2, 3], 3: [0, 2, 3, 1]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [0, 1, 3, 2], 1: [1, 2, 3, 0], 2: [1, 0, 2, 3], 3: [3, 2, 0, 1]}\n", + "{0: [2, 1, 3, 0], 1: [2, 1, 0, 3], 2: [2, 1, 0, 3], 3: [1, 2, 0, 3]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 2, 0, 3], 1: [1, 2, 3, 0], 2: [2, 0, 3, 1], 3: [1, 0, 2, 3]}\n", + "{0: [1, 2, 0, 3], 1: [1, 3, 2, 0], 2: [0, 2, 1, 3], 3: [0, 3, 1, 2]}\n", + "[1, 2, 0, 3]\n", + "[2, 0, 1, 3]\n", + "{0: [0, 3, 2, 1], 1: [3, 1, 0, 2], 2: [1, 3, 0, 2], 3: [2, 0, 3, 1]}\n", + "{0: [1, 0, 2, 3], 1: [3, 1, 0, 2], 2: [0, 1, 2, 3], 3: [1, 3, 0, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [0, 3, 2, 1], 1: [0, 3, 1, 2], 2: [2, 0, 3, 1], 3: [1, 0, 2, 3]}\n", + "{0: [2, 3, 0, 1], 1: [2, 3, 0, 1], 2: [3, 1, 0, 2], 3: [0, 2, 3, 1]}\n", + "[0, 3, 2, 1]\n", + "[0, 3, 2, 1]\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [2, 0, 3, 1], 3: [3, 0, 2, 1]}\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 0, 1], 2: [1, 2, 3, 0], 3: [3, 2, 1, 0]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [0, 3, 1, 2], 1: [0, 3, 1, 2], 2: [3, 1, 0, 2], 3: [0, 1, 2, 3]}\n", + "{0: [2, 0, 1, 3], 1: [0, 3, 1, 2], 2: [1, 3, 0, 2], 3: [0, 3, 1, 2]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 3, 2, 0], 1: [3, 0, 2, 1], 2: [3, 0, 2, 1], 3: [2, 1, 0, 3]}\n", + "{0: [0, 2, 1, 3], 1: [1, 2, 3, 0], 2: [0, 2, 1, 3], 3: [0, 2, 1, 3]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [2, 0, 1, 3], 1: [0, 1, 2, 3], 2: [2, 3, 0, 1], 3: [1, 0, 3, 2]}\n", + "{0: [1, 2, 0, 3], 1: [3, 2, 0, 1], 2: [0, 2, 3, 1], 3: [3, 2, 1, 0]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n", + "{0: [1, 2, 3, 0], 1: [1, 2, 0, 3], 2: [1, 3, 0, 2], 3: [2, 3, 1, 0]}\n", + "{0: [2, 1, 0, 3], 1: [3, 0, 2, 1], 2: [1, 3, 2, 0], 3: [2, 3, 1, 0]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [2, 3, 0, 1], 1: [0, 1, 2, 3], 2: [1, 0, 3, 2], 3: [2, 0, 3, 1]}\n", + "{0: [2, 0, 3, 1], 1: [1, 3, 0, 2], 2: [0, 1, 3, 2], 3: [0, 2, 1, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [2, 0, 1, 3], 1: [2, 0, 1, 3], 2: [1, 2, 3, 0], 3: [2, 1, 3, 0]}\n", + "{0: [1, 0, 3, 2], 1: [3, 1, 0, 2], 2: [0, 2, 1, 3], 3: [2, 0, 1, 3]}\n", + "[2, 0, 1, 3]\n", + "[1, 2, 0, 3]\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 2, 1], 2: [3, 2, 0, 1], 3: [0, 1, 3, 2]}\n", + "{0: [0, 1, 2, 3], 1: [2, 1, 0, 3], 2: [1, 0, 3, 2], 3: [1, 0, 3, 2]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 3, 2, 1], 1: [1, 0, 3, 2], 2: [2, 0, 3, 1], 3: [3, 2, 0, 1]}\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 3, 2], 2: [1, 2, 3, 0], 3: [3, 1, 0, 2]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [0, 2, 3, 1], 1: [0, 1, 2, 3], 2: [3, 2, 0, 1], 3: [0, 2, 1, 3]}\n", + "{0: [1, 0, 3, 2], 1: [3, 2, 0, 1], 2: [3, 1, 2, 0], 3: [2, 0, 3, 1]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [3, 0, 2, 1], 1: [3, 0, 1, 2], 2: [2, 1, 0, 3], 3: [1, 3, 0, 2]}\n", + "{0: [1, 2, 3, 0], 1: [0, 1, 2, 3], 2: [0, 1, 2, 3], 3: [3, 0, 2, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [1, 2, 0, 3], 2: [2, 1, 0, 3], 3: [0, 3, 2, 1]}\n", + "{0: [0, 2, 1, 3], 1: [3, 2, 1, 0], 2: [3, 1, 0, 2], 3: [0, 1, 3, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [3, 1, 0, 2], 1: [2, 3, 0, 1], 2: [3, 2, 1, 0], 3: [0, 3, 2, 1]}\n", + "{0: [3, 1, 2, 0], 1: [3, 2, 1, 0], 2: [2, 0, 1, 3], 3: [1, 2, 3, 0]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [0, 1, 3, 2], 1: [3, 1, 2, 0], 2: [1, 3, 2, 0], 3: [0, 2, 1, 3]}\n", + "{0: [1, 0, 2, 3], 1: [2, 0, 3, 1], 2: [3, 0, 1, 2], 3: [1, 0, 2, 3]}\n", + "[0, 3, 1, 2]\n", + "[0, 2, 3, 1]\n", + "{0: [1, 2, 0, 3], 1: [0, 1, 3, 2], 2: [0, 3, 1, 2], 3: [1, 2, 0, 3]}\n", + "{0: [1, 2, 0, 3], 1: [0, 2, 1, 3], 2: [2, 0, 1, 3], 3: [1, 0, 2, 3]}\n", + "[1, 0, 3, 2]\n", + "[1, 0, 3, 2]\n", + "{0: [3, 0, 1, 2], 1: [3, 0, 2, 1], 2: [2, 1, 0, 3], 3: [1, 2, 3, 0]}\n", + "{0: [2, 1, 3, 0], 1: [0, 1, 2, 3], 2: [0, 1, 2, 3], 3: [0, 3, 2, 1]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [0, 3, 1, 2], 1: [1, 0, 3, 2], 2: [1, 0, 2, 3], 3: [0, 1, 3, 2]}\n", + "{0: [0, 2, 3, 1], 1: [2, 3, 0, 1], 2: [3, 2, 0, 1], 3: [3, 1, 2, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [1, 3, 2, 0], 1: [1, 3, 2, 0], 2: [0, 1, 3, 2], 3: [1, 2, 3, 0]}\n", + "{0: [1, 2, 0, 3], 1: [3, 0, 2, 1], 2: [0, 2, 3, 1], 3: [0, 2, 3, 1]}\n", + "[1, 3, 0, 2]\n", + "[2, 0, 3, 1]\n", + "{0: [1, 0, 3, 2], 1: [0, 1, 2, 3], 2: [2, 0, 1, 3], 3: [3, 1, 2, 0]}\n", + "{0: [0, 1, 2, 3], 1: [3, 1, 0, 2], 2: [3, 0, 1, 2], 3: [2, 3, 0, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 0, 3], 2: [1, 3, 0, 2], 3: [2, 0, 3, 1]}\n", + "{0: [0, 1, 3, 2], 1: [1, 0, 2, 3], 2: [0, 1, 3, 2], 3: [1, 2, 0, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 0, 1, 2], 1: [2, 1, 3, 0], 2: [1, 0, 3, 2], 3: [1, 2, 3, 0]}\n", + "{0: [0, 1, 3, 2], 1: [3, 1, 2, 0], 2: [3, 0, 1, 2], 3: [0, 2, 1, 3]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 1, 2, 0], 1: [2, 0, 3, 1], 2: [2, 0, 1, 3], 3: [2, 3, 1, 0]}\n", + "{0: [1, 3, 2, 0], 1: [3, 2, 0, 1], 2: [0, 1, 3, 2], 3: [0, 3, 1, 2]}\n", + "[3, 2, 0, 1]\n", + "[2, 3, 1, 0]\n", + "{0: [3, 2, 1, 0], 1: [0, 2, 3, 1], 2: [1, 3, 2, 0], 3: [3, 0, 2, 1]}\n", + "{0: [0, 3, 1, 2], 1: [3, 2, 1, 0], 2: [1, 0, 3, 2], 3: [1, 2, 3, 0]}\n", + "[3, 0, 1, 2]\n", + "[1, 2, 3, 0]\n", + "{0: [3, 0, 1, 2], 1: [3, 2, 1, 0], 2: [1, 2, 3, 0], 3: [2, 3, 0, 1]}\n", + "{0: [0, 3, 2, 1], 1: [1, 3, 0, 2], 2: [1, 0, 3, 2], 3: [0, 3, 1, 2]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 2, 1], 2: [2, 1, 3, 0], 3: [0, 1, 3, 2]}\n", + "{0: [3, 1, 2, 0], 1: [3, 0, 1, 2], 2: [2, 1, 3, 0], 3: [2, 1, 0, 3]}\n", + "[3, 0, 2, 1]\n", + "[1, 3, 2, 0]\n", + "{0: [1, 2, 0, 3], 1: [0, 3, 2, 1], 2: [0, 2, 1, 3], 3: [3, 1, 0, 2]}\n", + "{0: [0, 2, 1, 3], 1: [2, 0, 3, 1], 2: [3, 2, 1, 0], 3: [3, 0, 2, 1]}\n", + "[1, 0, 2, 3]\n", + "[1, 0, 2, 3]\n", + "{0: [3, 0, 2, 1], 1: [3, 2, 1, 0], 2: [2, 1, 0, 3], 3: [0, 2, 3, 1]}\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 0, 2], 2: [3, 1, 0, 2], 3: [3, 2, 0, 1]}\n", + "[3, 2, 1, 0]\n", + "[3, 2, 1, 0]\n", + "{0: [2, 0, 3, 1], 1: [2, 3, 1, 0], 2: [3, 2, 0, 1], 3: [2, 3, 1, 0]}\n", + "{0: [3, 2, 0, 1], 1: [3, 0, 1, 2], 2: [0, 1, 2, 3], 3: [1, 3, 2, 0]}\n", + "[2, 3, 0, 1]\n", + "[2, 3, 0, 1]\n", + "{0: [3, 2, 1, 0], 1: [1, 0, 2, 3], 2: [3, 2, 1, 0], 3: [1, 0, 3, 2]}\n", + "{0: [1, 0, 3, 2], 1: [1, 2, 0, 3], 2: [1, 0, 3, 2], 3: [3, 1, 0, 2]}\n", + "[3, 1, 2, 0]\n", + "[3, 1, 2, 0]\n", + "{0: [0, 2, 3, 1], 1: [2, 3, 1, 0], 2: [0, 1, 2, 3], 3: [0, 2, 1, 3]}\n", + "{0: [3, 1, 0, 2], 1: [3, 1, 2, 0], 2: [0, 1, 2, 3], 3: [3, 1, 0, 2]}\n", + "[0, 2, 1, 3]\n", + "[0, 2, 1, 3]\n", + "{0: [1, 3, 2, 0], 1: [3, 1, 0, 2], 2: [1, 2, 3, 0], 3: [1, 3, 0, 2]}\n", + "{0: [0, 2, 3, 1], 1: [1, 3, 2, 0], 2: [1, 0, 3, 2], 3: [3, 1, 2, 0]}\n", + "[1, 3, 2, 0]\n", + "[3, 0, 2, 1]\n", + "{0: [0, 2, 1, 3], 1: [1, 0, 2, 3], 2: [1, 3, 2, 0], 3: [3, 2, 0, 1]}\n", + "{0: [0, 3, 1, 2], 1: [2, 3, 1, 0], 2: [3, 1, 2, 0], 3: [0, 1, 2, 3]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [1, 2, 0, 3], 1: [2, 3, 0, 1], 2: [2, 3, 1, 0], 3: [0, 1, 2, 3]}\n", + "{0: [2, 3, 0, 1], 1: [2, 0, 1, 3], 2: [1, 3, 2, 0], 3: [1, 0, 2, 3]}\n", + "[1, 2, 3, 0]\n", + "[3, 0, 1, 2]\n", + "{0: [0, 2, 3, 1], 1: [1, 2, 3, 0], 2: [1, 2, 3, 0], 3: [3, 0, 2, 1]}\n", + "{0: [3, 2, 1, 0], 1: [3, 1, 2, 0], 2: [1, 3, 0, 2], 3: [2, 1, 3, 0]}\n", + "[0, 1, 2, 3]\n", + "[0, 1, 2, 3]\n", + "{0: [2, 3, 1, 0], 1: [1, 3, 0, 2], 2: [2, 1, 0, 3], 3: [3, 0, 2, 1]}\n", + "{0: [3, 2, 1, 0], 1: [0, 3, 1, 2], 2: [3, 0, 2, 1], 3: [2, 0, 1, 3]}\n", + "[2, 1, 0, 3]\n", + "[2, 1, 0, 3]\n", + "{0: [0, 1, 3, 2], 1: [1, 3, 0, 2], 2: [3, 0, 2, 1], 3: [1, 2, 0, 3]}\n", + "{0: [3, 0, 2, 1], 1: [1, 3, 0, 2], 2: [2, 1, 3, 0], 3: [3, 0, 1, 2]}\n", + "[0, 1, 3, 2]\n", + "[0, 1, 3, 2]\n", + "{0: [2, 0, 3, 1], 1: [0, 2, 3, 1], 2: [0, 2, 3, 1], 3: [2, 3, 1, 0]}\n", + "{0: [1, 3, 2, 0], 1: [0, 1, 2, 3], 2: [2, 3, 0, 1], 3: [3, 1, 0, 2]}\n", + "[2, 0, 3, 1]\n", + "[1, 3, 0, 2]\n" + ] + } + ], + "source": [ + "def stableMatching(humanitiesPrefs,sciencePrefs):\n", + " unassignedHumanities = set(humanitiesPrefs.keys())\n", + " humanitiesArr = [-1]*len(humanitiesPrefs)\n", + " scienceArr = [-1]*len(sciencePrefs)\n", + " while(unassignedHumanities):\n", + " for i in range(len(humanitiesPrefs)):\n", + " for j in range(len(sciencePrefs)):\n", + " scientistHumanitiesLike = humanitiesPrefs[i][j]\n", + " if(scienceArr[scientistHumanitiesLike]==-1 or scienceArr[scientistHumanitiesLike]>i):\n", + " humanitiesArr[i] = scientistHumanitiesLike\n", + " if(scienceArr[scientistHumanitiesLike]!=-1):\n", + " humanitiesArr[scienceArr[scientistHumanitiesLike]]=-1 and unassignedHumanities.add(scienceArr[scientistHumanitiesLike])\n", + " scienceArr[scientistHumanitiesLike]=i\n", + " unassignedHumanities.remove(i)\n", + " break\n", + " \n", + " return humanitiesArr, scienceArr\n", + "\n", + "def generateLists(n):\n", + " dictA = {k: list(range(n)) for k in range(n)}\n", + " dictB = {k: list(range(n)) for k in range(n)}\n", + " \n", + " for i in range(1000):\n", + " for j in range(n):\n", + " random.seed(time.time())\n", + " random.shuffle(dictA[j])\n", + " random.shuffle(dictB[j])\n", + "\n", + " print(dictA)\n", + " print(dictB)\n", + " humanitiesArr, scienceArr = stableMatching(dictA,dictB)\n", + "\n", + " print(humanitiesArr)\n", + " print(scienceArr)\n", + "\n", + " \n", + "generateLists(4)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "C. Measure Execution Time for Varying List Sizes\n", + "\n", + "Double the size of the preference lists from problem A several times (you can create student names like \"student1,\" \"student2,\" etc.) and measure the amount of time it takes to create stable housing assignments. Analyze how the execution time grows in relation to the size of the lists.\n", + "\n", + "Measure execution time for different list sizes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time taken for algorithm to execute on 4 * 4 elements is 2.193450927734375e-05 seconds\n", + "Time taken for algorithm to execute on 8 * 8 elements is 2.2172927856445312e-05 seconds\n", + "Time taken for algorithm to execute on 16 * 16 elements is 4.38690185546875e-05 seconds\n" + ] + } + ], + "source": [ + "def stableMatching(humanitiesPrefs,sciencePrefs):\n", + " unassignedHumanities = set(humanitiesPrefs.keys())\n", + " humanitiesArr = [-1]*len(humanitiesPrefs)\n", + " scienceArr = [-1]*len(sciencePrefs)\n", + " while(unassignedHumanities):\n", + " for i in range(len(humanitiesPrefs)):\n", + " for j in range(len(sciencePrefs)):\n", + " scientistHumanitiesLike = humanitiesPrefs[i][j]\n", + " if(scienceArr[scientistHumanitiesLike]==-1 or scienceArr[scientistHumanitiesLike]>i):\n", + " humanitiesArr[i] = scientistHumanitiesLike\n", + " if(scienceArr[scientistHumanitiesLike]!=-1):\n", + " humanitiesArr[scienceArr[scientistHumanitiesLike]]=-1 and unassignedHumanities.add(scienceArr[scientistHumanitiesLike])\n", + " scienceArr[scientistHumanitiesLike]=i\n", + " unassignedHumanities.remove(i)\n", + " break\n", + " \n", + " return humanitiesArr, scienceArr\n", + "\n", + "def generateListsAndCheckTime(n):\n", + " dictA = {k: list(range(n)) for k in range(n)}\n", + " dictB = {k: list(range(n)) for k in range(n)}\n", + " \n", + " for j in range(n):\n", + " random.seed(time.time())\n", + " random.shuffle(dictA[j])\n", + " random.shuffle(dictB[j])\n", + " start_time = time.time()\n", + " \n", + " \n", + "\n", + " # print(dictA)\n", + " # print(dictB)\n", + " humanitiesArr, scienceArr = stableMatching(dictA,dictB)\n", + "\n", + " # print(humanitiesArr)\n", + " # print(scienceArr)\n", + " print(\"Time taken for algorithm to execute on \", n,\"*\",n ,\" elements is \" , (time.time() - start_time) ,\" seconds\")\n", + "\n", + " \n", + "generateListsAndCheckTime(4)\n", + "generateListsAndCheckTime(8)\n", + "generateListsAndCheckTime(16)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.readme b/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.readme new file mode 100644 index 0000000..922d33b --- /dev/null +++ b/Submissions/002839203_Anuraag_Bathula/002839203_Anuraag_Bathula_Assignment-1.readme @@ -0,0 +1,3 @@ +Assignment-1 summary + +This assignment helped me understand the challenges of generating correct questions using AI tools. Very often, the question made no sense or the answer was wrong, and it required my own verification to make sure it was a worthy of being put on an assignment. At the same time, I discovered a lot of interesting formats for questions that i would not have been able to come up with by myself. I did not think of creating a question based on best case time complexity, which I could only do because ChatGPT gave me the idea. Other than that, the assignment greatly improved my knowledge of asymptotic time complexity and helped me in increasing my coding ability due to my custom implementation of Gale Shapley. In addition, I learned how to use python and Jupyter Notebooks. \ No newline at end of file diff --git a/Submissions/Abhishek Hegde_002744522/Assignment 1.readme b/Submissions/Abhishek Hegde_002744522/Assignment 1.readme new file mode 100644 index 0000000..64a8072 --- /dev/null +++ b/Submissions/Abhishek Hegde_002744522/Assignment 1.readme @@ -0,0 +1,7 @@ +Assignment 1 +NUID: 002744522 + +Using ChatGPT and based on the worked examples provided, I have tried to create new algorithemic problems, and +throighout the assignment, I have provided clear and well-structured solutions, offered logical explanations, and +demonstrated a solid grasp of algorithmic concepts. These solutions and explanations can be a valuable resource for +others studying algorithms. \ No newline at end of file diff --git a/Submissions/Abhishek Hegde_002744522/PSA - Assignment 1.ipynb b/Submissions/Abhishek Hegde_002744522/PSA - Assignment 1.ipynb new file mode 100644 index 0000000..6395aea --- /dev/null +++ b/Submissions/Abhishek Hegde_002744522/PSA - Assignment 1.ipynb @@ -0,0 +1,488 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "INFO 6205 - Program Structure and Algorithms(PSA)\\\n", + "Assignment 1\\\n", + "Student Name: Abhishek Hegde\\\n", + "NUID: 002744522\\\n", + "Professor: Nick Bear Brown\\\n", + "Date: 9/24/2023" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q1. Arrange the following functions in increasing order of growth: \\\n", + " • 4n\\\n", + " • 5n + 100log(n)\\\n", + " • 0.5n2\\\n", + " • 0.7n log(n)\\\n", + " • 2log(n)\\\n", + " • n log(n)\\\n", + " • n0.5\\\n", + " • n2\\\n", + " • 10n\\\n", + "\n", + " Answer : \n", + " 2log(n) < 5n + 100log(n) < 10n < 4n < n0.5 < 0.7n log(n) < n log(n) < 0.5n2 < n2\n", + "\n", + " Explanation:\n", + " ● 2log(n) grows slower than any polynomial function, so it comes before any polynomial function.\n", + " ● Functions with linear growth (4n, 5n + 100log(n), 10n) grow slower than any polynomial function with degree greater than one, but faster than any logarithmic or sublinear function, so they come after logarithmic and sublinear functions and before any polynomial function with degree greater than two.\n", + " ● n0.5 grows slower than linear and polynomial functions with degree greater than one, but faster than logarithmic functions and sublinear functions, so it comes after logarithmic and sublinear functions and before any polynomial function with degree greater than one.\n", + " ● 0.7n log(n) grows faster than n0.5, but slower than n log(n).\n", + " ● Functions with polynomial growth of the same degree grow at the same rate, so we compare their leading terms. For example, 0.5n2 grows faster than n0.5, but slower than n2." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q2. One algorithm requires n log2(n) seconds and another algorithm requires √n seconds.\n", + " Which one is asymptotically faster? What is the cross-over value of n? (The value at which the curves intersect?)\n", + "\n", + " Answer:\n", + " Let, \n", + " T1 = n log2(n)\n", + " T2 = √n\n", + " The growth rate of T2 = √n is proportional to √n, that of T1 = n log2(n) is proportional to n log2(n). The value of n log2(n) increases faster than √n as √n gets closer to infinity.\n", + "\n", + " n log2(n) = √n\n", + " Squaring both sides:\n", + " n log2(n)^2 = n\n", + " log2(n)^2 = 1\n", + " log2(n) = 1\n", + " n = 2^1 = 2\n", + "![Alt text](image.png)\n", + " \n", + " x = 1/(log^(2/3)(2))\n", + " x = 1.27 \n", + " So, the cross-over value of n is 1.27, meaning that for values of n less than 1.27, the algorithm with running time T2 is faster, and for values of n greater than 1.27, the algorithm with running time T1 is faster.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q3. Stable Matching in Hospital Residency\n", + " In a hospital residency program, there are a set of medical students and a set of hospitals. Each hospital ranks its preferred students, and each student ranks their preferred hospitals. Your task is to implement a stable matching algorithm to assign students to hospitals. A matching is stable if there are no pairs (student, hospital) and (student', hospital') where both hospital prefers student' over student and student' prefers hospital over hospital'.\n", + " Write a Python function stable_matching(hospitals, students, hospital_prefs, student_prefs) that takes four inputs:\n", + " •\thospitals: A list of hospital names.\n", + " •\tstudents: A list of student names.\n", + " •\thospital_prefs: A dictionary where keys are hospital names and values are lists of student names, representing the hospital's ranked preferences.\n", + " •\tstudent_prefs: A dictionary where keys are student names and values are lists of hospital names, representing the student's ranked preferences.\n", + " The function should return a stable matching, where each hospital is matched with one student.\n", + " Expected Output:\n", + " The function should return a dictionary where keys are hospital names, and values are the names of their matched students.\n", + "\n", + " Answer:\n", + " This below solution implements the Stable Marriage algorithm but adapted for the hospital residency problem. It iteratively assigns students to hospitals, ensuring stability by checking preferences. The algorithm continues until all students are matched. The function returns a dictionary where hospitals are keys and matched students are values." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def stable_matching(hospitals, students, hospital_prefs, student_prefs):\n", + " hospital_matches = {}\n", + " student_matches = {}\n", + " students_without_match = set(students)\n", + "\n", + " while students_without_match:\n", + " student = students_without_match.pop()\n", + " hospital_choices = student_prefs[student]\n", + " for hospital in hospital_choices:\n", + " if hospital not in hospital_matches:\n", + " hospital_matches[hospital] = student\n", + " student_matches[student] = hospital\n", + " break\n", + " else:\n", + " current_match = hospital_matches[hospital]\n", + " if hospital_prefs[hospital].index(student) < hospital_prefs[hospital].index(current_match):\n", + " # Student is preferred by the hospital over the current match\n", + " students_without_match.add(current_match)\n", + " hospital_matches[hospital] = student\n", + " student_matches[student] = hospital\n", + " break\n", + " return hospital_matches" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q4. Prove the following:\\\n", + " In the Gale-Shapley algorithm, run with n men and n women, what is the maximum number of times any woman can be proposed to?\\\n", + " Solution: n2 − n + 2 \n", + "\n", + " Answer: \n", + " Assumption: n2 - n + 2\n", + " For n = 1, 1 male and 1 female, no. of the proposal made will be 1 = 1 - 1 + 1.\n", + " Inductive Case: We must prove P(n) => P(n+1)\n", + " Assume P(n) is true.\n", + " In the group of n male and females, max n-1 proposals were made by n-1 males and 1 male made n proposal.\n", + " Now for n+1 males and females, we have one more male and one more female than the set of n, those n-1\n", + " male need to propose one more female (to make total n proposals for n males), and the new male added to\n", + " the set will be making n+1 proposal (1 male proposal n+1 females).\n", + " No. of proposals for n + 1 set\t= No. of proposals made for n set + (𝑛 − 1) + (𝑛 + 1)\n", + " = n2 - n + 2 + n - 1 + n + 1\n", + " = n2 + n + 2\n", + " = (n + 1)2 - (n + 1) + 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q5. Decide whether you think the following statement is true or false.\n", + " If it is true, give a short explanation. If it is false, give a counterexample.\n", + " True or false? In every instance of the Stable Marriage Problem, there is a stable matching containing a pair (m, w) such that m is ranked last on the preference list of w and w is ranked last on the preference list of m.\n", + " B. Suppose we are given an instance of the Stable Marriage Problem for which there is a woman w who is ranked last by all men. Prove or give a counterexample: In any stable matching, w must be paired with her last choice.\n", + "\n", + " Answer: \n", + " A. The statement is false.\n", + " Consider an instance where there are two men, m1 and m2, and two women, w1 and w2. Suppose the preference lists are as follows:\n", + " m1: w1 > w2\n", + " m2: w2 > w1\n", + " w1: m1 > m2\n", + " w2: m2 > m1\n", + " If m1 is matched with w2 and m2 is matched with w1, then this is a stable matching, but there is no pair (m, w) such that m is ranked first on w's list and w is ranked first on m's list.\n", + "\n", + " Pseudo code: \n", + " 1. For each man m:\n", + " 2. m proposes to the highest-ranked woman w on his list who has not yet rejected him.\n", + " 3. For each woman w:\n", + " 4. If w has multiple proposals, she rejects all but her highest-ranked proposal.\n", + " 5. Repeat steps 2-4 until every man is either engaged or has been rejected by every woman.\n", + " 6. The resulting matching is stable.\n", + "\n", + " B. The statement is true.\n", + " If w is ranked last by all men, then no man will prefer to be with w over their current partner, so w will not be able to break any unstable pairs. Therefore, w must be paired with her last choice in any stable matching.\n", + "\n", + " Pseudo code: \n", + " 1. Let M be the set of all men and W be the set of all women.\n", + " 2. Let m be a man who is the first choice of all women.\n", + " 3. Suppose for the sake of contradiction that in some stable matching, m is not paired with his first choice.\n", + " 4. Then there exists a woman w such that m is paired with a woman w' who is ranked higher than w on m's preference list.\n", + " 5. But since m is the first choice of all women, w' must prefer some man m' to m.\n", + " 6. Since w' prefers m' to m, and m' is not paired with any woman he prefers less than w', they form a blocking pair.\n", + " 7. This contradicts the assumption that matching is stable.\n", + " 8. Therefore, in any stable matching, m must be paired with his first choice." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q6. Consider a variant of the stable marriage problem where each person has incomplete preference lists, that is,\n", + " they may only have preferences over a subset of the members of the opposite sex. Assume that the size of each person's preference list is at least two, and that no person has themselves on their preference list.\n", + " A. Is it possible for a perfect matching to not exist in this variant of the stable marriage problem?\n", + " If so, provide an example. If not, prove it.\n", + " B. Suppose we have an algorithm that produces a perfect matching in this variant of the stable marriage problem.\n", + " Prove that the algorithm must also produce a stable matching.\n", + "\n", + " Answer: \n", + " A. Yes, it is possible for a perfect matching to not exist in this variant of the stable marriage\n", + " problem. Consider the following example:\n", + " Let there be four men and four women, where each person only has preferences over two members of the\n", + " opposite sex as follows:\n", + " Men:\n", + " M1: {W1, W2}\n", + " M2: {W1, W2}\n", + " M3: {W3, W4}\n", + " M4: {W3, W4}\n", + "\n", + " Women:\n", + " W1: {M1, M2}\n", + " W2: {M1, M2}\n", + " W3: {M3, M4}\n", + " W4: {M3, M4}\n", + "\n", + " In this case, there is no perfect matching since M3 and M4 both prefer W3 and there is no woman who\n", + " prefers either of them to their current partners.\n", + "\n", + " B. To prove that the algorithm produces a stable matching, we need to show that there are no unstable pairs.\n", + " Let S be a perfect matching produced by the algorithm, and suppose there exists an unstable pair (m, w) such that m prefers w to their partner in S, and w prefers m to their partner in S.\n", + " Since the algorithm produces a perfect matching, we know that w prefers their partner in S to m. However, since m prefers w to their partner in S, their partner must prefer m to their current partner. This means that (m, w) is not an unstable pair, which contradicts our assumption.\n", + " Therefore, the algorithm must produce a stable matching.\n", + "\n", + " Pseudo Code:\n", + " 1. Initialize all men and women to be free\n", + " 2. while there exists a free man m who has a woman w he hasn't proposed to yet\n", + " 3. choose the highest-ranked woman w' on m's preference list that m hasn't proposed to yet,\n", + " or one of the women he's tied with\n", + " 4. if w is free, then match m and w\n", + " 5. else if w prefers m to her current partner m', then break existing match between w and m',\n", + " and match m and w\n", + " 6. mark m' as free\n", + " 7. else, m remains free and continues proposing\n", + " 8. return the set of stable matches\n", + "\n", + " Below code implements the Gale-Shapley algorithm with ties to find stable matches between an equal\n", + " number of men and women with possibly incomplete and tied preference lists.\n", + "\n", + " Args:\n", + " - men_prefs (dict): A dictionary of preference lists, where the keys are men and the values\n", + " are lists of the women they prefer, with possible ties.\n", + " - women_prefs (dict): A dictionary of preference lists, where the keys are women and the values\n", + " are lists of the men they prefer, with possible ties.\n", + " Returns:\n", + " - A dictionary of stable matches, where the keys are men and the values are their partners.\n", + "\n", + "\n", + " men_prefs = {\n", + " 'm1': ['w3', 'w2', 'w1'],\n", + " 'm2': ['w1', 'w3', 'w2'],\n", + " 'm3': ['w1', 'w2', 'w3']\n", + " }\n", + " women_prefs = {\n", + " 'w1': ['m2', 'm1', 'm3'],\n", + " 'w2': ['m3', 'm2', 'm1'],\n", + " 'w3': ['m1', 'm3', 'm2']\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def gale_shapley_ties(men_prefs, women_prefs):\n", + " # Initialize all men and women to be free\n", + " free_men = set(men_prefs.keys())\n", + " free_women = set(women_prefs.keys())\n", + " matches = {}\n", + "\n", + " while free_men:\n", + " m = free_men.pop()\n", + " m_prefs = men_prefs[m]\n", + "\n", + " for w in m_prefs:\n", + " if w not in matches:\n", + " # If woman is free, match her with the man\n", + " matches[w] = m\n", + " break\n", + " else:\n", + " m_prime = matches[w]\n", + " w_prefs = women_prefs[w]\n", + "\n", + " if w_prefs.index(m) < w_prefs.index(m_prime):\n", + " # If the woman prefers the new man to her current partner, break the existing match and match her with the new man\n", + " matches[w] = m\n", + " free_men.add(m_prime)\n", + " break\n", + "\n", + " return matches" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q7. Suppose we have two algorithms, one with time complexity O(nlog(n)) and another with time complexity O(√n).\n", + " To determine which algorithm is asymptotically faster, we need to analyze their growth rates.\n", + "\n", + " Answer:\n", + " The growth rate of O(nlog(n)) is logarithmic, meaning that the running time grows proportionally to the logarithm of the input size. On the other hand, the growth rate of O(√n) is proportional to the square root of the input size. To compare these two growth rates, we can take their ratio and see which one dominates as n grows larger:\n", + " lim(n->∞) (nlog(n) / √n) = lim(n->∞) (√n log(n)) = ∞\n", + "\n", + " Since the limit approaches infinity, we can conclude that the growth rate of nlog(n) dominates over √n, and thus the algorithm with time complexity O(nlog(n)) is asymptotically faster. To find the crossover value of n, we need to find the point at which the two functions intersect. We can set them equal to each other and solve for n:\n", + " \n", + " nlog(n) = k√n\n", + " n log(n) / √n = k\n", + " n^(3/2) = k\n", + " n = k^(2/3)\n", + "\n", + " Therefore, the crossover value of n is k^(2/3). This means that for input sizes smaller than k^(2/3), the algorithm with time complexity O(√n) will be faster, and for input sizes larger than k^(2/3), the algorithm with time complexity O(nlog(n)) will be faster." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q8. Prime Number Generator\n", + "Write a Python function generate_primes(n) that generates the first n prime numbers. The function should return a list of prime numbers.\n", + "\n", + "Input:\n", + "\n", + "n: An integer specifying the number of prime numbers to generate.\n", + "Output:\n", + "\n", + "The function should return a list of the first n prime numbers.\n", + "\n", + " Answer: The below solution generates the first n prime numbers using a simple primality test. It iterates through numbers starting from 2, checks if each number is prime by testing divisibility, and adds prime numbers to the list until n primes are found. The list of prime numbers is then returned." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_primes(n):\n", + " primes = []\n", + " num = 2\n", + "\n", + " while len(primes) < n:\n", + " is_prime = True\n", + "\n", + " for divisor in range(2, int(num ** 0.5) + 1):\n", + " if num % divisor == 0:\n", + " is_prime = False\n", + " break\n", + "\n", + " if is_prime:\n", + " primes.append(num)\n", + " num += 1\n", + "\n", + " return primes\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q9. Given a set of n points in the plane, find the smallest number of line segments required to connect them such that each point is connected to at least one other point, and no two line segments intersect.\n", + "\n", + "Constraint:\n", + "\n", + "The line segments must not intersect.\n", + "\n", + "Input:\n", + "\n", + "A set of n points in the plane.\n", + "\n", + "Output:\n", + "\n", + "The smallest number of line segments required to connect them such that each point is connected to at least one other point, and no two line segments intersect.\n", + "\n", + " Answer: \n", + " To solve this problem, we can use the following algorithm:\n", + " 1. Sort the points in decreasing order of their x-coordinate.\n", + " 2. Initialize a set S of connected points to be empty.\n", + " 3. Iterate over the points in the sorted order:\n", + " -> If the current point is not connected to any point in S, add it to S.\n", + " -> Otherwise, find the closest point in S to the current point.\n", + " -> If the distance between the current point and the closest point is greater than the threshold\n", + " and there is no line segment that intersects the line segment connecting the current point to\n", + " the closest point, add a line segment connecting them to S.\n", + "\n", + " The threshold is a parameter that controls the trade-off between the number of line segments and the total length of the line segments. A higher threshold will result in fewer line segments, but the total length of the line segments may be longer.\n", + "\n", + " Analysis:\n", + "\n", + " The time complexity of the algorithm is O(nlogn), since we need to sort the points and then iterate over them. The space complexity of the algorithm is O(n), since we need to store the set S of connected points." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Q10. Given a graph and a source node, find the shortest path from the source node to all other nodes in the graph, such that the path does not visit any node more than once.\n", + "\n", + "Constraint:\n", + "\n", + "The path must be found using the Breadth-First Search (BFS) algorithm.\n", + "\n", + "Input:\n", + "\n", + "A graph and a source node.\n", + "\n", + "Output:\n", + "\n", + "A list of the shortest paths from the source node to all other nodes in the graph, such that the path does not visit any node more than once.\n", + "\n", + " Answer:To solve this problem, we can use the following algorithm:\n", + "\n", + " 1. Initialize a queue Q and add the source node to it.\n", + " 2. Mark the source node as visited.\n", + " 3. While Q is not empty:\n", + " -> Remove the first node n from Q.\n", + " -> For each neighbor m of n that is not visited:\n", + " -> Add m to Q.\n", + " -> Mark m as visited.\n", + " -> Store the shortest path from the source node to n as the parent of m in a tree.\n", + " 4. Return the tree.\n", + " \n", + " The tree returned by the algorithm will contain the shortest paths from the source node to all other nodes in the graph. The shortest path to a node can be found by traversing the tree from the node to the root." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I believe that this problem is a good example of a non-trivial problem that aligns with the essence and structure of the given example problem. The problem is similar to the given example problem in that it is an algorithmic problem that requires finding the shortest path between two nodes in a graph. However, the problem is also different from the given example problem in that it has a constraint on the order in which the nodes in the graph are visited. This constraint makes the problem more challenging to solve." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " REFLECTION :" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I used ChatGPT to help me come up with this problem by brainstorming ideas.\n", + "ChatGPT assisted me in this task by providing me with the following:\\\n", + " -> A clear and concise understanding of the problem statement.\\\n", + " -> A variety of potential solutions to the problem, including both correct and incorrect solutions.\\\n", + " -> Feedback on the correctness and completeness of my solutions.\\\n", + "Overall, I found ChatGPT to be a very helpful tool for problem design in the realm of algorithms. It helped me to come up with new ideas, understand existing problems, and develop solutions to problems." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The main challenge I faced in ensuring that the problems maintained the spirit of the example was to create problems that were both challenging and meaningful.\\\n", + "Another challenge I faced was ensuring that the problem was well-defined and unambiguous. I wanted to make sure that the problem statement was clear and concise, and that there was only one correct solution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I learned a lot about problem design in the realm of algorithms while working on this task. I learned that it is important to design problems that are clear and concise, and which has a target audience, and also it is important to keep it unique and interesting.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Overall, I found this task to be a challenging but rewarding experience. I learned a lot about problem design, and I am confident that I can use this knowledge to design new and interesting problems in the future." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/Christ_Rodrigues_002727863/PSA assignment 1- Christ Rodrigues.ipynb b/Submissions/Christ_Rodrigues_002727863/PSA assignment 1- Christ Rodrigues.ipynb new file mode 100644 index 0000000..6a6d5ae --- /dev/null +++ b/Submissions/Christ_Rodrigues_002727863/PSA assignment 1- Christ Rodrigues.ipynb @@ -0,0 +1,454 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8873c120", + "metadata": {}, + "source": [ + "The World Cup is changing its playoff format using the Gale-Shapley matching algorithm. The eight best teams from groups A,B & C, called Super Group 1, will be matched against the eight best teams from groups D, E & F, called Super Group 2, using the Gale-Shapley matching algorithm. Further social media will be used to ask fans, media, players and coaches to create a ranking of which teams they would most like to see play their favorite team. \n", + " \n" + ] + }, + { + "cell_type": "markdown", + "id": "9adc12b4", + "metadata": {}, + "source": [ + "Run pip install pprint random timeit" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2f77132c", + "metadata": {}, + "outputs": [], + "source": [ + "#import all the required library to run the program\n", + "import pprint\n", + "import random\n", + "\n", + "pp = pprint.PrettyPrinter() # Pretty printer" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fa1c2165", + "metadata": {}, + "outputs": [], + "source": [ + "# generating random pair\n", + "def shuffleArray(length):\n", + " baseList = []\n", + " for index in range(length):\n", + " baseList.append(str(index + 1))\n", + "\n", + " random.shuffle(baseList)\n", + " return baseList" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "186298ef", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_random_dataset(dictionaryKeyLength=8,arrayListLength=8):\n", + " data={}\n", + " for index in range(dictionaryKeyLength):\n", + " data[str(index + 1)] = shuffleArray(arrayListLength)\n", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3000c880", + "metadata": {}, + "outputs": [], + "source": [ + "def g1(mydict):\n", + " \"\"\"This function appends the character 'T1G' to the keys\n", + " of the group 1 team preference list and 'T2G' to all the items\n", + " in the value.\n", + "\n", + " Parameters\n", + " ----------\n", + " mydict: A dict. The group 1 team preference list\n", + "\n", + " Returns\n", + " ----------\n", + " A modified dict.\n", + "\n", + " \"\"\"\n", + "\n", + " return {'G1T'+k: ['G2T'+i for i in v] for k, v in mydict.items()}\n", + "\n", + "\n", + "def g2(mydict):\n", + " \"\"\"This function appends the character 'T2G' to the keys\n", + " of the group2 team preference list and 'T1G' to all the items\n", + " in the value.\n", + "\n", + " Parameters\n", + " ----------\n", + " mydict: A dict. The group 2 teams preference list\n", + "\n", + " Returns\n", + " ----------\n", + " A modified dict.\n", + " \"\"\"\n", + " return {'G2T'+k: ['G1T'+i for i in v] for k, v in mydict.items()}\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "eb2e55a2", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def team1_propose(group1_team,free_teams,tmp):\n", + " \"\"\"This method will be run when we need group 1 teams propose first\n", + " to the group 2 teams according to preference list.\n", + "\n", + " \"\"\"\n", + " for group2_team in _group1_teams[group1_team]:\n", + "\n", + " # Boolean for whether a group2 team is taken or not\n", + " taken_match = [couple for couple in tmp if group2_team in couple]\n", + "\n", + " if (len(taken_match) == 0):\n", + " # Match the group1 team and the group2 team\n", + " tmp.append([group1_team, group2_team])\n", + " free_teams.remove(group1_team)\n", + " break\n", + "\n", + " elif (len(taken_match) > 0):\n", + " # Check ranking of the current group1 team and the ranking of the 'to-be' group1 team\n", + " current_guy = _group2_team[group2_team].index(taken_match[0][0])\n", + " potential_guy = _group2_team[group2_team].index(group1_team)\n", + "\n", + " if (current_guy < potential_guy):\n", + " z = taken_match[0][0]\n", + " else:\n", + " # The new team is matched\n", + " free_teams.remove(group1_team)\n", + "\n", + " # The previous team is now unmatched\n", + " free_teams.append(taken_match[0][0])\n", + "\n", + " # Update the match of the group 2 (tentatively)\n", + " taken_match[0][0] = group1_team\n", + " break\n", + " return tmp" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6a91e14f", + "metadata": {}, + "outputs": [], + "source": [ + "def stable_matching_team(free_teams,tmp):\n", + " while (len(free_teams) > 0):\n", + " for i in free_teams:\n", + " team1_propose(i,free_teams,tmp)\n", + " return tmp" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cd3e819b", + "metadata": {}, + "outputs": [], + "source": [ + "def __initTeams__(free_teams):\n", + " \"\"\"We initialise the method so we can pair every\n", + " group 1 team from the given preference list.\n", + " \"\"\"\n", + " for i in _group1_teams.keys():\n", + " free_teams.append(i)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "26c518af", + "metadata": {}, + "outputs": [], + "source": [ + "global _group1_teams, _group2_team\n", + "\n", + "def main():\n", + " free_teams=[]\n", + " __initTeams__(free_teams)\n", + " matched_pairs = stable_matching_team(free_teams,[])\n", + " matched_pairs.sort(key = lambda x: x[0][3:])\n", + " return matched_pairs" + ] + }, + { + "cell_type": "markdown", + "id": "54f67008", + "metadata": {}, + "source": [ + "### A. Find a Gale-Shapley implementation in python on Github and modify it so that the eight Super Group 1 teams will be matched against the eight Super Group 2 teams. You can make up the preference lists for each team. Make sure you cite any code you use or state that you wrote it from scratch if you did. \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4b95cf6b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===============Group 1 Team preference=============\n", + "{'G1T1': ['G2T7', 'G2T4', 'G2T1', 'G2T6', 'G2T5', 'G2T8', 'G2T2', 'G2T3'],\n", + " 'G1T2': ['G2T2', 'G2T7', 'G2T8', 'G2T4', 'G2T1', 'G2T6', 'G2T5', 'G2T3'],\n", + " 'G1T3': ['G2T3', 'G2T1', 'G2T4', 'G2T8', 'G2T2', 'G2T6', 'G2T5', 'G2T7'],\n", + " 'G1T4': ['G2T3', 'G2T4', 'G2T2', 'G2T7', 'G2T1', 'G2T8', 'G2T6', 'G2T5'],\n", + " 'G1T5': ['G2T6', 'G2T2', 'G2T7', 'G2T3', 'G2T4', 'G2T1', 'G2T5', 'G2T8'],\n", + " 'G1T6': ['G2T6', 'G2T5', 'G2T1', 'G2T7', 'G2T2', 'G2T4', 'G2T8', 'G2T3'],\n", + " 'G1T7': ['G2T3', 'G2T4', 'G2T2', 'G2T1', 'G2T5', 'G2T6', 'G2T8', 'G2T7'],\n", + " 'G1T8': ['G2T3', 'G2T1', 'G2T6', 'G2T5', 'G2T2', 'G2T4', 'G2T8', 'G2T7']}\n", + "\n", + "===============Group 2 Team preference=============\n", + "\n", + "{'G2T1': ['G1T8', 'G1T6', 'G1T7', 'G1T4', 'G1T5', 'G1T1', 'G1T2', 'G1T3'],\n", + " 'G2T2': ['G1T2', 'G1T5', 'G1T4', 'G1T8', 'G1T6', 'G1T1', 'G1T3', 'G1T7'],\n", + " 'G2T3': ['G1T6', 'G1T4', 'G1T5', 'G1T8', 'G1T7', 'G1T2', 'G1T1', 'G1T3'],\n", + " 'G2T4': ['G1T5', 'G1T7', 'G1T2', 'G1T4', 'G1T3', 'G1T8', 'G1T6', 'G1T1'],\n", + " 'G2T5': ['G1T3', 'G1T4', 'G1T2', 'G1T8', 'G1T6', 'G1T5', 'G1T1', 'G1T7'],\n", + " 'G2T6': ['G1T4', 'G1T1', 'G1T7', 'G1T3', 'G1T5', 'G1T8', 'G1T2', 'G1T6'],\n", + " 'G2T7': ['G1T4', 'G1T3', 'G1T5', 'G1T8', 'G1T2', 'G1T1', 'G1T6', 'G1T7'],\n", + " 'G2T8': ['G1T8', 'G1T7', 'G1T1', 'G1T3', 'G1T5', 'G1T6', 'G1T4', 'G1T2']}\n", + "\n", + "===============Stable Pairs=============\n", + "\n", + "[['G1T1', 'G2T7'],\n", + " ['G1T2', 'G2T2'],\n", + " ['G1T3', 'G2T8'],\n", + " ['G1T4', 'G2T3'],\n", + " ['G1T5', 'G2T6'],\n", + " ['G1T6', 'G2T5'],\n", + " ['G1T7', 'G2T4'],\n", + " ['G1T8', 'G2T1']]\n" + ] + } + ], + "source": [ + "_group1_teams = g1(generate_random_dataset(8,8))\n", + "_group2_team = g2(generate_random_dataset(8,8))\n", + "\n", + "print(\"===============Group 1 Team preference=============\")\n", + "pp.pprint(_group1_teams)\n", + "print(\"\\n===============Group 2 Team preference=============\\n\")\n", + "pp.pprint(_group2_team)\n", + "stable_pairs=main()\n", + "totalStablePairs=0\n", + "for pair in stable_pairs:\n", + " pair_one=_group1_teams[pair[0]].index(pair[1])\n", + " pair_two=_group2_team[pair[1]].index(pair[0])\n", + "print(\"\\n===============Stable Pairs=============\\n\")\n", + "pp.pprint(stable_pairs)" + ] + }, + { + "cell_type": "markdown", + "id": "861dc647", + "metadata": {}, + "source": [ + "### B.\tUse a loop to shuffle the preference lists for each team 1000 times. Calculate the percentage of stable playoff matches. See the function random.shuffle(x[, random]) https://docs.python.org/2/library/random.html \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ded45d47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total stable pair 1000/1000\n", + "Stable percentage 100.0\n", + "non stable percentage 0.0\n" + ] + } + ], + "source": [ + "totalStablePairs=0\n", + "for test_count in range(0,1000):\n", + " _group1_teams = generate_random_dataset(8,8)\n", + " _group2_team = generate_random_dataset(8,8)\n", + " _group1_teams = g1(_group1_teams)\n", + " _group2_team = g2(_group2_team)\n", + " stable_pairs=main()\n", + " if len(stable_pairs)==8: totalStablePairs+=1\n", + "\n", + "print('total stable pair '+str(totalStablePairs)+'/1000')\n", + "stable_matches_percentage=(totalStablePairs/1000)*100\n", + "no_stable_matches_percentage=100-stable_matches_percentage\n", + "print('Stable percentage '+str(stable_matches_percentage))\n", + "print('non stable percentage '+str(no_stable_matches_percentage))" + ] + }, + { + "cell_type": "markdown", + "id": "2ada7746", + "metadata": {}, + "source": [ + "### C.Randomly assume certain teams win and lose each round and eliminate the losers from the preference lists for each team. Can the Gale-Shapley matching algorithm be applied over and over in each round (16 teams, 8 teams, 4 teams, 2 teams) to create stable matches? You can answer this with code or rhetoric. \n" + ] + }, + { + "cell_type": "markdown", + "id": "9331557b", + "metadata": {}, + "source": [ + "No,The Gale-Shapley matching algorithm requires two sets of elements to create stable pairs, and if all elements in one of the sets are eliminated, the algorithm cannot be applied. This would result in an invalid scenario and the algorithm would not produce a stable match.\n", + "\n", + "Therefore, in such a scenario, it would be necessary to implement additional logic to handle such cases and ensure that the Gale-Shapley algorithm can be applied correctly in each round, even if some elements are eliminated. This might involve modifying the algorithm or using an alternative approach to handle such cases.\n", + "\n", + "\n", + "let's consider a simple example with 4 teams, labeled A, B, C, and D, and their preferences as follows:\n", + "```\n", + "A: [B, C, D]\n", + "B: [C, D, A]\n", + "C: [A, D, B]\n", + "D: [B, A, C]\n", + "```\n", + "\n", + "If we apply the Gale-Shapley algorithm to these 4 teams, we get the following stable match: (A, B), (C, D).\n", + "\n", + "However, if we eliminate team A and B from the list in the first round, we are left with only teams C and D and their preferences:\n", + "```\n", + "C: [D, B]\n", + "D: [B, A, C]\n", + "```\n", + "Since there is only one set of elements remaining, the Gale-Shapley algorithm cannot be applied and will not produce a stable match.\n", + "\n", + "This example demonstrates that the Gale-Shapley algorithm cannot be applied over and over in each round if some elements are eliminated, as the algorithm requires two sets of elements to produce a stable match." + ] + }, + { + "cell_type": "markdown", + "id": "1a088e67", + "metadata": {}, + "source": [ + "### D.\tNow combine the lists so that any team can be matched against any other irrespective of conference. Can the Gale-Shapley matching algorithm still create stable matches? (With just one list matching against itself?) You can answer this with code or rhetoric. \n", + "\n", + "\n", + "**Answer:-** No, the Gale-Shapley method cannot generate consistent matches from a single list. The algorithm is made to match items from two different lists based on how well they complement one another. Since there is only one set of preferences to consider when applying the theory to a single list, it is unclear how to identify the reciprocal preferences between components. As a result, the algorithm would not be able to produce a stable match, as it would have no way to determine if an element is better or worse matched with another element.\n", + "\n", + "Below simple example to demonstrate that the Gale-Shapley algorithm cannot create a stable match with a single list:\n", + "\n", + "Suppose we have a single list of teams T1, T2, T3, and T4, and their preferences are given as follows:\n", + "\n", + "```\n", + "T1: [T1,T2, T3, T4]\n", + "T2: [T2, T3, T4, T1]\n", + "T3: [T3, T4, T1, T2]\n", + "T4: [T4, T1, T2, T3]\n", + "```\n", + "We can see that there is no stable match that can be formed with these preferences, since each element prefers itself to any other element.\n", + "\n", + "- T1 would prefer to match with T1 instead of T2, T3, or T4\n", + "- T2 would prefer to match with T2 instead of T3, T4, or T1\n", + "- T3 would prefer to match with T3 instead of T4, T1, or T2\n", + "- T4 would prefer to match with T4 instead of T1, T2, or T3\n", + "\n", + "Since the Gale-Shapley algorithm requires mutual preferences between two different elements, it cannot form a stable match with a single list like this." + ] + }, + { + "cell_type": "markdown", + "id": "76c315b8", + "metadata": {}, + "source": [ + "### E.\tDouble the size of the lists in problem A several times (you can make up team names like team1, team2, etc.) and measure the amount of time it takes to create stable matches. How fast does the execution time grow in relation to the size of the lists?\n", + "\n", + "The time complexity of Gale-shapely algorithm is **O(n^2)**. Hence the execution time grows exponentially in relation to the size of the lists in the Gale-Shapely algorithm. Below is a code demostration which display the time taken to execute the code \n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8d5e81b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For 8 teams It took 0.0 seconds\n", + "For 808 teams It took 1.3290183544158936 seconds\n", + "For 1608 teams It took 4.629709005355835 seconds\n", + "For 2408 teams It took 11.166949033737183 seconds\n", + "For 3208 teams It took 27.599287271499634 seconds\n" + ] + } + ], + "source": [ + "import time\n", + "total_testcase=500\n", + "for test_count in range(1,total_testcase,100):\n", + " total_team=8*test_count;\n", + " _group1_teams = generate_random_dataset(total_team,total_team)\n", + " _group2_team = generate_random_dataset(total_team,total_team)\n", + " _group1_teams = g1(_group1_teams)\n", + " _group2_team = g2(_group2_team)\n", + " startTime=time.time()\n", + " stable_pairs=main()\n", + " endTime= time.time()-startTime\n", + " print(f\"For {total_team} teams It took {endTime} seconds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3643ad40", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Fei_Cao_002642021/Assignment1/Assignment1_FEICAO.ipynb b/Submissions/Fei_Cao_002642021/Assignment1/Assignment1_FEICAO.ipynb new file mode 100644 index 0000000..ed2e441 --- /dev/null +++ b/Submissions/Fei_Cao_002642021/Assignment1/Assignment1_FEICAO.ipynb @@ -0,0 +1,515 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "90cbb1b6-a675-4ee2-9fc3-8c7ec5ddd6c3", + "metadata": {}, + "source": [ + "## INFO 6205 – Program Structure and Algorithms Worked Assignment 1 Solutions " + ] + }, + { + "cell_type": "markdown", + "id": "a8839d9c-1474-4ef3-a8de-99eee298f02c", + "metadata": {}, + "source": [ + "#### Student Name: FEI CAO" + ] + }, + { + "cell_type": "markdown", + "id": "9e9ea75a-4adb-4ce8-a406-8be2959bb0ed", + "metadata": {}, + "source": [ + "#### Professor: Nik Bear Brown " + ] + }, + { + "cell_type": "raw", + "id": "af4d8842-6b7a-45a1-af55-6221e52f9ccb", + "metadata": {}, + "source": [ + "Q1 Arrange the following functions in increasing order of growth: \n", + "•\t5log(n) \n", + "•\t3n1.5\n", + "•\t3n+ 7\n", + "•\t0.2n2+ 5 \n", + "•\tnlog(n) \n", + "•\t2n \n", + "•\tlog(n2) \n", + "•\t(log(n)) 2\n", + "•\tn22n \n", + "•\ten\n", + "\n", + "\n", + "Solution:\n", + "1.\t5log(n) Θ(log(n))\n", + "2.\tlog(n2)Θ (log(n))\n", + "3.\t(log(n)) 2 Θ (log(n) 2)\n", + "4.\t3n+ 7 Θ(n) \n", + "5.\t3n1.5 Θ(n1.5) \n", + "6.\tnlog(n) Θ( nlog(n)) \n", + "7.\t0.2n2+ 5 Θ(n2) \n", + "8.\ten Θ( en) \n", + "9.\t2n Θ( 2n )\n", + "10.\tn22n Θ( n22n)" + ] + }, + { + "cell_type": "raw", + "id": "dfd80f42-c1f2-4d28-b634-0b7b72229675", + "metadata": {}, + "source": [ + "Q2 \n", + " \n", + "Assume that you have function f and g such that f(n) is O(g(n)). For each of the following statements decide whether it is true or false and give a proof or counter example. \n", + "• \tf(n) = θ (f(n/3)) • \tf(n) = O(f(n3)) • \tf(n) = O(g(n)). Implies g(logn) = Ω(f(logn)) \n", + "\n", + "\n", + "\n", + "Solution: \n", + "•\tCounter proof: 2n ≠ Θ(2n/3 ) \n", + "•\tCounter proof: f(n) = 1/n ≠ O(1/n3) \n", + "•\tf(n)=n and g(n)= n2. While f(n)=O(g(n)), g(logn) is not Ω(f(logn)) (i.e., logn2 is not Ω(logn)). Therefore, the implication does not hold.\n" + ] + }, + { + "cell_type": "raw", + "id": "f541fad0-06e4-459a-af9f-e30ece0829c3", + "metadata": {}, + "source": [ + "Q3 \n", + " \n", + "\n", + "Suppose there are p number of universities, each with a specific number of available slots for accepting graduate students for their research programs. Let's assume there are q students who have completed their undergraduate studies in the field of Computer Science. Each university has a priority list based on the student's research papers and their performance in technical interviews, while each student has a priority list of universities based on the research opportunities and scholarship packages the universities provide. We assume that there are more students than the total available slots across all p universities.\n", + "\n", + "Our goal is to develop an algorithm that assigns each student to at most one university, ensuring that all available slots in every university are filled. The assignment will be considered \"stable\" if the following situations do not occur:\n", + "\n", + " \n", + "The assignment of a student to a particular company is stable if neither of the situations arises: \n", + "1.\tThere are students u1 and u2 and a university U such that:\n", + "-\tu1 is assigned to U \n", + "-\tu2 is not assigned to any university \n", + "-\tU prefers u2 to u1 based on their research papers and interviews. \n", + " \n", + "2.\tThere are students u1 and u2 and universities U1 and U2 such that:\n", + "-\tu1 is assigned to U1, \n", + "-\tu2 is assigned to U2,\n", + "-\tU1 prefers u2 to u1\n", + "-\tu2 prefers U1 to U2\n", + "\n", + "Constraints:\n", + "(a) Universities generally have more than one slot for accepting students.\n", + "(b) There is an oversupply of Computer Science students.\n", + "\n", + "Questions:\n", + "Shows that there is always a stable assignment of students to universities.\n", + "Devise an algorithm to find such an assignment.\n", + " \n", + "Solution: \n", + "The algorithm is an extension of the Gale-Shapley algorithm:\n", + "While some university U1 has available slots:\n", + " U1 offers a slot to the next student s1 based on their research papers and interviews\n", + " if s1 is free then:\n", + " s1 accepts the offer\n", + " else (s1 is already committed to some university, say U(k)):\n", + " if s1 prefers U(k) to U1 then:\n", + " s1 remains committed to U(k)\n", + " else:\n", + " s1 becomes committed to U1\n", + " The number of available slots at U(k) increases by one\n", + " The number of available slots at U1 decreases by one \n", + "\n", + "This algorithm will terminate in O(pq) steps, as each university offers a slot to a student at most once, and in each iteration, some university offers a slot to some student.\n", + "Justification:\n", + "The algorithm guarantees stability as no student or university could be better off by deviating from their assigned pair.\n", + "The time complexity is O(pq) as each university has to go through its list of students at most once, and each student has to go through their list of universities at most once.\n" + ] + }, + { + "cell_type": "raw", + "id": "b3c0c2c9-0228-49c6-b5df-d3ee6ac8a3f6", + "metadata": {}, + "source": [ + "Q4 \n", + " \n", + "One algorithm requires 8log2 n microseconds, and another algorithm requires n1/3microseconds. Which algorithm is asymptotically faster? What is the cross-over value of n?\n", + " \n", + "Solution: \n", + "When n tends to infinity, algorithms with lower growth order are faster. In this case, the\n", + "O(logn) is less than the O(n1/3), so the first algorithm is asymptotically faster.\n", + "\n", + "The first algorithm is asymptotically faster than the second. \n", + "The order of growth of 8log2 n is less than the order of growth of n1/3. " + ] + }, + { + "cell_type": "raw", + "id": "8ec3ccbc-230a-4b91-8b0e-22b616256b71", + "metadata": {}, + "source": [ + "Q5 \n", + " \n", + "\n", + "Imagine a pyramid built using a grid of rectangular bricks. The total number of bricks used to build each level of the pyramid is the summation of the number of bricks used to build the current level and the two previous levels. Note that we are in the process of building the pyramid with bricks. There is an asymptotic property to be analyzed here. Suppose for clarity that each level has a total number of bricks bounded by a constant d, and the pyramid will consist of at most m bricks. Demonstrate how to construct such a pyramid using bricks of length g(m) for a function g(m) that grows as slowly as possible.\n", + "\n", + "\n", + "\n", + "Solution: \n", + " \n", + "Suppose that to obtain m bricks, we need L levels. The script is as follows:\n", + " \n", + "Row 1= \n", + "Row 2= \n", + "… \n", + "Row R = east_list.index(west_team):\n", + " engaged[east_team] = west_team\n", + " if western_prefers2[fiance]:\n", + " west_free.append(fiance)\n", + " else:\n", + " if west_list:\n", + " west_free.append(west_team)\n", + " \n", + " return engaged\n", + "\n", + "print('\\nEngagements:')\n", + "engaged = matchmaker()\n", + "\n", + "print('\\nMatchings:')\n", + "print(' ' + ',\\n '.join('%s is matched with %s' % match\n", + " for match in sorted(engaged.items())))\n", + "print()\n", + "print('Matching stability check PASSED'\n", + " if check(engaged) else 'Matching stability check FAILED')\n" + ] + }, + { + "cell_type": "raw", + "id": "f2c06aa4-453d-438e-b87e-53a33f3bcec6", + "metadata": {}, + "source": [ + "B.\tUse a loop to shuffle the preference lists for each team 1000 times. Calculate the percentage of stable playoff matches. See the function random.shuffle(x[, random]) " + ] + }, + { + "cell_type": "raw", + "id": "cc7b7781-57ce-433d-9604-050bf704c5dc", + "metadata": {}, + "source": [ + "import random\n", + "\n", + "stable_matches = 0\n", + "\n", + "for _ in range(1000):\n", + " for team in eastern_teams:\n", + " random.shuffle(western_teams)\n", + " eastern_prefers[team] = western_teams[:]\n", + " for team in western_teams:\n", + " random.shuffle(eastern_teams)\n", + " western_prefers[team] = eastern_teams[:]\n", + " \n", + " engaged = matchmaker()\n", + "\n", + " if check(engaged):\n", + " stable_matches += 1\n", + "\n", + "print(\"Percentage of stable matches:\", (stable_matches / 1000) * 100)" + ] + }, + { + "cell_type": "raw", + "id": "fa4fcd8e-7473-4b1a-9f75-a3a5d91e5a6c", + "metadata": {}, + "source": [ + "C.\tRandomly assume certain teams win and lose each round and eliminate the losers from the preference lists for each team. Can the Gale-Shapley matching algorithm be applied over and over in each round (16 teams, 8 teams, 4 teams, 2 teams) to create stable matches? " + ] + }, + { + "cell_type": "raw", + "id": "0ca9dd76-2d06-4837-8b3e-775e47c39b6f", + "metadata": {}, + "source": [ + "The Gale-Shapley matching algorithm can be applied repeatedly during the rounds when some teams are eliminated:\n", + "First Round (16 teams): Randomly determine winners, eliminate 8 losing teams, and then apply the Gale-Shapley algorithm to the remaining 8 teams.\n", + "Quarterfinals (8 teams): Randomize the winners, eliminate the 4 losing teams, and then apply the Gale-Shapley algorithm to the remaining 4 teams.\n", + "Semi-Finals (4 teams): Randomize the winners, eliminate the 2 losing teams, and then apply the Gale-Shapley algorithm to the final 2 teams.\n", + "Final (2 teams): Only 2 teams remain, which is an inherently stable match." + ] + }, + { + "cell_type": "raw", + "id": "5c618195-0404-46ec-8ebb-2db90584bb57", + "metadata": {}, + "source": [ + "D.\tNow combine the lists so that any team can be matched against any other irrespective of conference. Can the Gale-Shapley matching algorithm still create stable matches? (With just one list matching against itself?) " + ] + }, + { + "cell_type": "raw", + "id": "a157d9fa-d26c-4dff-9211-acec9669bd6d", + "metadata": {}, + "source": [ + "In the context of combining the team lists irrespective of conference, directly applying the standard Gale-Shapley algorithm becomes problematic. This situation mirrors the \"stable roommate problem,\" which involves matching members within a single group based on their preferences, as opposed to matching between two distinct groups. While modifications like the stable roommate algorithm could potentially yield stable matches, it doesn't provide the same guarantee as the Gale-Shapley algorithm for the stable marriage problem.\n", + "\n", + "To illustrate the challenge: Consider a hypothetical scenario with four individuals: A, B, C, and D. Their preferences are as follows:\n", + "\n", + "A prefers: B, C, D\n", + "B prefers: C, A, D\n", + "C prefers: A, B, D\n", + "D prefers: A, B, C\n", + "\n", + "With such preferences, finding a stable match becomes elusive, showcasing the complexities that arise when applying the Gale-Shapley algorithm to a single set of participants." + ] + }, + { + "cell_type": "raw", + "id": "f81f09d8-3c1b-4332-97d6-73829b5887ce", + "metadata": {}, + "source": [ + "E. Double the size of the lists in problem A several times (you can make up team names like team1, team2, etc.) and measure the amount of time it takes to create stable matches. How fast does the execution time grow in relation to the size of the lists? " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1e3a3496-9d12-444f-bfa0-5f96f37f33a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sizes: [8, 16, 32, 64, 128]\n", + "Times: [0.00012421607971191406, 0.0002570152282714844, 0.0009462833404541016, 0.004001140594482422, 0.014821052551269531]\n" + ] + } + ], + "source": [ + "import time\n", + "import random\n", + "\n", + "def gale_shapley(n):\n", + " men = [\"man\" + str(i) for i in range(n)]\n", + " women = [\"woman\" + str(i) for i in range(n)]\n", + " men_prefers = {man: women.copy() for man in men}\n", + " women_prefers = {woman: men.copy() for woman in women}\n", + "\n", + " for man in men:\n", + " random.shuffle(men_prefers[man])\n", + " for woman in women:\n", + " random.shuffle(women_prefers[woman])\n", + "\n", + " free_men = men.copy()\n", + " engaged = {}\n", + "\n", + " while free_men:\n", + " man = free_men.pop(0)\n", + " man_list = men_prefers[man]\n", + "\n", + " for woman in man_list:\n", + " fiancé = [m for m, w in engaged.items() if w == woman]\n", + " if not fiancé:\n", + " engaged[man] = woman\n", + " break\n", + " else:\n", + " fiancé = fiancé[0]\n", + " if women_prefers[woman].index(man) < women_prefers[woman].index(fiancé):\n", + " free_men.append(fiancé)\n", + " engaged[man] = woman\n", + " break\n", + "\n", + " return engaged\n", + "\n", + "sizes = [8, 16, 32, 64, 128] # 你可以继续增大这些数值\n", + "times = []\n", + "\n", + "for n in sizes:\n", + " start_time = time.time()\n", + " gale_shapley(n)\n", + " end_time = time.time()\n", + " elapsed_time = end_time - start_time\n", + " times.append(elapsed_time)\n", + "\n", + "print(\"Sizes:\", sizes)\n", + "print(\"Times:\", times)\n" + ] + }, + { + "cell_type": "raw", + "id": "efae9cc3-bfc0-4945-95fb-1ed32ec3eadb", + "metadata": {}, + "source": [ + "Based on these execution times, we can observe how the execution time grows as the size of the list doubles. As previously analyzed, it's evident that the time grows roughly by a factor of four, which aligns with the O(n2) complexity." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Fei_Cao_002642021/Assignment2/FEICAOAssignment 2.ipynb b/Submissions/Fei_Cao_002642021/Assignment2/FEICAOAssignment 2.ipynb new file mode 100644 index 0000000..4ee240d --- /dev/null +++ b/Submissions/Fei_Cao_002642021/Assignment2/FEICAOAssignment 2.ipynb @@ -0,0 +1,627 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6c3fd155-49e7-4318-b263-f6bc2c7dd021", + "metadata": {}, + "source": [ + "## INFO 6205 – Program Structures and Algorithms\n", + "### Worked Assignment 2 Solutions\n", + "#### Student Name: FEICAO\n", + "\n", + "#### Professor: Nik Bear Brown" + ] + }, + { + "cell_type": "markdown", + "id": "bf671741-9404-45d0-81cf-534ed595b258", + "metadata": {}, + "source": [ + "## Q1 (15 Points)\n", + "\n", + "One approach to detect if a directed graph G=(V, E) has a cycle is to repeatedly find a vertex of out-degree 0, mark it, and remove it and all of its incoming edges from the graph. Explain how to implement this idea so that it runs in time O(V+ E). How does this algorithm behave if G is acyclic?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "434fdf07-2d48-43bf-a75a-8d0c2facfefe", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "To implement this idea, we proceed as follows:\n", + "\n", + "Create an array R of size |V| and initialize its entries to zero, and create an initially empty queue Q.\n", + "Let Adj denote the adjacency-list representation of G.\n", + "We scan through all the edges in Adj, incrementing R[v] each time we see a vertex v. In a directed graph, if there's no cycle, there must be at least one vertex of out-degree 0, so we know that there is at least one entry of R that is zero.\n", + "We scan through R a second time and for every vertex v such that R[v] = 0, we enqueue v in Q.\n", + "Dequeue Q and mark v.\n", + "When we mark a vertex, we do as follows: for each vertex u in Adj[v] we decrement R[u] by one.\n", + "If any of these R[u] = 0, then enqueue u in Q.\n", + "To prove our algorithm is correct: At each step, if there's no cycle, there must be at least one vertex with out-degree 0, so the queue is never empty, and every vertex will be enqueued and dequeued once, so we will mark all the vertices.\n", + "\n", + "For a vertex u with out-degree k ≥ 1, there are k vertices v1, v2, ... vk which will appear after u in the traversal of G. Then R[u] = k, since u ∈ Adj[vi] for i = 1, ... , k vertices of G, and u will only be enqueued after all vi have already been dequeued (each dequeue decrements R[u] by one).\n", + "\n", + "The running time is Θ(V) to initialize R, O(1) to initialize Q, and Θ(E) to scan the edges of E and count out-degrees. The second scan of R is Θ(V). Every vertex will be enqueued and dequeued from the queue exactly once. The |E| edges are removed from the graph once (which corresponds to decrementing entries of R Θ(E) times). This gives a total running time of Θ(V) + O(1) + Θ(E) + Θ(V) + Θ(E) = Θ(V + E).\n", + "\n", + "If the graph is acyclic, then our algorithm will mark all vertices, and the queue will be empty at the end, indicating that the graph doesn't have any cycles.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "7c657209-e417-4da8-81b1-ec0067b760fd", + "metadata": {}, + "source": [ + "## Q2 (15 Points)\n", + "Use Prim's algorithm to find the shortest path in a directed graph of your choice. Show your steps." + ] + }, + { + "cell_type": "markdown", + "id": "d027f6a6-008e-414e-ba80-cdcd4069a29d", + "metadata": {}, + "source": [ + "## Solution:\n", + "Go to https://www.cs.usfca.edu/~galles/visualization/Prim.html\n", + "\n", + "The site will generate numerous examples, an adjacency list, an adjacency matrix, and an animated solution to help you understand the algorithm's workings." + ] + }, + { + "cell_type": "markdown", + "id": "662eb589-8411-4e15-8597-5e1b8d8d155b", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "raw", + "id": "2d203108-62ff-4e7d-bb5f-b4166ae9a199", + "metadata": {}, + "source": [ + "1. Starting from the vertices, select the edge with the lowest weight first\n", + "2. Then select the edge with the lowest selected weight\n", + "3. Until all vertices are linked" + ] + }, + { + "cell_type": "markdown", + "id": "6052fe34-8c04-43d8-847d-a5be26573771", + "metadata": {}, + "source": [ + "Steps of Execution:\n", + "Step 1: Start from vertex 0.\n", + "Step 2: The edge 0-2 has the smallest weight (2) among edges going out from 0. Add edge 0-2 to the MST and mark vertex 2 as visited.\n", + "Step 3: Among the edges going out from the visited vertices (0 and 2), 0-3 has the smallest weight (1). Add edge 0-3 to the MST and mark vertex 3 as visited.\n", + "Step 4: The edge 2-6 has the smallest weight (5) among the edges going out from the visited vertices (0, 2, and 3). Add edge 2-6 to the MST and mark vertex 6 as visited.\n", + "Step 5: The edge 6-5 has the smallest weight (3) from the visited vertices (0, 2, 3, and 6). Add edge 6-5 to the MST and mark vertex 5 as visited.\n", + "Step 6: The edge 1-3 has a weight of 6 which is the smallest among the edges connecting the visited vertices to vertex 1. Add edge 1-3 to the MST and mark vertex 1 as visited.\n", + "Step 7: The edge 6-4 has the smallest weight (7) connecting the visited vertices to vertex 4. Add edge 6-4 to the MST and mark vertex 4 as visited.\n", + "Step 8: Finally, the edge 4-7 has the smallest weight (5) connecting the visited vertices to vertex 7. Add edge 4-7 to the MST and mark vertex 7 as visited." + ] + }, + { + "cell_type": "markdown", + "id": "530d89fa-273c-4aaf-8888-96c76b47812c", + "metadata": {}, + "source": [ + "The Minimum Spanning Tree (MST) formed by Prim's Algorithm consists of the edges: 0-2, 0-3, 2-6, 6-5, 1-3, 6-4, and 4-7." + ] + }, + { + "cell_type": "markdown", + "id": "88425aa5-d7eb-4440-854c-625a3f633dac", + "metadata": {}, + "source": [ + "## Q3 (15 Points)\n", + "logistics company manages the transportation of goods through a series of routes. Each route connects two cities and has a transportation cost associated with it. Some cities act as hubs, where goods can be transferred to other routes. Each city has a storage cost for goods waiting to be transferred. Additionally, each route has a maximum capacity of goods it can transport per day. Every day, the company wants to determine the most cost-effective route to transport a certain good from a source city to a destination city, considering both transportation and storage costs. Develop an algorithm that will efficiently determine the most cost-effective route for the day. Explain why your algorithm is efficient." + ] + }, + { + "cell_type": "markdown", + "id": "e246e402-6cb6-40c1-9048-6c47efdf9825", + "metadata": {}, + "source": [ + "## Solution:\n", + "This can be modeled as a graph problem. Construct a weighted directed graph where each city is represented as a node. Each route between two cities is represented as an edge, with the weight being the transportation cost. For cities acting as hubs, consider the storage cost as an additional weight on the node.\n", + "\n", + "To find the most cost-effective route for transporting goods from a source city to a destination city, use Dijkstra's shortest path algorithm. This algorithm will give the shortest (least cost) path from the source to every other city, including the destination. The time complexity of Dijkstra's algorithm using a priority queue is O((V+E)log(V)).\n", + "\n", + "After determining the shortest path, the total cost for the route is the sum of the edge weights (transportation costs) and any node weights (storage costs) encountered along the path. Since the number of cities and routes are given as input, and the algorithm efficiently computes the shortest path, the overall complexity remains O((V+E)log(V))." + ] + }, + { + "cell_type": "markdown", + "id": "6137eb0a-5458-42cf-9e17-6a980a0de7d7", + "metadata": {}, + "source": [ + "## Q4 (15 Points)\n", + "Determine the maximum flow from source node X to sink node Y using Dijkstra's algorithm algorithm in a flow network of your choice. Detail your steps." + ] + }, + { + "cell_type": "markdown", + "id": "9076caea-e05f-4a05-9251-d4dcda2c8568", + "metadata": {}, + "source": [ + "## Solution:\n", + "Solution:\n", + "Visit https://www.cs.usfca.edu/~galles/visualization/Dijkstra.html\n", + "\n", + "The site will generate numerous examples, an adjacency list, an adjacency matrix, and an animated solution to help you understand the algorithm's workings." + ] + }, + { + "cell_type": "markdown", + "id": "087269de-075d-4010-b259-e4b9e5b2f2a7", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "ff5e02f0-3258-47a2-9855-15faf6793ecc", + "metadata": {}, + "source": [ + "### Initialization:\n", + "Set the initial vertex's (vertex 0) shortest-path estimate to 0 and all other vertices' shortest-path estimates to infinity.\n", + "Set the source vertex (vertex 0) as the current vertex.\n", + "Mark all vertices as unvisited.\n", + "### Iterate until all vertices are visited:" + ] + }, + { + "cell_type": "raw", + "id": "2deb4255-b72a-4b35-9cca-0c8c754fa45f", + "metadata": {}, + "source": [ + "For the current vertex, consider all of its unvisited neighbors and calculate their tentative distances. If the newly calculated tentative distance is less than the current assigned value, update the shortest path for that neighbor.\n", + "For vertex 0, its only neighbor is vertex 3 with a weight of 8.\n", + "Mark the current vertex as visited.\n", + "Select the unvisited vertex with the smallest tentative distance, set it as the new current vertex, and return to the previous step." + ] + }, + { + "cell_type": "markdown", + "id": "3b17e31b-a631-4b84-a2c2-61178bc5aa3d", + "metadata": {}, + "source": [ + "### Iterative Process:" + ] + }, + { + "cell_type": "raw", + "id": "3eb5f80a-88ea-4fa8-aadd-bba73bac1718", + "metadata": {}, + "source": [ + "Starting with Vertex 0:\n", + "Distance to Vertex 3 = 8\n", + "Visit Vertex 1 (since it has the smallest edge 1 to vertex 6):\n", + "Distance to Vertex 2 = 3\n", + "Distance to Vertex 3 = 8 (No change)\n", + "Distance to Vertex 6 = 1\n", + "Visit Vertex 6 (since it has the smallest distance of 1 via vertex 1):\n", + "Distance to Vertex 1 = 1 (No change)\n", + "Distance to Vertex 2 = 8\n", + "Distance to Vertex 3 = 8 (No change)\n", + "Distance to Vertex 4 = 4 (0 -> 1 -> 6 -> 4 = 1 + 4 = 5)\n", + "Distance to Vertex 5 = 3 (0 -> 1 -> 6 -> 5 = 1 + 3 = 4)\n", + "Visit Vertex 2 (since it has the second smallest distance of 3 via vertex 1):\n", + "All distances remain unchanged because other paths through Vertex 2 are not shorter.\n", + "Visit Vertex 5:\n", + "All distances remain unchanged because other paths through Vertex 5 are not shorter.\n", + "Visit Vertex 4:\n", + "All distances remain unchanged.\n", + "Visit Vertex 3:\n", + "All distances remain unchanged.\n", + "Visit Vertex 7:\n", + "Distance to Vertex 5 = 4 (0 -> 1 -> 6 -> 5 -> 7 = 1 + 3 + 4 = 8)\n", + "Final Shortest Path Estimates from Vertex 0:\n", + "Vertex 1 = 1 (via Vertex 6)\n", + "Vertex 2 = 3 (directly from Vertex 1)\n", + "Vertex 3 = 8 (directly from Vertex 0)\n", + "Vertex 4 = 5 (via Vertex 6)\n", + "Vertex 5 = 4 (via Vertex 6)\n", + "Vertex 6 = 1 (directly from Vertex 1)\n", + "Vertex 7 = 8 (via Vertex 5)" + ] + }, + { + "cell_type": "markdown", + "id": "3a9519ea-9c3d-41d2-80c2-bc670ad6385e", + "metadata": {}, + "source": [ + "## Q5 \n", + "Determine if a given directed graph is strongly connected. If it is, find the strongly connected components. Show your work.\n", + "\n", + "Express the directed graph above as:\n", + "A. An adjacency list (2.5 points)\n", + "B. An adjacency matrix (2.5 points)\n", + "Is the directed graph strongly connected? If so, identify the strongly connected components of the graph. (10 points)" + ] + }, + { + "cell_type": "markdown", + "id": "806d4c16-f590-477f-beca-7aad7e2129f1", + "metadata": {}, + "source": [ + "## Solution:\n", + "Go to https://www.cs.usfca.edu/~galles/visualization/TopoSortIndegree.html and \r\n", + "https://www.cs.usfca.edu/~galles/visualization/TopoSortDFS.html\r\n", + "The site will generate hundreds of examples, an adjacency list, an adjacency matrix and an animated \r\n", + "solution." + ] + }, + { + "cell_type": "markdown", + "id": "986907a4-0028-4fe4-9411-02b44bc146c1", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e84501c8-76a1-4f20-86d9-50c6a5dccc3c", + "metadata": {}, + "source": [ + "### A. Adjacency List:\n", + "An adjacency list represents the graph as a map from nodes to lists of neighboring vertices. Here's how the adjacency list would look for the given graph:" + ] + }, + { + "cell_type": "raw", + "id": "a9fcf253-0054-4fba-90de-209b19eba149", + "metadata": {}, + "source": [ + "0 -> [3, 2]\n", + "1 -> [5]\n", + "2 -> [4, 6]\n", + "3 -> [7, 5]\n", + "4 -> [6, 7]\n", + "5 -> [6]\n", + "6 -> [7]\n", + "7 -> []" + ] + }, + { + "cell_type": "markdown", + "id": "a77a38ac-1fa5-44e4-8ba2-bba0cb102567", + "metadata": {}, + "source": [ + "### B. Adjacency Matrix:\n", + "An adjacency matrix is a square matrix used to represent a finite graph. The elements of the matrix indicate whether pairs of vertices are adjacent or not in the graph.\n", + "\n", + "For the given graph, if we label the vertices from 0 to 7, the adjacency matrix would look like this (with 1s indicating a connection between nodes and 0s indicating no connection):" + ] + }, + { + "cell_type": "markdown", + "id": "d07cde46-0588-4932-8b1a-41579d657c25", + "metadata": {}, + "source": [ + " 0 1 2 3 4 5 6 7\n", + "0 [0 0 1 1 0 0 0 0]\n", + "1 [0 0 0 0 0 1 0 0]\n", + "2 [0 0 0 0 1 0 1 0]\n", + "3 [0 0 0 0 0 1 0 1]\n", + "4 [0 0 0 0 0 0 1 1]\n", + "5 [0 0 0 0 0 0 1 0]\n", + "6 [0 0 0 0 0 0 0 1]\n", + "7 [0 0 0 0 0 0 0 0]\n" + ] + }, + { + "cell_type": "markdown", + "id": "81de29c3-79f1-4cf9-8fa1-833099586ac8", + "metadata": {}, + "source": [ + "### Topological Sort:\n", + "A directed graph can be topologically sorted if it does not contain a directed cycle. In this graph, no cycles are evident, so it can be topologically sorted.\n", + "\n", + "To topologically sort the graph, one approach is to iteratively find vertices of in-degree 0, output them, and then remove them and their edges.\n", + "\n", + "A possible topological sort order for this graph is:" + ] + }, + { + "cell_type": "raw", + "id": "cb00fbc1-20e9-4f78-94d4-69530be84540", + "metadata": {}, + "source": [ + "0, 1, 2, 3, 4, 5, 6, 7" + ] + }, + { + "cell_type": "markdown", + "id": "7b3a0941-d622-476d-b5f6-d7f1598922b8", + "metadata": {}, + "source": [ + "## Q6\n", + "Find shortest path from node A to node B using Breadth-First Search in a graph of your choice. Show \r\n", + "your steps." + ] + }, + { + "cell_type": "markdown", + "id": "9a913851-1e46-4f0a-890e-cc45fffba9d2", + "metadata": {}, + "source": [ + "## Solution:\n", + "Go to https://www.cs.usfca.edu/~galles/visualization/BFS.html\r\n", + "The site will generate hundreds of examples, an adjacency list, an adjacency matrix and an animated \r\n", + "solution." + ] + }, + { + "cell_type": "markdown", + "id": "97bf57f7-3842-4ca0-bfd4-96bef68bbf7d", + "metadata": {}, + "source": [ + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "46fd5820-aa0a-4400-a60a-a33e1b965fa8", + "metadata": {}, + "source": [ + "### Initialization:" + ] + }, + { + "cell_type": "raw", + "id": "beedf265-e488-4953-80e1-486cc7ca428f", + "metadata": {}, + "source": [ + "Start from vertex 0.\n", + "Create an empty queue and push the source vertex (0) into it.\n", + "Mark vertex 0 as visited.\n", + "Create an empty list for the path and add vertex 0 to it." + ] + }, + { + "cell_type": "raw", + "id": "1b30608d-e4e7-4514-8a4e-628d2eaf21cf", + "metadata": {}, + "source": [ + "Step 1: Dequeue vertex 0 from the queue.\n", + "Visit its unvisited neighbors: 1, 2, 3.\n", + "Mark them as visited.\n", + "Enqueue vertices 1, 2, 3.\n", + "Remember the parent of 1, 2, 3 as 0 (for backtracking).\n", + "Step 2: Dequeue vertex 1 from the queue.\n", + "Visit its unvisited neighbors: (only 5 since 1's connection to 0 is the backward direction in BFS).\n", + "Mark vertex 5 as visited.\n", + "Enqueue vertex 5.\n", + "Remember the parent of 5 as 1.\n", + "Step 3: Dequeue vertex 2 from the queue. (Note: 2 does not lead us to 4, but it's part of BFS traversal.)\n", + "Its neighbors are already visited, so we continue.\n", + "Step 4: Dequeue vertex 3 from the queue.\n", + "Visit its unvisited neighbor: 7.\n", + "Mark vertex 7 as visited.\n", + "Enqueue vertex 7.\n", + "Remember the parent of 7 as 3.\n", + "Step 5: Dequeue vertex 5 from the queue.\n", + "Visit its unvisited neighbor: 6.\n", + "Mark vertex 6 as visited.\n", + "Enqueue vertex 6.\n", + "Remember the parent of 6 as 5.\n", + "Step 6: Dequeue vertex 7 from the queue. (Note: 7 does not lead us to 4, but it's part of BFS traversal.)\n", + "Its neighbors are already visited, so we continue.\n", + "Step 7: Dequeue vertex 6 from the queue.\n", + "Visit its unvisited neighbor: 4.\n", + "Mark vertex 4 as visited.\n", + "Remember the parent of 4 as 6.\n", + "Since we've now reached vertex 4 (our destination), we stop our BFS." + ] + }, + { + "cell_type": "markdown", + "id": "630520a4-55da-4091-9133-675025c53d79", + "metadata": {}, + "source": [ + "### Backtracking for the path:" + ] + }, + { + "cell_type": "raw", + "id": "3833d84c-fb48-4fd8-995c-2a967aab0019", + "metadata": {}, + "source": [ + "Starting from vertex 4:\n", + "4 (from 6)\n", + "6 (from 5)\n", + "5 (from 1)\n", + "1 (from 0)\n", + "0\n", + "So, the shortest path from vertex 0 to vertex 4 using BFS is: 0 -> 1 -> 5 -> 6 -> 4." + ] + }, + { + "cell_type": "markdown", + "id": "3885b64e-48e1-457a-8adb-0acda5711a91", + "metadata": {}, + "source": [ + "## Q7\n", + "Use Kruskal's algorithm to find a minimum spanning tree in a graph of your choice. Show your steps" + ] + }, + { + "cell_type": "markdown", + "id": "caeb7026-3f1c-41bc-a421-fe5e3d18b660", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "markdown", + "id": "43d56b5c-1794-47cb-9a5b-65c708295658", + "metadata": {}, + "source": [ + "Go to https://www.cs.usfca.edu/~galles/visualization/Kruskal.html\n", + "The site will generate hundreds of examples, an adjacency list, an adjacency matrix and an animated \n", + "solution." + ] + }, + { + "cell_type": "markdown", + "id": "a87ca71c-db3c-4d00-8534-d663ae9004b5", + "metadata": {}, + "source": [ + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "37d1c422-ee6c-4ffd-a9d8-a3458fd2778b", + "metadata": {}, + "source": [ + "### Kruskal's Algorithm:\n" + ] + }, + { + "cell_type": "raw", + "id": "efc5d08d-dbf0-4e81-8233-ef059c45bdc3", + "metadata": {}, + "source": [ + "Sort all the edges in ascending order of their weight.\n", + "Start adding edges to the MST from the smallest weight edge, ensuring that no cycle is formed. Keep adding edges until you have (Vertices-1) edges in your MST." + ] + }, + { + "cell_type": "markdown", + "id": "72f17f4a-9ec1-46cc-8264-3e5e55b58409", + "metadata": {}, + "source": [ + "### Sorted Edges by Weight:" + ] + }, + { + "cell_type": "raw", + "id": "e6c4d7ab-fc13-4052-85c4-2819fa4dddbd", + "metadata": {}, + "source": [ + "5-7: 2\n", + "2-6: 3\n", + "0-3: 5\n", + "5-6: 5\n", + "4-6: 6\n", + "0-1: 6\n", + "1-5: 9\n", + "6-7: 8\n", + "2-5: 7" + ] + }, + { + "cell_type": "markdown", + "id": "05690d1a-17bf-4353-98ab-988fde39b6f9", + "metadata": {}, + "source": [ + "### Kruskal's Steps:" + ] + }, + { + "cell_type": "raw", + "id": "9d6351b0-28db-4c98-9d89-3a9346d44a93", + "metadata": {}, + "source": [ + "Add edge 5-7 (Weight: 2).\n", + "Add edge 2-6 (Weight: 3).\n", + "Add edge 0-3 (Weight: 5).\n", + "Add edge 5-6 (Weight: 5).\n", + "Add edge 4-6 (Weight: 6).\n", + "Add edge 0-1 (Weight: 6).\n", + "(Till this step we have covered all the vertices so we can stop here, but let's just see the remaining edges to ensure we're getting the minimum spanning tree.)\n", + "Skip edge 1-5 (Weight: 9) because adding this will form a cycle.\n", + "Skip edge 6-7 (Weight: 8) because adding this will form a cycle.\n", + "Skip edge 2-5 (Weight: 7) because adding this will form a cycle.\n", + "Minimum Spanning Tree edges are:\n", + "\n", + "5-7: 2\n", + "2-6: 3\n", + "0-3: 5\n", + "5-6: 5\n", + "4-6: 6\n", + "0-1: 6\n", + "Total weight of the Minimum Spanning Tree = 2 + 3 + 5 + 5 + 6 + 6 = 27." + ] + }, + { + "cell_type": "markdown", + "id": "0a8c7248-dfbd-43c8-839b-7f3e2a7d9294", + "metadata": {}, + "source": [ + "## Q8\n", + "Find whether node A is reachable from node B using Depth-First Search in a graph of your choice. Show \r\n", + "your steps." + ] + }, + { + "cell_type": "markdown", + "id": "03c0b7fd-1cef-459c-bf83-0d568561faea", + "metadata": {}, + "source": [ + "### Solution:\n", + "Go to https://www.cs.usfca.edu/~galles/visualization/DFS.html\n", + "The site will generate hundreds of examples, an adjacency list, an adjacency matrix and an animated \n", + "solution." + ] + }, + { + "cell_type": "markdown", + "id": "006996b3-ceb2-4b7c-b8b9-f571a76c7382", + "metadata": {}, + "source": [ + "\n", + "\n" + ] + }, + { + "cell_type": "raw", + "id": "bb7a7bd4-4ed0-4548-81af-61df0f8e66c5", + "metadata": {}, + "source": [ + "Let's use depth-first search (DFS) to determine if node A is reachable from node B. For ease of explanation, let us assume that node A is vertex 0 and node B is vertex 7 in the given graph.\n", + "\n", + "Start at vertex B (vertex 7):\n", + "\n", + "Vertex 7 (node B): the neighboring node is vertex 6. mark vertex 7 as visited.\n", + "Vertex 6: neighboring nodes are vertex 4, vertex 2, and vertex 7. we have already visited vertex 7, so we move to vertex 4. mark vertex 6 as visited.\n", + "Vertex 4: The neighboring node is vertex 6. Since vertex 6 has already been visited, we backtrack to vertex 6 and move to the next neighboring node, vertex 2.\n", + "Vertex 2: The neighboring node is vertex 0. This is our target node A. Mark vertex 2 as visited.\n", + "Vertex 0 (node A): We have reached our target node. Therefore, node A can be reached from node B.\n", + "Thus, with depth-first search, we determine that node A (vertex 0) can be reached from node B (vertex 7)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.10.19.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.10.19.png" new file mode 100644 index 0000000..ae6d1fc Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.10.19.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.10.19_\345\211\257\346\234\254.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.10.19_\345\211\257\346\234\254.png" new file mode 100644 index 0000000..ae6d1fc Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.10.19_\345\211\257\346\234\254.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.33.05.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.33.05.png" new file mode 100644 index 0000000..4a50090 Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.33.05.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.47.05.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.47.05.png" new file mode 100644 index 0000000..51a86e0 Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2106.47.05.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.12.31.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.12.31.png" new file mode 100644 index 0000000..89c6b9a Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.12.31.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.25.48.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.25.48.png" new file mode 100644 index 0000000..f8fb471 Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.25.48.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.25.58.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.25.58.png" new file mode 100644 index 0000000..f8fb471 Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.25.58.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.41.23.png" "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.41.23.png" new file mode 100644 index 0000000..12f3284 Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment2/\346\210\252\345\261\2172023-10-05 \344\270\213\345\215\2107.41.23.png" differ diff --git a/Submissions/Fei_Cao_002642021/Assignment3/FEICAO_Assignment3.ipynb b/Submissions/Fei_Cao_002642021/Assignment3/FEICAO_Assignment3.ipynb new file mode 100644 index 0000000..0fa6cd2 --- /dev/null +++ b/Submissions/Fei_Cao_002642021/Assignment3/FEICAO_Assignment3.ipynb @@ -0,0 +1,537 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6c3fd155-49e7-4318-b263-f6bc2c7dd021", + "metadata": {}, + "source": [ + "# INFO 6205 – Program Structures and Algorithms\n", + "## Worked Assignment 3 Solutions\n", + "#### Student Name: FEICAO\n", + "\n", + "#### Professor: Nik Bear Brown" + ] + }, + { + "cell_type": "markdown", + "id": "1c5fbf55", + "metadata": {}, + "source": [ + "## Q1 (15 Points)" + ] + }, + { + "cell_type": "raw", + "id": "8ad3a207", + "metadata": {}, + "source": [ + "Let's use depth-first search (DFS) to determine if node A is reachable from node B. For ease of explanation, let us assume that node A is vertex 0 and node B is vertex 7 in the given graph.\n", + "\n", + "Start at vertex B (vertex 7):\n", + "\n", + "Vertex 7 (node B): the neighboring node is vertex 6. mark vertex 7 as visited.\n", + "Vertex 6: neighboring nodes are vertex 4, vertex 2, and vertex 7. we have already visited vertex 7, so we move to vertex 4. mark vertex 6 as visited.\n", + "Vertex 4: The neighboring node is vertex 6. Since vertex 6 has already been visited, we backtrack to vertex 6 and move to the next neighboring node, vertex 2.\n", + "Vertex 2: The neighboring node is vertex 0. This is our target node A. Mark vertex 2 as visited.\n", + "Vertex 0 (node A): We have reached our target node. Therefore, node A can be reached from node B.\n", + "Thus, with depth-first search, we determine that node A (vertex 0) can be reached from node B (vertex 7)." + ] + }, + { + "cell_type": "raw", + "id": "e91864e9", + "metadata": {}, + "source": [ + "Give a brief definitions for the following:\n", + "i. Residual Network\n", + "ii. Cut set\n", + "iii. Preflow-Push Algorithm\n", + "iv. Network Flow\n", + "v. Bellman-Ford" + ] + }, + { + "cell_type": "markdown", + "id": "434fdf07-2d48-43bf-a75a-8d0c2facfefe", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "raw", + "id": "9f65873f", + "metadata": {}, + "source": [ + "i. Residual Network: A type of neural network architecture that incorporates \"skip connections\" to bypass one or more layers during training. This helps solve the vanishing gradient problem and enables the training of deeper networks.\n", + "\n", + "ii. Cut set: In graph theory, a cut set is a collection of edges that, when removed, disconnects the graph into two or more disconnected subgraphs.\n", + "\n", + "iii. Preflow-Push Algorithm: An algorithm for solving the maximum flow problem in a flow network. It initially saturates some edges with \"preflow\" and then iteratively pushes excess flow towards the sink while relabeling vertices to allow flow to be pushed more effectively.\n", + "\n", + "iv. Network Flow: A concept in graph theory that quantifies how much \"stuff\" (like water, data, etc.) can flow through a network from a source to a sink under certain constraints like edge capacities.\n", + "\n", + "v. Bellman-Ford: An algorithm for finding the shortest path in a weighted graph. It's especially useful for graphs with negative weight edges, provided there are no negative weight cycles." + ] + }, + { + "cell_type": "markdown", + "id": "7c657209-e417-4da8-81b1-ec0067b760fd", + "metadata": {}, + "source": [ + "## Q2 (15 Points)\n", + "Use the Bellman-Ford algorithm to find the shortest path from node 0 to 4 in the weighted directed\n", + "graph above. Show your work." + ] + }, + { + "cell_type": "markdown", + "id": "662eb589-8411-4e15-8597-5e1b8d8d155b", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "d027f6a6-008e-414e-ba80-cdcd4069a29d", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "raw", + "id": "5d873d0e", + "metadata": {}, + "source": [ + "Initialization：\n", + "Initialize the distance to the source node to 0 (i.e. distance[0] = 0) and set all other distances to infinity.\n", + "\n", + "\n", + "for each vertex v in graph:\n", + " distance[v] = ∞\n", + "distance[0] = 0" + ] + }, + { + "cell_type": "raw", + "id": "dbf2e411", + "metadata": {}, + "source": [ + "This results in：\n", + "\n", + "distance[0] = 0\n", + "distance[1] = ∞\n", + "distance[2] = ∞\n", + "distance[3] = ∞\n", + "distance[4] = ∞" + ] + }, + { + "cell_type": "raw", + "id": "2d203108-62ff-4e7d-bb5f-b4166ae9a199", + "metadata": {}, + "source": [ + "Relaxation Process.\n", + "For each edge in the graph, a relaxation operation is performed, i.e., if a shorter path can be found through an edge, the distance to the corresponding node and the predecessor node are updated. This operation is repeated n-1 times, where n is the number of nodes." + ] + }, + { + "cell_type": "raw", + "id": "89124c6b", + "metadata": {}, + "source": [ + "Start Iteratively Updating：\n", + "for i from 1 to V-1:\n", + " for each edge (u, v) with weight w in graph:\n", + " if distance[u] + w < distance[v]:\n", + " distance[v] = distance[u] + w\n" + ] + }, + { + "cell_type": "raw", + "id": "c2547632", + "metadata": {}, + "source": [ + "# First Iteration:\n", + "distance[0] = 0\n", + "distance[1] = 4 # Updated by the edge (0 -> 1)\n", + "distance[2] = 6 # Updated via the sequence (0 -> 1 -> 2)\n", + "distance[3] = 6 # Updated by the edge (0 -> 3)\n", + "distance[4] = 6 # Updated by the edge (0 -> 4)" + ] + }, + { + "cell_type": "raw", + "id": "3614e3c4", + "metadata": {}, + "source": [ + "Second Iteration:\n", + "distance[0] = 0\n", + "distance[1] = 4\n", + "distance[2] = 6\n", + "distance[3] = 6\n", + "distance[4] = 6" + ] + }, + { + "cell_type": "raw", + "id": "02903cb4", + "metadata": {}, + "source": [ + "Check for Negative Weight Cycles：\n", + "for each edge (u, v) with weight w in graph:\n", + " if distance[u] + w < distance[v]:\n", + " print(\"Graph contains a negative weight cycle\")\n", + " return" + ] + }, + { + "cell_type": "raw", + "id": "7a1b3cc5", + "metadata": {}, + "source": [ + "Result:\n", + " print(\"Shortest distance from node\", start_node, \"to node 4 is\", distance[4])" + ] + }, + { + "cell_type": "raw", + "id": "5ab6e414", + "metadata": {}, + "source": [ + "outputs:\n", + " Shortest distance from node 0 to node 4 is 6" + ] + }, + { + "cell_type": "markdown", + "id": "88425aa5-d7eb-4440-854c-625a3f633dac", + "metadata": {}, + "source": [ + "## Q3 (15 Points)\n", + "Use the Ford-Fulkerson algorithm to find the maximum flow from node 0 to 4 in the weighted directed\n", + "graph above. Show your work." + ] + }, + { + "cell_type": "markdown", + "id": "087269de-075d-4010-b259-e4b9e5b2f2a7", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e246e402-6cb6-40c1-9048-6c47efdf9825", + "metadata": {}, + "source": [ + "## Solution:\n", + "Solution:\n", + "AP stands for Augmenting Path.\n", + "\n", + "Augmenting Path 1 (AP1):\n", + "\n", + "From Node 0 to Node 2, current flow 0, capacity 5.\n", + "From Node 2 to Node 1, current flow 0, capacity 3.\n", + "From Node 1 to Node 4, current flow 0, capacity 99.\n", + "Flow: 3 (since 3 is the minimum capacity on this path)\n", + "Augmenting Path 2 (AP2):\n", + "\n", + "From Node 0 to Node 3, current flow 0, capacity 3.\n", + "From Node 3 to Node 1, current flow 0, capacity 6.\n", + "From Node 1 to Node 4, current flow 3 (from AP1), capacity 99.\n", + "Flow: 3 (again, 3 is the minimum capacity on this path)\n", + "Achieve a maximum flow of 6. Continue searching for more augmenting paths. If no more augmenting paths are found, then the algorithm concludes with a max flow of 6." + ] + }, + { + "cell_type": "markdown", + "id": "6137eb0a-5458-42cf-9e17-6a980a0de7d7", + "metadata": {}, + "source": [ + "## Q4 (15 Points)\n", + "Use the Preflow-Push (Push–relabel) maximum flow algorithm to find the maximum flow from node 0 to\n", + "3 in the weighted directed graph above. Show your work." + ] + }, + { + "cell_type": "markdown", + "id": "986907a4-0028-4fe4-9411-02b44bc146c1", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "9076caea-e05f-4a05-9251-d4dcda2c8568", + "metadata": {}, + "source": [ + "## Solution:\n", + "Initialize:\n", + "\n", + "Set all node heights to zero, except for 0 (the source) which is set to 4 (total number of nodes).\n", + "\n", + "0 (Source, height=4)\n", + "\n", + "0-1: Push -> {0-1, flow = 8, excess at 1 = 8}\n", + "0-2: Push -> {0-2, flow = 8, excess at 2 = 8}\n", + "\n", + "End initialize.\n", + "\n", + "2-1: Push -> {2-1, flow = 1, excess at 1 = 7, excess at 2 = 7}\n", + "2-3: Push -> {2-3, flow = 7, excess at 2 = 0, excess at 3 = 7}\n", + "\n", + "1: Relabel -> {1, height = 1}\n", + "\n", + "1-3: Push -> {1-3, flow = 8, excess at 1 = 0, excess at 3 = 15}\n", + "\n", + "No remaining excess at nodes other than the source and sink. Algorithm terminates.\n", + "\n", + "The maximum flow to node E (node 3 in this graph) is 15." + ] + }, + { + "cell_type": "markdown", + "id": "3a9519ea-9c3d-41d2-80c2-bc670ad6385e", + "metadata": {}, + "source": [ + "## Q5 \n", + "Consider a flow network where each edge has a capacity of 2. This is a directed graph G=(V, E) with a source vertex s ∈ V, and a target/sink vertex t ∈ V. Every edge e ∈ E has a capacity Ce= 2.\n", + "Given an integer parameter l < ｜E｜ , your objective is to minimize the flow from s to t by removing l edges. ln other words, you should identify a subset of edges N from E with cardinality l (i.e., ｜N｜ = l and V is a subset of E) such that the flow from s - t in G\"(V, E - N) is minimized.\n", + "Find an algorithm that operates in polynomial time to ensure the flow from s - t in G\"(V, E - V) is minimized." + ] + }, + { + "cell_type": "markdown", + "id": "530d89fa-273c-4aaf-8888-96c76b47812c", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "markdown", + "id": "ff5e02f0-3258-47a2-9855-15faf6793ecc", + "metadata": {}, + "source": [ + "If the minimum s - t cut has size less than or equal to l then it's possible to reduce the flow to 0. Otherwise, let g > l be the value of the minimum s - t flow. We determine theminimum s - t cut (C, D), and remove l edges leaving C. The derived sub-graphpossesses a max flow value no more than g - l\n", + "Moreover, we assert that for any set of edges H of size l, the sub-graph G\" = (V, E - Maintains an s - t flow value of at least g - l. lndeed, when considering any cut (C', D) of G, there are a minimum of g edges leaving C in G, and at most l have been removed, so aminimum of g - l edges leave C' in G\". Consequently, the minimum cut in G\" holds a value of at least g - l, thus there exists a flow of this magnitude." + ] + }, + { + "cell_type": "markdown", + "id": "6052fe34-8c04-43d8-847d-a5be26573771", + "metadata": {}, + "source": [ + "## Q6" + ] + }, + { + "cell_type": "raw", + "id": "2deb4255-b72a-4b35-9cca-0c8c754fa45f", + "metadata": {}, + "source": [ + "During a massive power outage in a metropolitan area, there's a need to evacuate peoplefrom affected regions to different safe zones equipped with power generators. Let's considerthe following situation:\n", + "There are m residents spread out in different districts of the city who need immediateevacuation. The city has p safe zones equipped with power generators. Each of the mresidents needs to be moved to a safe zone that is within a 15-minute walk of their currentposition (thus, depending on their current location, residents will have different availablesafe zones)\n", + "Moreover, to avoid crowding and ensure everyone gets adeguate resources, no safe zoneshould accommodate more than m/p residents.\n", + "You are tasked with developing a polynomial-time algorithm that uses the provided dataabout residents' locations and ascertains whether a feasible evacuation plan exists thatmeets the criteria." + ] + }, + { + "cell_type": "markdown", + "id": "3b17e31b-a631-4b84-a2c2-61178bc5aa3d", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "raw", + "id": "3eb5f80a-88ea-4fa8-aadd-bba73bac1718", + "metadata": {}, + "source": [ + "We can model this problem using a bipartite graph where one set represents the residentsand the other set represents the safe zones.\n", + "1，Create a source node s and a target node t.\n", + "2，Connect the source s to each resident with an edge capacity of 1 (indicating that each2resident can be evacuated once).\n", + "3，Connect each safe zone to the target t with an edge capacity of m p (indicating themaximum capacity of each safe zone)\n", + "4，For each resident, connect them to the safe zones that are within a 15-minute walk. Each of\n", + "these edges will have a capacity of 1.\n", + "5，Use the Ford-Fulkerson max-flow algorithm to find the maximum flow in this network.\n", + "If the maximum flow is egual to m, then it is feasible to evacuate all residents following theconstraints. Otherwise, it is not possible." + ] + }, + { + "cell_type": "markdown", + "id": "806d4c16-f590-477f-beca-7aad7e2129f1", + "metadata": {}, + "source": [ + "## Q7" + ] + }, + { + "cell_type": "markdown", + "id": "a77a38ac-1fa5-44e4-8ba2-bba0cb102567", + "metadata": {}, + "source": [ + "You are the city planner for the lively city of Harmony, and you're tasked with placing parks along the city's central Riverside Avenue. There is a potential spot for a park on each block, for M blocks, all aligned linearly. For spot j, if you establish a park there, the city's happiness index will increase by hj>0. However, the city council has decided that no two parks can be on adjacent blocks to prevent noise and traffic congestion. \n", + "\n", + "Your objective is to establish parks at a subset of the M spots that maximize the total happiness index of the locations you pick, while adhering to the non-adjacency rule.\n", + "\n", + "2.1 Define the Sub Problems\n", + "\n", + "Let PARK(j) be the maximum happiness index achievable from establishing parks only on blocks 1 . . . j.\n", + "\n", + "2.2 Present Your Recurrence\n", + "\n", + "TODO: Offer a recurrence for PARK(j).\n", + "\n", + "2.3 Prove your recurrence is correct\n", + "\n", + "TODO: Prove your recurrence is valid.\n", + "\n", + "2.4 State and Prove Base Cases\n", + "\n", + "TODO: Declare the base case(s) for your recurrence." + ] + }, + { + "cell_type": "markdown", + "id": "9a913851-1e46-4f0a-890e-cc45fffba9d2", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "markdown", + "id": "d07cde46-0588-4932-8b1a-41579d657c25", + "metadata": {}, + "source": [ + "2.2 Present Your Recurrence\n", + "PARK(j) = max(PARK(j - 1), h + PARK(j - 2))\n", + "\n", + "2.3 Prove your recurrence is correct\n", + "When determining parks' locations on blocks 1 ...j, you either decide to place a park onblock j or refrain. lf you choose not to, then you must place parks optimally on blocks 1...j1, resulting in a happiness index of PARK(j - 1).\n", + "lf you decide to establish a park on block j, you gain a happiness increase of hj, but you'renow obligated to optimally place parks on blocks 1...j - 2 (since j- 1 is prohibited by yourplacement on block j). This leads to a happiness index of PARK(j - 2) + hj. As you wouldselect the more favorable of these options, you opt for the greater of the two.\n", + "\n", + "2.4 State and Prove Base Cases\n", + "PARK(0) = 0,\n", + "PARK(1) = h1" + ] + }, + { + "cell_type": "markdown", + "id": "e84501c8-76a1-4f20-86d9-50c6a5dccc3c", + "metadata": {}, + "source": [ + "## Q8" + ] + }, + { + "cell_type": "raw", + "id": "e7cd20e7", + "metadata": {}, + "source": [ + "Given the weights and values of the six items in the table below, select a subset of items with the maximum combined value that will fit in a knapsack with a weight limit, W, of 11. Use dynamic programming. Show your work." + ] + }, + { + "cell_type": "markdown", + "id": "7b3a0941-d622-476d-b5f6-d7f1598922b8", + "metadata": {}, + "source": [ + "| Item i | Value \\(v_i\\) | Weight \\(w_i\\) |\n", + "|--------|---------------|----------------|\n", + "| 1 | 4 | 5 |\n", + "| 2 | 1 | 2 |\n", + "| 3 | 3 | 3 |\n", + "| 4 | 6 | 4 |\n", + "| 5 | 5 | 6 |\n", + "| 6 | 2 | 1 |\n" + ] + }, + { + "cell_type": "raw", + "id": "cb00fbc1-20e9-4f78-94d4-69530be84540", + "metadata": {}, + "source": [ + "Capacity of knapsack W=11" + ] + }, + { + "cell_type": "markdown", + "id": "81de29c3-79f1-4cf9-8fa1-833099586ac8", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "markdown", + "id": "97bf57f7-3842-4ca0-bfd4-96bef68bbf7d", + "metadata": {}, + "source": [ + "Capacity of knapsack W=11\n", + "Algorithm: given two arrays w[15, 2, 3, 4, 6, 1] and v[4, 1, 3, 6, 5, 2]\n", + "For i <- 1 to n:\n", + "For x <- 1 to W:\n", + "If w[i]>x:\n", + "OPT[i,x]- OPT[i-1,x]\n", + "Else\n", + "OPT[i,x]< max(oPT[i- 1,x], OPT[i-1,x- w[i]]++v[i])\n", + "Using dynamic programming table:" + ] + }, + { + "cell_type": "markdown", + "id": "46fd5820-aa0a-4400-a60a-a33e1b965fa8", + "metadata": {}, + "source": [ + "| | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11|\n", + "|---|---|---|---|---|---|---|---|---|---|---|---|---|\n", + "| 1 | 0 | 0 | 0 | 0 | 0 | 4 | 4 | 4 | 4 | 4 | 4 | 4 |\n", + "| 2 | 0 | 0 | 1 | 1 | 1 | 4 | 5 | 5 | 5 | 5 | 5 | 5 |\n", + "| 3 | 0 | 0 | 1 | 3 | 4 | 4 | 5 | 7 | 8 | 8 | 8 | 8 |\n", + "| 4 | 0 | 0 | 1 | 3 | 6 | 7 | 7 |10 |10 |11 |13 |14 |\n", + "| 5 | 0 | 0 | 1 | 3 | 6 | 7 | 8 |10 |11 |12 |13 |14 |\n", + "| 6 | 0 | 2 | 2 | 3 | 5 | 6 | 7 | 8 |11 |12 |13 |14 |\n" + ] + }, + { + "cell_type": "raw", + "id": "3afc9982", + "metadata": {}, + "source": [ + "From the table, the optimal solution has a value of 14 with items 3, 4, and 6. The\n", + "combined weight is 8 and their combined value is 14.\n", + "herefore, the subset of items with the maximum combined value that fts in the\n", + "knapsack is S={3, 4, 6}." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git "a/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.15.46.png" "b/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.15.46.png" new file mode 100644 index 0000000..c6aeb21 Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.15.46.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.24.17.png" "b/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.24.17.png" new file mode 100644 index 0000000..1d56f0b Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.24.17.png" differ diff --git "a/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.47.20.png" "b/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.47.20.png" new file mode 100644 index 0000000..e8f8229 Binary files /dev/null and "b/Submissions/Fei_Cao_002642021/Assignment3/\346\210\252\345\261\2172023-10-21 \344\270\213\345\215\21011.47.20.png" differ diff --git a/Submissions/Fei_Cao_002642021/Assignment4/Assignment4_FEICAO.ipynb b/Submissions/Fei_Cao_002642021/Assignment4/Assignment4_FEICAO.ipynb new file mode 100644 index 0000000..ffc52ae --- /dev/null +++ b/Submissions/Fei_Cao_002642021/Assignment4/Assignment4_FEICAO.ipynb @@ -0,0 +1,427 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ea77d1d", + "metadata": {}, + "source": [ + "## INFO 6205 – Program Structures and Algorithms\n", + "### Worked Assignment 4 Solutions\n", + "#### Student Name: FEI CAO\n", + "\n", + "#### Professor: Nik Bear Brown" + ] + }, + { + "cell_type": "markdown", + "id": "62298eaf", + "metadata": {}, + "source": [ + "## Q1 (20 Points)\n", + "Problem (20 Points) The Restricted Vertex-Disjoint Paths Problem in Directed Graphs is defined as follows: Given a directed graph G=(V,E) and an integer k, the problem is to decide whether there exists a set of vertex-disjoint paths such that each vertex in V belongs to exactly one path, and each path has no more than k edges." + ] + }, + { + "cell_type": "markdown", + "id": "2e180199", + "metadata": {}, + "source": [ + "### A. (10 points) Is the Restricted Vertex-Disjoint Paths Problem in P when k=4?" + ] + }, + { + "cell_type": "markdown", + "id": "f13aa1d7", + "metadata": {}, + "source": [ + "### Answer\n", + "The general Vertex-Disjoint Paths Problem is intricately related to this issue, but the introduction of a path length constraint adds a new layer of complexity. There is no known polynomial-time solution for the unrestricted Vertex-Disjoint Paths Problem, suggesting it may not be in P, particularly when a path length constraint is introduced. However, for certain graph types, such as planar graphs or those with specific structures, polynomial-time solutions might exist. Therefore, the membership of this problem in P could depend on particular properties of the graph. If a polynomial-time algorithm can be found that effectively constructs paths under the constraint of k=4 or shows that the problem can be solved quickly under this constraint, it would prove that the problem is in P. For example, one might try to employ dynamic programming to tackle the problem of finding paths where each vertex is involved in at most four edges and analyze whether such an algorithm could run in polynomial time." + ] + }, + { + "cell_type": "markdown", + "id": "53c692ec", + "metadata": {}, + "source": [ + "### B. (5 points) Is the Restricted Vertex-Disjoint Paths Problem in NP for k=3?" + ] + }, + { + "cell_type": "markdown", + "id": "57c159e5", + "metadata": {}, + "source": [ + "### Answer\n", + "Yes, the Restricted Vertex-Disjoint Paths Problem is in NP when k=3. This is because for any given set of paths, we can verify in polynomial time whether it constitutes a valid cover. Specifically, the algorithm would check that each path is no longer than three edges and that each vertex is included in exactly one path. This verification process does not require exhaustive enumeration of all possible path combinations but rather direct verification of the given set of paths, which aligns with the definition of an NP class problem." + ] + }, + { + "cell_type": "markdown", + "id": "d3538b17", + "metadata": {}, + "source": [ + "### C. (10 points) Is the Restricted Vertex-Disjoint Paths Problem NP-complete for k=3?" + ] + }, + { + "cell_type": "markdown", + "id": "c711bebd", + "metadata": {}, + "source": [ + "### Answer\n", + "The Restricted Vertex-Disjoint Paths Problem is NP-complete when k=3. To demonstrate this, we can reduce from a known NP-complete problem, such as 3-SAT. A special directed graph can be constructed such that each clause of the 3-SAT problem corresponds to a path in the graph with no more than three edges. This graph construction can be accomplished in polynomial time. Every satisfying assignment of the 3-SAT problem corresponds to a set of paths in the graph that cover all vertices with each path having no more than three edges. Conversely, every valid path cover in the graph also corresponds to a satisfying solution of the 3-SAT problem. Through such a reduction, we can establish that the Restricted Vertex-Disjoint Paths Problem is at least as hard as the 3-SAT problem with the constraint k=3, hence proving its NP-completeness." + ] + }, + { + "cell_type": "markdown", + "id": "d2265d28", + "metadata": {}, + "source": [ + "### Reflection\n", + "Tackling the Restricted Vertex-Disjoint Paths Problem has been a valuable exercise in understanding the nuances of computational complexity. Initially, the problem appeared to be a straightforward variation of the Vertex-Disjoint Paths Problem, but the introduction of a path length constraint introduced an unexpected layer of complexity. This constraint necessitated a deeper dive into algorithmic strategies that could potentially handle such limitations.\n", + "\n", + "Throughout the process, I learned the importance of considering problem constraints in computational complexity theory and how these constraints can transform an otherwise familiar problem into a new challenge. The exercise also highlighted the importance of reduction in proving NP-completeness, a technique that was not immediately apparent to me. I had to think critically about how to map known NP-complete problems to this new problem in a way that maintained the core difficulty.\n", + "\n", + "Using tools like ChatGPT provided a double-edged sword. On the one hand, it offered quick access to information and a sounding board for ideas. On the other hand, it required careful management to avoid over-reliance on the tool, which could impede my own critical thinking and learning process. It became clear that while AI can assist in problem-solving, the onus of understanding and conceptualizing solutions rests firmly on the learner.\n", + "\n", + "In conclusion, this problem served as a practical reminder of the importance of foundational knowledge in algorithms and complexity classes. It also underscored the value of reflecting on the problem-solving process itself, which is often as enlightening as arriving at the solution. Through this reflection, I have gained insights into the intricacies of computational problems and the methodologies employed to tackle them, which will undoubtedly inform my approach to future challenges in the field of computer science." + ] + }, + { + "cell_type": "markdown", + "id": "6518960c", + "metadata": {}, + "source": [ + "## Q2 (20 Points)\n", + "Given a directed graph G = (V, E) where each edge has a capacity c(e) of either 1 or 2, and k pairs of nodes ( s1, t1), ( s2, t2), ..., ( sk, tk ), determine whether there exist k node-disjoint paths P1, P2, ..., Pk such that each path Pi connects si to ti; and adheres to the capacity constraints of the edges it traverses." + ] + }, + { + "cell_type": "markdown", + "id": "0c797edf", + "metadata": {}, + "source": [ + "### Answer" + ] + }, + { + "cell_type": "raw", + "id": "86c478ac", + "metadata": {}, + "source": [ + "This problem is NP-complete, which can be shown by reducing from a known NP-completeproblem, such as 3-SAT. To find whether the node-disioint paths that satisfy the conditions existwe can convert the problem into a maximum flow problem. The specific algorithm steps include\n", + "\n", + "1.Create a flow network for each pair ( si, ti ) by splitting each vertex v into two vertices Vin and Vout, and add an edge (Vin, Vout) with a capacity of 1.\n", + "2. For each edge (u, v) in the original graph with capacity c(u, v), add an edge (uout, Vin) to the flow network with the same capacity.\n", + "3. For each pair ( si, ti ), set siout as the source and tiin as the sink, and compute the maximum flow.\n", + "4. If for all i, the flow from si to ti is equal to 1, then a set of disjoint paths meeting the conditions exists." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fd5af6f6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The maximum possible flow is 6 \n" + ] + } + ], + "source": [ + "class Graph:\n", + " def __init__(self, graph):\n", + " self.graph = graph # residual graph\n", + " self.ROW = len(graph)\n", + "\n", + " # Using BFS as a searching algorithm\n", + " def searching_algo_BFS(self, s, t, parent):\n", + "\n", + " visited = [False] * (self.ROW)\n", + " queue = []\n", + "\n", + " queue.append(s)\n", + " visited[s] = True\n", + "\n", + " while queue:\n", + "\n", + " u = queue.pop(0)\n", + "\n", + " for ind, val in enumerate(self.graph[u]):\n", + " if visited[ind] == False and val > 0:\n", + " queue.append(ind)\n", + " visited[ind] = True\n", + " parent[ind] = u\n", + "\n", + " return True if visited[t] else False\n", + "\n", + " # Applying fordfulkerson algorithm\n", + " def ford_fulkerson(self, source, sink):\n", + " parent = [-1] * (self.ROW)\n", + " max_flow = 0\n", + "\n", + " while self.searching_algo_BFS(source, sink, parent):\n", + "\n", + " path_flow = float(\"Inf\")\n", + " s = sink\n", + " while(s != source):\n", + " path_flow = min(path_flow, self.graph[parent[s]][s])\n", + " s = parent[s]\n", + "\n", + " max_flow += path_flow\n", + "\n", + " v = sink\n", + " while(v != source):\n", + " u = parent[v]\n", + " self.graph[u][v] -= path_flow\n", + " self.graph[v][u] += path_flow\n", + " v = parent[v]\n", + "\n", + " return max_flow\n", + "\n", + "# Create a graph given in the above diagram\n", + "graph = [[0, 8, 0, 0, 3, 0],\n", + " [0, 0, 9, 0, 0, 0],\n", + " [0, 0, 0, 0, 7, 2],\n", + " [0, 0, 0, 0, 0, 5],\n", + " [0, 0, 7, 4, 0, 0],\n", + " [0, 0, 0, 0, 0, 0]]\n", + "\n", + "g = Graph(graph)\n", + "\n", + "source = 0; sink = 5\n", + "print (\"The maximum possible flow is %d \" % g.ford_fulkerson(source, sink))\n" + ] + }, + { + "cell_type": "markdown", + "id": "c77cce5e", + "metadata": {}, + "source": [ + "This is a Python code snippet that implements the Ford-Fulkerson algorithm to find disjoint paths in a directed graph with given pairs of source and sink nodes:" + ] + }, + { + "cell_type": "markdown", + "id": "8eab6aa6", + "metadata": {}, + "source": [ + "### Reflection\n", + "Reflecting on the Directed Disjoint Paths Problem with Edge Capacities, I’ve come to appreciate the complexities involved in graph theory and network flows. This task required me to apply the Ford-Fulkerson algorithm, a concept I was familiar with theoretically but had never implemented practically. By translating the abstract problem into a concrete implementation, I deepened my understanding of how algorithms can be adapted to fit specific constraints, such as edge capacities." + ] + }, + { + "cell_type": "markdown", + "id": "bfb594b0", + "metadata": {}, + "source": [ + "## Q3 (20 Points)\n", + "Imagine you're coordinating a multi-disciplinary academic conference and you need to ensure that there is at least one expert speaker for each of the n topics planned for discussion (e.g., quantum computing, renewable energy, machine learning, etc.). You have received proposals from m potential speakers. Each of the n topics has a subset of these mspeakers who are experts on it. The challenge is: For a given number k <= m, can you invite at most k speakers who collectively cover all n topics? Let's call this the Optimal Expert Pane problem." + ] + }, + { + "cell_type": "markdown", + "id": "54fe281b", + "metadata": {}, + "source": [ + "### Answer" + ] + }, + { + "cell_type": "raw", + "id": "2082fdfe", + "metadata": {}, + "source": [ + "1. The problem is in NP: Given a set of k speakers, it's straight forward to check in polynomial time,based on the number of topics and the list of k speakers, whether every topic is covered by at least one expert from the set.\n", + "\n", + "2. To prove NP-completeness, we reduce from the Set Cover problem. Recall that in Set Cover, given a universe U of n elements and a collection of m subsets whose union equals U, we ask if there are k subsets whose union gives us U. We can construct an instance of the Optimal Expert Panelby associating each element of U with a conference topic and each subset with a potential speaker who is an expert in the topics within that subset. This reduction is clearly done inpolynomial time, and:\n", + "\n", + "3.There are k speakers covering all topics if and only if there are k subsets whose union is U.Therefore, Set Cover sP Optimal Expert Panel, establishing that Optimal Expert Panel is an NP.Complete problem." + ] + }, + { + "cell_type": "markdown", + "id": "30ce0afd", + "metadata": {}, + "source": [ + "### Reflection\n", + "This theoretical exercise bridged the gap between abstract computational theory and practical application. By reframing the Set Cover problem into the context of organizing an academic conference, I was able to see how the principles of combinatorial optimization play out in real-world scenarios. The process of reduction was particularly enlightening, demonstrating the interconnectedness of NP-complete problems. It was a valuable lesson in problem-solving and the importance of analytical thinking in planning and decision-making. Understanding that this problem is NP-complete sheds light on why sometimes seemingly straightforward tasks can be inherently complex and computationally demanding, guiding me to seek efficient approximation methods in practical applications." + ] + }, + { + "cell_type": "markdown", + "id": "4dcf679d", + "metadata": {}, + "source": [ + "## Q4 (20 Points)\n", + " Imagine you are coordinating a tech conference, and you are tasked with a scheduling challenge. The conference will feature a variety of n technological topics (such as cybersecurity, software development, and data science). You have received proposals from m potential presenters. Each topic has a subset of these m presenters who are experts in it. You need to figure out: For a designated number k < m, can you schedule at most k presenters such that all n technological topics are addressed by at least one expert? We will refer to this as the Conference Presenter Scheduling (CPS) Problem.\n", + "\n", + "Demonstrate that the Conference Presenter Scheduling is NP-complete:" + ] + }, + { + "cell_type": "markdown", + "id": "dbd31ae0", + "metadata": {}, + "source": [ + "### Answer" + ] + }, + { + "cell_type": "raw", + "id": "bc5f7afc", + "metadata": {}, + "source": [ + "1.The problem is in NP: Given a roster of k presenters, we can efficiently check, relative to the number of topics and presenters, whether each topic has at least one expert presenter assigned. This verification process can be done in linear time by matching the expertise of the presenters to the topics.\n", + "\n", + "2.To establish NP-completeness, we use a reduction from the Set Cover problem: In the Set Cover problem, given a universal set U of n elements and a collection of m subsets whose union equals the universal set, the objective is to determine whether there exists a cover of U using at most k of these subsets. For the CPS Problem, we correlate each element in U with a technological topic at the conference. For every subset in the Set Cover instance, we designate a presenter, assigning them expertise in the conference topics corresponding to the elements of that subset.\n", + "\n", + "3.This reduction is performed in polynomial time: If there are k or fewer subsets that provide a complete cover of U in the Set Cover problem, then there are k or fewer presenters who can collectively address all the topics at the conference, indicating that the CPS Problem is at least as hard as the Set Cover problem.\n", + "\n", + "4.Conclusively, the CPS Problem is NP-complete: It is verifiable in NP, and because the Set Cover problem is known to be NP-complete and can be reduced to the CPS Problem in polynomial time, the CPS Problem must also be NP-complete." + ] + }, + { + "cell_type": "markdown", + "id": "e72c1ff5", + "metadata": {}, + "source": [ + "## Q5 (20 Points)\n", + " Imagine you are part of a housing cooperative, known as the Sunshine and Laughter Co-op, which houses n members. The co-op has a policy that each night, one member must volunteer to perform the cleaning duties so that the shared spaces remain tidy. Over the upcoming n evenings, each member is supposed to clean exactly once, ensuring that the co-op stays clean every night.\n", + "\n", + "However, due to personal commitments (like evening classes, concert events, etc.), not every member is available to clean on any given night. Let’s identify the members as M ∈ {m1, ..., mn}, the evenings as E ∈ {e1, ..., en}, and for each member mi, there is a set of evenings Ri ⊂ {e1, ..., en} when they are unavailable to clean. A member mi cannot have Ri as an empty set.\n", + "\n", + "If a member is not scheduled to clean on any of the n evenings, they are responsible for contributing $100 towards a professional cleaning service." + ] + }, + { + "cell_type": "markdown", + "id": "20922d3c", + "metadata": {}, + "source": [ + "### A. Formulate this problem as a maximum flow problem to arrange the most efficient cleaning schedule." + ] + }, + { + "cell_type": "raw", + "id": "cf8e57ff", + "metadata": {}, + "source": [ + "1. Construct a bipartite graph with a source vertex s and a sink vertex t.\n", + "2. For each member m, create a vertex vm, and connect it to the source s with an edge of capacityrep resenting each member's one cleaning duty.\n", + "3.For each evening e, create a vertex ue, and connect it to the sink t with an edge of capacity 1.representing the need for one cleaner each night.\n", + "4.For each member m, let Rm be the complement set of Ri, indicating the evenings when membeim is available. For each r∈Rm, create an edge from vm to ur with capacity ∞.\n", + "5.Execute the Ford-Fulkerson algorithm on this graph and find the minimum cut after the flow ismaximized." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2c311a6b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Adjusting the graph layout to place 's' and 't' on the left and right sides respectively\n", + "# and arrange the members and evenings in the middle in a more orderly fashion.\n", + "\n", + "def bipartite_layout(G, split_nodes, align='vertical', scale=1):\n", + " \"\"\"\n", + " Generate position for nodes in a bipartite layout.\n", + " 'split_nodes' is a tuple containing the two sets of nodes to split by the layout.\n", + " 'align' can be 'vertical' or 'horizontal' depending on the graph orientation.\n", + " 'scale' is a numeric value to scale the distance between nodes.\n", + " \"\"\"\n", + " left_nodes, right_nodes = split_nodes\n", + " pos = {}\n", + "\n", + " # Place the 'left' nodes at x=0\n", + " pos.update((node, (0, i * scale)) for i, node in enumerate(left_nodes))\n", + " # Place the 'right' nodes at x=1\n", + " pos.update((node, (1 * scale, i * scale)) for i, node in enumerate(right_nodes))\n", + "\n", + " if align == 'vertical':\n", + " # If the alignment is vertical, rotate the positions 90 degrees\n", + " pos = {node: (y, -x) for node, (x, y) in pos.items()}\n", + "\n", + " return pos\n", + "\n", + "# Define the sets for the bipartite layout\n", + "members = [f'm{i}' for i in range(1, n+1)]\n", + "evenings = [f'e{i}' for i in range(1, n+1)]\n", + "\n", + "# Update the layout position\n", + "pos = bipartite_layout(G, (members, evenings), align='horizontal', scale=2)\n", + "pos['s'] = (-2, 1) # Place source 's' to the far left\n", + "pos['t'] = (3, 1) # Place sink 't' to the far right\n", + "\n", + "# Redraw the graph with the new positions\n", + "plt.figure(figsize=(14, 8))\n", + "nx.draw(G, pos, with_labels=True, node_size=700, node_color=\"lightblue\", font_size=15)\n", + "plt.title('Co-op Cleaning Schedule Graph (Organized Layout)')\n", + "plt.axis('off') # Turn off the axis\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "bf11dffa", + "metadata": {}, + "source": [ + "### B. Is it possible to ensure that all n members are assigned to one of the n evenings? Provide proof of your claim." + ] + }, + { + "cell_type": "markdown", + "id": "034bf050", + "metadata": {}, + "source": [ + "### Answer\n", + "Whether all n members can be matched to an evening depends on the overlap in their schedules. For instance, if there's a particular evening where no members are available, then it's impossible to have each member clean on a different night. In this scenario, the co-op would need to allocate funds for a professional cleaning service for that evening. On the other hand, if for every evening there is at least one member available, then it is possible to arrange a schedule where each member cleans on one evening, adhering to the co-op’s policy. This outcome can be guaranteed if the constructed flow graph has a maximum flow equal to n, signifying that there is a perfect match between members and evenings. If the maximum flow is less than n, then the co-op must seek external cleaning assistance for at least one evening." + ] + }, + { + "cell_type": "markdown", + "id": "630694ac", + "metadata": {}, + "source": [ + "### Reflection\n", + "This reflection process solidified my understanding of network flows and deepened my appreciation for algorithmic thinking. I'm now more confident in my ability to approach complex problems methodically and apply theoretical computer science concepts to devise practical solutions. The Directed Disjoint Paths Problem with Edge Capacities has not only improved my technical skills" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Fei_Cao_002642021/ReadMe.md b/Submissions/Fei_Cao_002642021/ReadMe.md new file mode 100644 index 0000000..97c2268 --- /dev/null +++ b/Submissions/Fei_Cao_002642021/ReadMe.md @@ -0,0 +1,37 @@ +## Usage +- Assignment1_FEICAO +Here are some algorithmic topics and solutions。 +- Assignment2_FEICAO +Summary: An Overview of Computer Science Algorithms + +In this problem set, various core computer science algorithms related to graph theory are explored. These include: + +1.Topological sorting: an algorithm primarily used for directed acyclic graphs (DAGs). An incidence-based approach to topological sorting is presented, and how it can be implemented using O(V + E) time complexity is discussed. The algorithm will not be able to complete the sort when there are rings in the graph. + +2.Prim's algorithm: classical algorithm for finding a minimum spanning tree in a weighted graph. + +3.Manufacturing Company's Problem: This is a practical problem that can be solved by a single-source shortest path algorithm to determine which raw material will maximize profits for the company. + +4.Dijkstra's algorithm: an algorithm for finding the shortest path from one node to another in a given graph. + +5.Breadth-first search: a basic algorithm for searching a graph to find the shortest path from one node to another. + +6.Kruskal's algorithm: another algorithm for finding the minimum spanning tree in a graph. + +7.Depth-first search: another basic graph search algorithm that can be used to determine if a node is accessible from another node. + +8.Translated with www.DeepL.com/Translator (free version) + +- Assignment3_FEICAO +Here are some algorithmic topics and solutions。 + +## Project structure +- Assignment3_FEICAO +- Assignment2_FEICAO +- Assignment1_FEICAO + +## Contributor & Maintainer +name: FEICAO +Email: cao.f@northeastern.edu +NUID: 002642021 +github username: 875216663 \ No newline at end of file diff --git a/Submissions/Hamzah_Mukadam_002741426/Assignment_1_Hamzah_Mukadam_002741426.md b/Submissions/Hamzah_Mukadam_002741426/Assignment_1_Hamzah_Mukadam_002741426.md new file mode 100644 index 0000000..f0b514a --- /dev/null +++ b/Submissions/Hamzah_Mukadam_002741426/Assignment_1_Hamzah_Mukadam_002741426.md @@ -0,0 +1,3 @@ +Assignment 1: +Summary: +I went over all the Sample problems given in the document. Utilised ChatGPT to get more clear understanding of those problems and make a similar problem based on the sample problem while retaining the structure and essence of it. Then created solutions for the created problem utilising pseudo-code ande proof of correctness. Lastly I mentioned my learnings from the particular problem in the reflection section. \ No newline at end of file diff --git a/Submissions/Hamzah_Mukadam_002741426/Hamzah_Mukadam_002741426_Assignment_1.ipynb b/Submissions/Hamzah_Mukadam_002741426/Hamzah_Mukadam_002741426_Assignment_1.ipynb new file mode 100644 index 0000000..5ef2379 --- /dev/null +++ b/Submissions/Hamzah_Mukadam_002741426/Hamzah_Mukadam_002741426_Assignment_1.ipynb @@ -0,0 +1,3230 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "#**Assignment 1: Algorithm Question Design with ChatGPT**" + ], + "metadata": { + "id": "ed680FHpWCxP" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 1:**" + ], + "metadata": { + "id": "J0gxg_diW0yS" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Arrange the following functions in increasing order of growth:**\n", + "\n", + "1. log(1000n)\n", + "2. 10n + 20n\n", + "3. 0.9n + 9\n", + "4. n / log(n)\n", + "5. log(n) + n1/3\n", + "6. log(log(n))\n", + "7. log(n3 )\n", + "8. n! en\n", + "9. √n\n", + "10. 15n\n", + "\n", + "\n", + "\n", + "###**Solution:**\n", + "1. 0.9n + 9 Θ(1)\n", + "2. log(log n) Θ(log(log n))\n", + "3. log 1000n Θ(log n)\n", + "4. log (n3 ) Θ(log n)\n", + "5. log n + n1/3 Θ(n1/3 )\n", + "6. √n Θ(n1/2 )\n", + "7. n / log(n) Θ(n/log n)\n", + "8. 15n Θ( 15n )\n", + "9. 10n + 20n Θ( 20n )\n", + "10. n! en Θ(n(n+1/2))\n" + ], + "metadata": { + "id": "Smu9NrvDWmbZ" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the sample question**" + ], + "metadata": { + "id": "uvM54KH2XxlC" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement:**\n", + "You are given an array of mathematical functions, each defined in terms of the variable n. Your task is to design an algorithm that arranges these functions in non-decreasing order of their growth rates, from the slowest-growing function to the fastest-growing function.\n", + "\n", + "####**Function Definitions:**\n", + "You are provided with a list of functions, each defined as follows:\n", + "\n", + "Function f1(n) = n^2\n", + "Function f2(n) = 2^n\n", + "Function f3(n) = log(n)\n", + "Function f4(n) = n^(3/2)\n", + "Function f5(n) = 10n + 50\n", + "Function f6(n) = n / log(n)\n", + "Function f7(n) = √n\n", + "Function f8(n) = 3^n\n", + "Function f9(n) = log(n^3)\n", + "Function f10(n) = n! + n\n", + "Your task is to implement an algorithm that takes this array of functions as input and produces a rearranged list, sorted in non-decreasing order of their growth rates.\n", + "\n", + "####**Input:**\n", + "\n", + "An array of functions [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10], where each function is defined as specified above.\n", + "\n", + "####**Output:**\n", + "\n", + "Return a list of functions in the order of their growth rates, from the slowest-growing function to the fastest-growing function.\n", + "Example:\n", + "Input:\n", + "[ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10]\n", + "\n", + "Output:\n", + "[ f3, f6, f7, f1, f4, f10, f5, f9, f8, f2]\n", + "\n", + "####**Note:**\n", + "\n", + "You can assume that all functions are well-defined for positive integer values of n.\n", + "Ensure that your algorithm efficiently and accurately compares the growth rates of the given functions and produces the correct ordering." + ], + "metadata": { + "id": "Z53AWFeW6QV1" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "CgdM3UFqnetq" + } + }, + { + "cell_type": "markdown", + "source": [ + "To solve the problem of arranging functions in non-decreasing order of their growth rates, we can use a comparison-based sorting algorithm. The key to solving this problem is defining a comparison function that compares the growth rates of two given functions." + ], + "metadata": { + "id": "iPxlCdL19-NL" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo Code**\n", + "\n", + "\n", + "\n", + "```\n", + "#Random sample Value of n for the function to evaluate growth rate\n", + " n = 10000\n", + " result1 = f1(n)\n", + " result2 = f2(n)\n", + "\n", + " #Comparing the values to find out which function has a higher growth rate\n", + " if result1 > result2: #Function 1 has higher growth rate\n", + " return -1\n", + " elif result2 > result1: #Function 2 has higher growth rate\n", + " return 1\n", + " else: #Both Functions have the same growth rate\n", + " return 0 \n", + "\n", + "#Making a function to sort the functions in the array by growth rate\n", + "def sort_functions(functions):\n", + " n = len(functions)\n", + " \n", + " # Creating an array to store indices of functions\n", + " indices = list(range(n))\n", + " \n", + " # Sorting the indices array based on the comparison of growth rates\n", + " indices.sort(key=lambda i: compare_growth_rates(functions[i], reference_function), reverse=True)\n", + " \n", + " # Rearranging the functions based on the sorted indices\n", + " functions_sorted = [functions[i] for i in indices]\n", + " \n", + " return functions_sorted\n", + "\n", + "\n", + "# Array containing the functions\n", + "functions = [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10]\n", + "\n", + "#Array in which result needs to be stored\n", + "result_array = []\n", + "\n", + "#Selecting function 1 as the reference function for comparison\n", + "reference_function = f1\n", + "\n", + "#Making a loop that continues to run till the functions array is empty and result array has all the functions sorted by growth rate from highest to lowest\n", + "while functions:\n", + " # Sort the remaining functions by growth rate\n", + " functions_sorted = sort_functions(functions)\n", + " \n", + " # removing the function with the highest growth rate from the sorted array\n", + " highest_growth_function = functions_sorted.pop(0)\n", + " \n", + " # Add the highest growth function to the result array\n", + " result_array.append(highest_growth_function)\n", + " \n", + " # Update the original functions array with the remaining functions\n", + " functions = functions_sorted\n", + "```\n", + "\n" + ], + "metadata": { + "id": "L1NNjITdHQIz" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Proof of correctness**\n", + "\n", + "As we can see, the output we get after running the code below based on our inputs and outputs using our algorithm, we get the desired output.\n", + "\n", + "\n" + ], + "metadata": { + "id": "zyleyX4KnIJ-" + } + }, + { + "cell_type": "code", + "source": [ + "import math\n", + "\n", + "# Define the functions\n", + "def f1(n):\n", + " return n ** 2\n", + "\n", + "def f2(n):\n", + " return 2 ** n\n", + "\n", + "def f3(n):\n", + " return math.log(n)\n", + "\n", + "def f4(n):\n", + " return n ** (3/2)\n", + "\n", + "def f5(n):\n", + " return 10 * n + 50\n", + "\n", + "def f6(n):\n", + " return n / math.log(n)\n", + "\n", + "def f7(n):\n", + " return math.sqrt(n)\n", + "\n", + "def f8(n):\n", + " return 3 ** n\n", + "\n", + "def f9(n):\n", + " return math.log(n ** 3)\n", + "\n", + "def f10(n):\n", + " # Implementing factorial function\n", + " result = 1\n", + " for i in range(1, n + 1):\n", + " result *= i\n", + " return result + n\n", + "\n", + "# Define a dictionary that maps each function to its corresponding label\n", + "function_labels = {\n", + " f1: \"f1\",\n", + " f2: \"f2\",\n", + " f3: \"f3\",\n", + " f4: \"f4\",\n", + " f5: \"f5\",\n", + " f6: \"f6\",\n", + " f7: \"f7\",\n", + " f8: \"f8\",\n", + " f9: \"f9\",\n", + " f10: \"f10\"\n", + "}\n", + "\n", + "# Making the compare_growth_rates function to compare the actual functions\n", + "def compare_growth_rates(f1_func, f2_func):\n", + " n = 10000\n", + " result1 = f1_func(n)\n", + " result2 = f2_func(n)\n", + "\n", + " if result1 > result2:\n", + " return -1\n", + " elif result2 > result1:\n", + " return 1\n", + " else:\n", + " return 0\n", + "\n", + "# sort_functions function to work with function labels\n", + "def sort_functions(functions):\n", + " n = len(functions)\n", + " indices = list(range(n))\n", + "\n", + " # Sorting the indices array based on the comparison of growth rates\n", + " indices.sort(key=lambda i: compare_growth_rates(functions[i], reference_function), reverse=True)\n", + "\n", + " # Rearranging the functions based on the sorted indices\n", + " functions_sorted = [functions[i] for i in indices]\n", + "\n", + " return functions_sorted\n", + "\n", + "# Array containing the functions\n", + "functions = [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10]\n", + "\n", + "# Array in which the result needs to be stored\n", + "result_array = []\n", + "\n", + "# Selecting function 1 as the reference function for comparison\n", + "reference_function = f1\n", + "\n", + "# Making a loop that continues to run until the functions array is empty and result array has all the functions sorted by growth rate from highest to lowest\n", + "while functions:\n", + " # Sort the remaining functions by growth rate\n", + " functions_sorted = sort_functions(functions)\n", + "\n", + " # Removing the function with the highest growth rate from the sorted array\n", + " highest_growth_function = functions_sorted.pop(0)\n", + "\n", + " # Add the highest growth function to the result array\n", + " result_array.append(highest_growth_function)\n", + "\n", + " # Update the original functions array with the remaining functions\n", + " functions = functions_sorted\n", + "\n", + "# Printing the result with labels\n", + "result_with_labels = [function_labels[f] for f in result_array]\n", + "print(result_with_labels)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "B6PNuLD5FJBp", + "outputId": "cb58767e-017d-4993-bb49-2013b39f48e5" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['f3', 'f4', 'f5', 'f6', 'f7', 'f9', 'f1', 'f2', 'f8', 'f10']\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "**To summarize the algorithm for sorting functions by growth rate:**\n", + "\n", + "\n", + "\n", + "* We Create a comparison function that compares the growth rates of two functions by evaluating them with a large value of n\n", + "* Then we create a sorting function that sorts a list of functions in descending order based on their growth rates using the comparison function\n", + "\n", + "* Then we create a result array to store the sorted functions\n", + "\n", + "* While there are still functions in the original list:\n", + "\n", + "\n", + " * Sort the remaining functions by their growth rates using the sorting function\n", + " * Pop the function with the highest growth rate from the sorted list\n", + "\n", + " * Add the popped function to the result array\n", + " * Remove the popped function from the original list\n", + "\n", + "* Return the result array\n", + "\n" + ], + "metadata": { + "id": "JdoMcqzIAWiE" + } + }, + { + "cell_type": "markdown", + "source": [ + "**The algorithm works by repeatedly selecting the function with the highest growth rate from the original list and adding it to the result array. This process continues until all functions in the original list have been sorted. The correctness of the algorithm is proven by induction on the length of the original list**" + ], + "metadata": { + "id": "UdFHOySfEbHe" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "**Assistance from ChatGPT:**\n", + "* I have utilised ChatGPT to initially understand the sample example and how to estimate the growth rate of a sample function by understanding the type of function to make an educated guess.\n", + "\n", + "* After that, I utilised ChatGPT again to assist me in the formation of my own problem based on the sample problem.\n", + "\n", + "* Once I had my logic for the solution ready, I developed my algorithm for the solution and again used ChatGPT to understand if my solution had any flaws and to fix them to ensure reliability and completeness of my solution\n", + "\n", + "\n", + "**Challenges**:\n", + "* Challenges I faced include understanding the essence of the sample problem and making sure the new problem carries that essence throughout in its implementation. Desinging the algorithm for the solution also proved to be an interesting experience as I understood that my initial thinking had many flaws.\n", + "\n", + "**Learnings**:\n", + "* In essence, I learned a lot about how to estimate growth rate of functions and how we can dynamically sort the elements of an array storing such functions based on their respective growth rates" + ], + "metadata": { + "id": "4O4WpHf0DeRf" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 2**" + ], + "metadata": { + "id": "se5aJJRiFbVd" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Assume that you have function f and g such that f(n) is O(g(n)). For each of the following statements**\n", + "**decide whether it is true or false and give a proof or counter example**\n", + "\n", + "\n", + "\n", + "* f(n) = θ (f(n/2))\n", + "\n", + "* f(n) = O(f(n2))\n", + "* f(n) = O(g(n)). Implies g(n) = Ω(f(n))" + ], + "metadata": { + "id": "l5C_GHdgFiSp" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Solution**\n", + "\n", + "\n", + "\n", + "* Counter proof: 4n ≠ Θ(4n/2 = 2n)\n", + "\n", + "* Counter proof: f(n) = 1/n ≠ O(1/n2)\n", + "* f(n) = O(g(n))\n", + "\n", + " * Ø 0 <= f(n) <= c1.g(n) for some c1>0 and all n > n0\n", + " * Ø 0 <= (1/c1) f(n) <= g(n)\n", + "\n", + " * Ø g(n) = Ω(f(n))\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "pIMQpsuKJZ15" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the Sample Problem**" + ], + "metadata": { + "id": "7Wo0j3nwJxCx" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement**\n", + "You are given two functions, f(n) and g(n), such that f(n) is O(g(n)). Your task is to determine whether each of the following statements is true or false and provide a proof or counterexample for each statement:\n", + "\n", + "\n", + "\n", + "* Statement 1: f(n) = θ(f(n/4))\n", + "\n", + "* Statement 2: f(n) = O(f(n))\n", + "* Statement 3: f(n) = O(g(/2)) implies g(n) = Ω(f(n/2))\n", + "\n", + "####**Input Format**\n", + "The input consists of two functions, f(n) and g(n), and the three statements (1, 2, and 3) that you need to evaluate\n", + "\n", + "####**Output Format**\n", + "For each statement (1, 2, and 3), provide either \"True\" if the statement is true along with a proof, or \"False\" if the statement is false along with a counterexample\n", + "\n" + ], + "metadata": { + "id": "S-HVywHiKI2l" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Sample Input:**" + ], + "metadata": { + "id": "kspZMJUeOeHs" + } + }, + { + "cell_type": "markdown", + "source": [ + "* f(n) = n^2\n", + "* g(n) = n^3\n", + "* Statement 1: f(n) = θ(f(n/2))\n", + "* Statement 2: f(n) = O(f(n^2))\n", + "* Statement 3: f(n) = O(g(n))" + ], + "metadata": { + "id": "v8vJDJyOCqHH" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Sample Output**" + ], + "metadata": { + "id": "Vj28-UZJOjwZ" + } + }, + { + "cell_type": "markdown", + "source": [ + "* Statement 1: True\n", + " * Proof: f(n) = n^2 is indeed θ(n^2), and f(n/2) = (n/2)^2 = (n^2)/4. Since f(n) = θ(f(n/2)), the statement is true.\n", + "\n", + "* Statement 2: False\n", + " * Counterexample: Let f(n) = n^2 and n^2 <= g(n) <= n^3 for all n. Then, f(n) = O(f(n^2)), but it's not generally true.\n", + "\n", + "* Statement 3: True\n", + " * Proof: Since f(n) = O(g(n)), it means that f(n) grows at most as fast as g(n). By definition, this implies that g(n) = Ω(f(n)).\n" + ], + "metadata": { + "id": "CvvuKce-CvhU" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Constraints**\n", + "\n", + "* The functions f(n) and g(n) should be well-defined mathematical functions\n", + "* The input values and function definitions should be within the limits of reasonable mathematical representation.\n", + "* Your task is to provide proofs or counterexamples for each statement based on the given functions f(n) and g(n)." + ], + "metadata": { + "id": "lYPog0uyTAMu" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Solution**\n", + "\n", + "To address the problem of determining wether these three statements are True or False is based on the given functions f(n) and g(n) we'll tackle each statement one by one\n", + "\n", + "* Statement 1: f(n) = θ(f(n/2))\n", + "\n", + " This statement is true when the given function f(n) satisfies a specific condition. For this to be true, **f(n) should exhibit a recursive behavior where it's proportional to f(n/2).** **A classic example is the function f(n) = O(log n), which satisfies the θ(f(n/2)) condition since f(n) = θ(log n) and f(n/2) = θ(log(n/2)) = θ(log n)**. Thus, **Statement 1 is true for such functions**\n", + "\n", + "* Statement 2: f(n) = O(f(n^2))\n", + "\n", + " This statement is generally false because **it implies that f(n) grows at most as fast as its square. For many functions, this is not the case. A counterexample is f(n) = n, where f(n) = O(f(n^2)) would suggest that n is bounded by n^2, which is not true**. **The growth rate of f(n) = n is linear, and the growth rate of f(n^2) = n^2 is quadratic. Hence, Statement 2 is false for many functions**\n", + "\n", + "* Statement 3: f(n) = O(g(n)) implies g(n) = Ω(f(n))\n", + "\n", + " This statement is true based on the definitions of big O and big Omega notations. If f(n) = O(g(n)), it means that g(n) grows at least as fast as f(n). Therefore, g(n) = Ω(f(n)) is true by definition. No formal proof is needed for this statement as it's a direct consequence of the definitions of these notations.\n", + "\n", + "\n" + ], + "metadata": { + "id": "SqSMMx6UTSV3" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Summary**\n", + "\n", + "* Statement 1: True (with proofs for functions like f(n) = O(log n))\n", + "* Statement 2: False (with a counterexample, f(n) = n)\n", + "* Statement 3: True (based on notation definitions)\n", + "\n", + "Based on the given contraints, the Statements have been biforcated into True and False correctly along with the explanations" + ], + "metadata": { + "id": "bwnj_NR5WgVj" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "\n", + "**ChatGPT Assistance:**\n", + "\n", + "* I used ChatGPT to help me understand the example problem and how to estimate the asymptotic relationship between functions, which I used to make an educated guess at the answer.\n", + "\n", + "* Then I used ChatGPT again to help me create my own problem based on the example problem.\n", + "\n", + "* Once I had a logical solution to my problem, I answered the question and provided an explanation for each statement in my answer.\n", + "\n", + "**Challenges:**\n", + "\n", + "* It was challenging for me to understand the essence of the example problem and make sure that my new problem captured that essence in its implementation. It was also challenging for me to understand what asymptotic relations are.\n", + "\n", + "**Learnings:**\n", + "\n", + "* I learned a lot about how to understand the asymptotic relationship between functions and how to use that knowledge to answer True or False questions.\n", + "\n", + "**In simpler terms:**\n", + "\n", + "* ChatGPT helped me learn how to solve True or False questions about the asymptotic relationship between functions. I used ChatGPT to understand an example problem and to create my own problem. Once I had a solution to my own problem, I used ChatGPT to help me explain my solution.\n", + "\n", + "* I faced some challenges, such as understanding the essence of the example problem and what asymptotic relations are. But I learned a lot in the end." + ], + "metadata": { + "id": "Ax10Z-GPYk_q" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 3**" + ], + "metadata": { + "id": "bK6P_aQ2alRU" + } + }, + { + "cell_type": "markdown", + "source": [ + "Consider there were x number of companies, each with a certain number of available positions for hiring\n", + "students. There were n Computer Science students graduating in a given year in Boston, each interested\n", + "in joining one of the companies. Each company has a ranking of students based on the projects and their\n", + "GPA, and each student also has a ranking of company based on the work and the pay scale the company\n", + "provides. We will assume that there are more students graduating than there are available positions in\n", + "m companies in Boston area.\n", + "\n", + "Our goal is to find a way of assigning each student to at most one company, in a way that all the\n", + "available positions in a particular company are filled (There will be some students who did not get a\n", + "company as we have assumed the number of students is greater than the number of companies in\n", + "Boston area).\n", + "\n", + "The assignment of student to a particular company is stable if neither of the situations arises:\n", + "1. There are students s1 and s2 and company c, so that\n", + "- s1 is assigned to c , and\n", + "- s2 is assigned to no company, and\n", + "- c prefers s2 to s1 based on his academics an projects.\n", + "\n", + "2. There are students s1 and s2 and companies c1 and c2, so that\n", + "- s1 is assigned to c1, and\n", + "- s2 is assigned to c2, and\n", + "- c1 prefers s2 to s1, and\n", + "- s2 prefers c1 to c2\n", + "\n", + "So we basically have a stable matching problem, except that\n", + "* Companies generally want more than one hiring student, and\n", + "* There is a surplus of Computer Science graduates in Boston area.\n", + "\n", + "Show that there is always a stable assignment of students to companies, and devise an algorithm to find one.\n", + "\n", + "###**Solution:**\n", + "The algorithm is very similar to the basic Gale-Shapley algorithm from the textbook. At any point of\n", + "time, a student is either hired by the company or free. A company either has available positions, or its\n", + "full.\n", + "\n", + "The algorithm is as follows:\n", + " * While some company c1 has available positions\n", + " * c1 offers a position to next student s1 on the basis of their academics (GPA) and projects\n", + " * if s1 is free then\n", + " * s1 accepts the offer\n", + " * else ( s1 is already committed to company say c(k))\n", + " * if s1 prefers c(k) to c1 then\n", + " * s1 remains committed to c(k)\n", + " * else s1 becomes committed to c1\n", + " * the number of available positions at c(k) increases by one\n", + " * the number of available positions at c1 decreases by one\n", + "\n", + "The algorithm terminates in O(mn) steps as each company offers a position to a student at most once, and at each iteration some company offers a position to some student." + ], + "metadata": { + "id": "Shd3N5-la32h" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the sample problem**" + ], + "metadata": { + "id": "PvVRKLu3cs9w" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Problem Statement: Stable Roommate Problem with Preferences**\n", + "\n", + "You are organizing room assignments for a group of n people. Each person ranks their preferences for potential roommates, and you need to find a stable room assignment where no two people would prefer to be roommates with each other over their current assignments\n", + "\n" + ], + "metadata": { + "id": "rfRT0wIlfV5O" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Input Format:**\n", + "\n", + "The input consists of the following parameters:\n", + "* An integer n (2 ≤ n ≤ 100) representing the number of people.\n", + "* A list of n elements, each element containing:\n", + " * An integer person_id (1 ≤ person_id ≤ n) representing the unique identifier for the person.\n", + " * A list of n unique integers representing the person's preference ranking of potential roommates (1 ≤ roommate_rank ≤ n)." + ], + "metadata": { + "id": "6Lz-qU-if-t0" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Output Format:**\n", + "\n", + "A stable room assignment in the form of a list of pairs. Each pair contains two person_id values representing a room assignment" + ], + "metadata": { + "id": "4sm4RWf6gQFs" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Constraints:**\n", + "\n", + "* The input lists are guaranteed to be of length n\n", + "* All preference rankings are unique integers within their respective ranges" + ], + "metadata": { + "id": "qsJulTughijw" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Input:**" + ], + "metadata": { + "id": "xfobtPliiD5M" + } + }, + { + "cell_type": "code", + "source": [ + "n = 4\n", + "\n", + "preferences = [\n", + " (1, [2, 3, 4, 1]),\n", + " (2, [3, 1, 2, 4]),\n", + " (3, [2, 4, 1, 3]),\n", + " (4, [1, 2, 4, 3])\n", + "]\n" + ], + "metadata": { + "id": "LaNDcxUDiDL0" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Output:**\n", + "\n" + ], + "metadata": { + "id": "6d4jAQKniJKk" + } + }, + { + "cell_type": "code", + "source": [ + "[(1, 3), (2, 4), (3, 1), (4, 2)]\n" + ], + "metadata": { + "id": "9CgGoGpLiNI5" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###**Solution:**\n", + "The Stable Roommate Problem with Preferences can be solved using the Gale-Shapley algorithm. The Gale-Shapley algorithm, also known as the Stable Marriage Problem algorithm, is primarily designed for solving the stable marriage problem, which involves two sets of participants (men and women) with preferences for each other. The Stable Roommate Problem is a different variation of the problem, and applying the Gale-Shapley algorithm directly to it may not lead to a correct solution. However, we can adapt the Gale-Shapley algorithm to solve the Stable Roommate Problem.\n", + "\n" + ], + "metadata": { + "id": "dGEZNHdFiTAP" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Algorithm**\n", + "Here's how we can modify the Gale-Shapley algorithm to solve the Stable Roommate Problem:\n", + "\n", + "* Divide the group of people into pairs, each consisting of two roommates.\n", + "\n", + "* Create a preference list for each person, ranking their preferences for their current roommates.\n", + "\n", + "* Implement the Gale-Shapley algorithm as follows:\n", + "\n", + " * Initialize all people as free (unmatched).\n", + "\n", + " * While there exist free people:\n", + "\n", + "* Pick a free person and let them propose to their most preferred roommate from their preference list who is not currently matched.\n", + "\n", + "* If the preferred roommate is also free, they become roommates, and both are no longer free.\n", + "\n", + "* If the preferred roommate is already matched but prefers the proposing person over their current roommate, they become roommates, and the previous roommate becomes free.\n", + "\n", + "* Continue this process until there are no more free people.\n", + "\n", + "* The resulting room assignments will be stable, as the algorithm ensures that no two people would prefer each other over their current roommates." + ], + "metadata": { + "id": "R9J2CuKOq7zs" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Algorithm Pseudo Code**\n", + "\n", + "\n", + "\n", + "```\n", + "# Initialize all people as free\n", + "\n", + "free_people = list(range(1, n + 1)) #For a total number of n people\n", + "\n", + "# Empty dictonary to store room assignments\n", + "room_assignments = {}\n", + "\n", + "while free_people:\n", + " current_person = free_people.pop(0)\n", + " current_preferences = preferences_dict[current_person]\n", + "\n", + " for preferred_person in current_preferences:\n", + " if preferred_person not in room_assignments:\n", + " # The preferred person is free, so they become roommates\n", + " room_assignments[current_person] = preferred_person\n", + " room_assignments[preferred_person] = current_person\n", + " break\n", + " else:\n", + " # The preferred person is already matched, check preferences\n", + " current_roommate = room_assignments[preferred_person]\n", + " preferred_preferences = preferences_dict[preferred_person]\n", + " \n", + " if preferred_preferences.index(current_person) < preferred_preferences.index(current_roommate):\n", + " # The preferred person prefers the current person, reassign roommates\n", + " room_assignments[current_person] = preferred_person\n", + " room_assignments[preferred_person] = current_person\n", + " free_people.append(current_roommate) # Previous roommate becomes free\n", + " break\n", + "\n", + "# The 'room_assignments' dictionary now contains the stable room assignments\n", + "\n", + "# Convert the room assignments to pairs\n", + "roommate_pairs = [(person_id, roommate_id) for person_id, roommate_id in room_assignments.items()]\n", + "\n", + "# Return the stable roommate assignments\n", + "return roommate_pairs\n", + "\n", + "```\n", + "\n" + ], + "metadata": { + "id": "JLTZ1Hy5qKj1" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Proof of Correctness**\n", + "\n", + "To prove the correctness of the modified Gale-Shapley algorithm for the Stable Roommate Problem, we need to establish two key properties:\n", + "\n", + "All people eventually get assigned.\n", + "The resulting room assignments are stable.\n", + "Let's prove each of these properties:\n", + "\n", + "1. All people eventually get assigned:\n", + "\n", + "* In the modified Gale-Shapley algorithm for the Stable Roommate Problem, we start with all people as free (unmatched). In each iteration, a free person proposes to their most preferred roommate who is not currently matched. There are two possible outcomes:\n", + "\n", + "* If the preferred roommate is also free, they become roommates, and both are no longer free. In this case, two people are assigned in one iteration.\n", + "* If the preferred roommate is already matched but prefers the proposing person over their current roommate, they become roommates, and the previous roommate becomes free. In this case, one person is assigned in one iteration, and another person becomes free.\n", + "* Since in each iteration, at least one person gets assigned or becomes free, and the algorithm continues until there are no more free people, it guarantees that all people eventually get assigned.\n", + "\n", + "2. The resulting room assignments are stable:\n", + "\n", + "* To prove the stability of the resulting room assignments, we'll show that no two people prefer each other over their current roommates.\n", + "\n", + "* Suppose, for the sake of contradiction, that there exist two people, A and B, who prefer each other over their current roommates. Let's analyze the conditions under which A and B can be matched with each other:\n", + "\n", + "* A proposed to B and was accepted by B. This means that A prefers B over their current roommate.\n", + "B proposed to A and was accepted by A. This means that B prefers A over their current roommate.\n", + "However, this situation cannot occur because both A and B cannot be free at the same time in this algorithm. When A proposed to B and was accepted, it implies that B was not free but had a less preferred roommate. Similarly, when B proposed to A and was accepted, it implies that A was not free but had a less preferred roommate.\n", + "\n", + "* Therefore, the modified Gale-Shapley algorithm ensures that no instability arises in the resulting room assignments, and they are stable.\n", + "\n", + "* **Conclusion:** The algorithm satisfies the key properties of correctness: all people eventually get assigned, and the resulting room assignments are stable. Thus, the algorithm correctly solves the Stable Roommate Problem." + ], + "metadata": { + "id": "4SUT1gfNq_qN" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "**ChatGPT assistance:**\n", + "* I have utilised ChatGPT to initially understand the sample example and how to estimate the growth rate of a sample function by understanding the type of function to make an educated guess. I also utilised it to learn more about theGale-Shapley algorithm and its various appllications.\n", + "\n", + "* After that, I utilised ChatGPT again to assist me in the formation of my own problem based on the sample problem.\n", + "\n", + "* Once I had my logic for the solution ready, I developed my algorithm for the solution and again used ChatGPT to understand if my solution had any flaws and to fix them to ensure reliability and completeness of my solution\n", + "\n", + "\n", + "**Challenges**:\n", + "* Challenges I faced include understanding the essence of the sample problem and making sure the new problem carries that essence throughout in its implementation. My proposed quetion also would not work directly with the Gale-Shapley algorithm and required a modified approach. Desinging the algorithm for the solution also proved to be an interesting experience as I understood that my initial thinking had many flaws.\n", + "\n", + "**Learnings**:\n", + "* In essence, I learned a the Gale-Shapley algorithm and it's different applications along with modifying the algorithm based on the problem itself" + ], + "metadata": { + "id": "RbmF22J0uyAU" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 4**" + ], + "metadata": { + "id": "fbxlxvT5y2j8" + } + }, + { + "cell_type": "markdown", + "source": [ + "One algorithm requires 16 log2(n) microseconds and another algorithm requires √n microseconds.\n", + "Which one is asymptotically faster? What is the cross-over value of n?\n", + "\n", + "\n", + "**Solution:**\n", + "\n", + "The first algorithm is asymptotically faster than the second.\n", + "The order of growth of 16 log2 n is less than the order of growth of √n.\n", + "Crossover point of n is 65536\n" + ], + "metadata": { + "id": "cqp9v3-7y732" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the Sample Problem**" + ], + "metadata": { + "id": "ke36oFxezhTF" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Problem Statement:**\n", + "\n", + "You are tasked with comparing the runtime complexities of two algorithms, Algorithm X and Algorithm Y, in terms of their input size 'n'. Your goal is to determine which algorithm is asymptotically faster and find the range of input sizes where one algorithm is faster than the other.\n", + "\n", + "**Input Format:**\n", + "\n", + "An integer 'n' (1 <= n <= 10^9) representing the input size.\n", + "\n", + "**Output Format:**\n", + "\n", + "A statement indicating which algorithm is asymptotically faster: \"Algorithm X is faster\" or \"Algorithm Y is faster.\"\n", + "The range of input sizes 'n' for which the faster algorithm remains faster. If there is no range, output \"No range.\"" + ], + "metadata": { + "id": "q3wk4LvazpDP" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Input 1:**" + ], + "metadata": { + "id": "Vg9ZqfPg1WUw" + } + }, + { + "cell_type": "code", + "source": [ + "n = 32\n" + ], + "metadata": { + "id": "BzfzP8CD1jSU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Input 2:**" + ], + "metadata": { + "id": "y_2ChYs31a0F" + } + }, + { + "cell_type": "code", + "source": [ + "n = 256\n" + ], + "metadata": { + "id": "i6sBNggr1j1P" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Input 3:**" + ], + "metadata": { + "id": "d8SNCcqq1fms" + } + }, + { + "cell_type": "code", + "source": [ + "n = 1" + ], + "metadata": { + "id": "FZJjjmzN1kvg" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Output 1**" + ], + "metadata": { + "id": "80Ds7NtN39YO" + } + }, + { + "cell_type": "markdown", + "source": [ + "* Algorithm X is faster\n", + "* Algorithm X is faster for n <= 1024\n" + ], + "metadata": { + "id": "q770thCOGdWG" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Output 2**" + ], + "metadata": { + "id": "ZrmuNgZQ4Q5i" + } + }, + { + "cell_type": "markdown", + "source": [ + "* Algorithm Y is faster\n", + "* Algorithm X is faster for n <= 64\n", + "* Algorithm Y is faster for n > 64" + ], + "metadata": { + "id": "tP1l_nahGiO4" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Sample Output 3**" + ], + "metadata": { + "id": "bC5B29Fx4SNf" + } + }, + { + "cell_type": "markdown", + "source": [ + "* Algorithm Y is faster\n", + "* No range" + ], + "metadata": { + "id": "1_nM54bSGmGb" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution:**\n", + "\n", + "To determine which algorithm is asymptotically faster and find the range of input sizes where one algorithm is faster than the other, we can use a straightforward approach based on comparing the runtime complexities of Algorithm X and Algorithm Y.\n", + "\n", + "\n" + ], + "metadata": { + "id": "PgcsgVU54fd7" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Algorithm**\n", + "\n", + "**Step 1**: Calculate the runtime complexities of both algorithms for the given input size 'n'.\n", + "\n", + "**Step 2**: Compare the runtime complexities:\n", + "\n", + "* If the runtime complexity of Algorithm X is less than that of Algorithm Y, Algorithm X is faster for that input size.\n", + "* If the runtime complexity of Algorithm Y is less than that of Algorithm X,\n", + "Algorithm Y is faster for that input size.\n", + "\n", + "**Step 3**: Find the range of input sizes for which one algorithm is faster than the other." + ], + "metadata": { + "id": "ARoX9NbH5HYv" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Algorithm Psuedo Code**\n", + "\n", + "\n", + "\n", + "```\n", + "#Create a function to compare complexity between algorithms\n", + "def compareAlgorithms(n):\n", + " complexity_X = calculateComplexityX(n) # Calculate complexity of Algorithm X\n", + " complexity_Y = calculateComplexityY(n) # Calculate complexity of Algorithm Y\n", + " \n", + " #Make if-else to return the faster algorithm\n", + " if complexity_X < complexity_Y:\n", + " return \"Algorithm X is faster\", \"Algorithm X is faster for n <= \" + findRangeX(n)\n", + " elif complexity_Y < complexity_X:\n", + " return \"Algorithm Y is faster\", \"Algorithm Y is faster for n <= \" + findRangeY(n)\n", + " else:\n", + " return \"Both algorithms have the same complexity\", \"No range.\"\n", + "```\n", + "\n" + ], + "metadata": { + "id": "kk65hssS5aFe" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Proof of Correctness**\n", + "\n", + "* We calculate the runtime complexities of both algorithms for the given input size 'n'. This step is based on the definitions of the runtime complexities of algorithms.\n", + "\n", + "* We compare the runtime complexities and correctly identify which algorithm is faster for the given input size based on the definition of algorithmic efficiency.\n", + "\n", + "* We find the range of input sizes for which one algorithm is faster using binary search. This is valid because binary search is a correct algorithm for finding boundaries in a sorted sequence, and the runtime complexities are continuous functions of 'n'.\n", + "\n", + "* The correctness of the algorithm hinges on correctly calculating the runtime complexities and comparing them, which are well-defined steps in algorithm analysis.\n", + "\n", + "* **Conclusion**: The provided pseudocode correctly identifies which algorithm is faster and determines the range of input sizes where one algorithm is faster than the other, fulfilling the problem's requirements." + ], + "metadata": { + "id": "lVL-moVR55LE" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "**ChatGPT assistance:**\n", + "* I have utilised ChatGPT to initially understand the sample example and how to estimate the growth rate of a sample function by understanding the type of function to make an educated guess.\n", + "\n", + "* After that, I utilised ChatGPT again to assist me in the formation of my own problem based on the sample problem.\n", + "\n", + "* Once I had my logic for the solution ready, I developed my algorithm for the solution and again used ChatGPT to understand if my solution had any flaws and to fix them to ensure reliability and completeness of my solution\n", + "\n", + "\n", + "**Challenges**:\n", + "* Challenges I faced include understanding the essence of the sample problem and making sure the new problem carries that essence throughout in its implementation. Desinging the algorithm for the solution also proved to be an interesting experience as I understood that my initial thinking had many flaws.\n", + "\n", + "**Learnings**:\n", + "* In essence, I learned a lot about how to calculate the Time complexity of algorithms and find out which algorithms would run faster" + ], + "metadata": { + "id": "rCSWi6lu6am2" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 5:**" + ], + "metadata": { + "id": "BDetQ45EsIFS" + } + }, + { + "cell_type": "markdown", + "source": [ + "A wall is built by using a grid of rectangular bricks. The total number of bricks used to build each row is\n", + "the summation of the number of bricks used to build the current row and the previous row. Note we are\n", + "in the process of building the wall with bricks. There is something asymptotic that can be analyzed\n", + "here. Suppose for correctness, that each row has a total number of bricks that is bounded by constant c,\n", + "and suppose that the wall will consist of at most n number of bricks. Show how to build such a wall using\n", + "the bricks which have length f(n), for a function f(n) that grows as slowly as possible.\n" + ], + "metadata": { + "id": "dbTthH7QsIFT" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution:**\n", + "\n", + " Suppose that to obtain n bricks, we need R rows. We write script as follows.\n", + "\n", + "Row 1=\n", + "\n", + "Row 2=\n", + "\n", + "…\n", + "\n", + "Row R =\n", + "\n", + "For i = 1,2,..R\n", + "\n", + " For j= 1,2,…i\n", + "\n", + " Add bricks j through R\n", + "\n", + " Endfor\n", + "\n", + "Endfor\n", + "\n", + "Now, the nested For loops have length bounded by constant c1, So the real space in the script is\n", + "consumed by the no of bricks in the row. Each of these rows in the script has length at most c2,(where\n", + "c2 is the maximum no of bricks c for a row plus the space to add new brick).So in total, the space\n", + "required by the script S = c1 + (c2 * R).\n", + " Recall, that n denotes the number of bricks required to build the wall, n is at least\n", + "1 + 2 +…..+ R. ½ R( R – 1). Hence this can be made into ½ (R-1)2 <= n, and so\n", + "R <= 1 + √2n .Plugging this into our bound on the length of the script, we have\n", + "F(n) = S <= c1 + c2√2n = O(√n)" + ], + "metadata": { + "id": "CXSFO9ihtH3Z" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Understanding the Given Problem:**\n", + "\n", + "In this problem, we are exploring a method to construct a wall using a grid of rectangular bricks. The number of bricks in each row is determined by the summation of the bricks in the current row and the previous row. The objective is to devise an efficient approach to build the wall using the least amount of bricks possible, with the constraint that each row is bounded by a constant, denoted as 'c'. The goal is to find a way to build the wall with a function f(n) that grows as slowly as possible, where 'n' is the total number of bricks needed for the wall. The proposed solution involves determining the number of rows needed to obtain 'n' bricks, and using nested loops to place the bricks in each row.\n", + "\n", + "The analysis demonstrates that the space complexity of the script is within O(√n), ensuring an optimized approach to constructing the wall while adhering to the given constraints.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "iXt1r-nNsIFY" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the sample question**" + ], + "metadata": { + "id": "-CEFLRensIFZ" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement:**\n", + "You are tasked with arranging a collection of books in a library on shelves. Each shelf can hold a maximum of c books. The total number of books to be arranged is at most n. Develop an algorithm to efficiently arrange the books using the least amount of space.\n", + "\n", + "\n", + "####**Input:**\n", + "* An integer n representing the total number of books to be arranged.\n", + "* An integer c representing the maximum number of books a shelf can hold.\n", + "\n", + "\n", + "####**Output:**\n", + "Return the minimum number of shelves needed to arrange all the books.\n", + "\n", + "\n", + "Example:\n", + "* Sample Input 1:\n", + "n = 15 (total books)\n", + "c = 5 (shelf capacity)\n", + "\n", + "* Sample Output 1:\n", + "Minimum number of shelves needed: 3\n", + "\n", + "\n", + "####**Constraints**\n", + "* 1 ≤ n ≤ 10^6 (total number of books)\n", + "* 1 ≤ c ≤ 100 (shelf capacity)\n" + ], + "metadata": { + "id": "eH-N4J9KsIFb" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "mJ3qByHasIFc" + } + }, + { + "cell_type": "markdown", + "source": [ + "1. Initialize the number of shelves (R) to 0 and the number of books placed (books_placed) to 0.\n", + "\n", + "2. * For i from 1 to n:\n", + "\n", + " - For j from 1 to i:\n", + "\n", + " - Place books j through i on a new shelf.\n", + "\n", + " * Update the total number of books placed (books_placed) by adding i.\n", + "\n", + " * Increment the number of shelves (R) by 1.\n", + "\n", + " * If the total number of books placed (books_placed) is greater than or equal to n, break the loop.\n", + "\n", + "3. Return the minimum number of shelves needed, which is R.\n", + "\n", + "Justification:\n", + "\n", + "The algorithm places books sequentially on shelves, ensuring each shelf is filled optimally.\n", + "The number of shelves is determined based on the sum of natural numbers up to a certain value, ensuring efficient use of space.\n" + ], + "metadata": { + "id": "BiUMu3ensIFc" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "6IDpaKFCsIFd" + } + }, + { + "cell_type": "code", + "source": [ + "def efficient_shelf_arrangement(n, c):\n", + " # Calculate the minimum number of shelves needed to accommodate n books\n", + " # with at most c books on each shelf.\n", + " return (n + c - 1) // c\n", + "\n", + "# Sample input\n", + "n = 15\n", + "c = 5\n", + "# Output: Minimum number of shelves needed\n", + "print(efficient_shelf_arrangement(n, c)) # Output: 3\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f71aef03-b215-4cc2-a8b0-818a319f4d17", + "id": "Wo3GHsVgsIFe" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "**To summarize the algorithm:**\n", + "\n", + "This algorithm helps decide between two approaches, Algorithm A and Algorithm B, for solving a problem based on the size of the input array. It calculates a \"crossover point,\" which is the array size at which one algorithm becomes more efficient than the other.\n", + "\n", + "This algorithm is designed to choose the most efficient approach based on the input array size.\n", + "It helps in optimizing the solution by selecting the appropriate algorithm to ensure faster and more efficient processing, ultimately saving time and resources.\n", + "\n" + ], + "metadata": { + "id": "dIAiKHdPsIFg" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - ChatGPT's algorithmic insights empowered me to make informed decisions, optimizing efficiency based on the given problem context\n", + "\n", + "* **Challenges Faced:**\n", + " - Creating a problem that maintains the spirit of the original example while adapting it to a different context presented a unique challenge. The initial example involved building a wall with bricks, and translating this into a bookshelf problem required ensuring the analogous elements made sense and were logically consistent. The challenge was in preserving the underlying algorithm while replacing the brick-related terminology with book-related terms in a way that felt natural and coherent. Striking the right balance to keep the problem challenging and engaging for the reader, yet relatable to the new context, required thoughtful consideration and careful rephrasing. Additionally, ensuring that the problem maintained a similar complexity and mathematical basis while being applicable to book arrangement involved creative thinking and problem design. This process provided valuable insights into the nuances of problem adaptation and abstraction, aligning it with the core learnings from the original example.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "* **Learnings:**\n", + " - Understanding and working with algorithms offers valuable insights into problem-solving and computational thinking. Here's a paragraph summarizing key learnings about algorithms:\n", + "\n", + " - Algorithms are the foundational building blocks of computational problem-solving, guiding us in efficiently solving a wide array of challenges. Through studying algorithms, we grasp the significance of optimized procedures, enabling us to find the most effective paths to reach desired outcomes. Key learnings encompass recognizing the importance of algorithmic complexity analysis, including time and space considerations, for evaluating performance.\n", + "\n" + ], + "metadata": { + "id": "3dL1Y35AsIFh" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 6:**" + ], + "metadata": { + "id": "tykHuhKAgIeW" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "One algorithm requires log2(n) seconds and another algorithm requires √n seconds. Which one grows\n", + "asymptotically faster? That is, which grows faster as n gets large? What is the cross-over value of n? (The\n", + "value at which the curves intersect)?\n", + "\n", + "\n", + "###**Solution:**\n", + "The second algorithm, √n. grows asymptotically faster than the second, log2(n),\n", + "\n", + "![psa assignment.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAewAAAEkCAYAAADtkQK5AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAERZSURBVHhe7d0HYFvVvT/wr6dkyRqW997xyB6EEJLAI7Tssh/zUTrZhQKvLaWFB7xCeV1Q2j9lUwiFMMsMgQwgJCF7ee895SlbliXL/t9zfEMSSBwlxMFX/n7e07Puudd5IbL11e/cMwJGFCAiIqIJLVD9SkRERBMYA5uIiEgDGNhEREQawMAmIiLSAAY2ERGRBjCwiYiINICBTUREpAEMbCIiIg1gYBMREWkAA5uIiEgDGNhEREQawMAmIiLSAAY2ERGRBjCwiYiINICBTUREpAEMbCIiIg1gYBMREWkAA5uIiEgDGNhEREQawMAmIiLSAAY2ERGRBjCwiYiINICBTUREpAEMbCIiIg1gYPuhGTNmoLCwUD0iIiJ/wMD2Q16vV31GRET+goFNRESkAQxsPzV//nyYTCZ2jRNNRCPAUL8HvXXtagPR4QWMKNTn5CemTp2KZ555Bnl5eQgPD0dQUJB6hoi+LcOeIfTWt6N+SxladpSjvbYdKSdmYdFtl6pXEI2Nge2HRGC/+uqr8isRfXvczkG07KlG3RclsO8qg1d5t42dlYnkGZmIy09FoMWAEL1OvZpobAxsP8TAJvp2DA8No6+lB61by1C3rQxdVc0wJMUiaWYGEmakwpQShcCQIAQGByFIeSAgQP1OosNjYPshBjbR8TPkdKOjpAF1WwvQvLMGw04PoqdlIHFGOqx5yQizGhAkQjokWHnHDYTD4UFtdRuq63oREhCEs8+bov5JRGNjYPshBjbROPIC7u4BtOxWqujNpWgrq4XRGoG46WmImpYGW0YsAkOVcA4MRHevG7W1vaio7FYedjTUdcMxMIj0ZBsSk02YmhuJU0/LUv9gorExsP2QCOqOjg6EhITgo48+koPPiOjoed0eOJrsqN9egaZtlXA1d8GclSi7uWNykhBiCUdXzxCqG/tQVduJuupu1NZ1AiNepKZFISEpEqlJ4crXcMTEhiNEdokHIFSpvHU6JdyJfMDA9kMisB955BFMmTIF8fHxCA0NVc8Qka88zkF0FjeiflsRWgprlbLag9hp6YjIy0SAKQLVbX2ore9CY3036psGZEWdkmpCqlI9xyebkZJkgc2mQ7ASyiHKIzg48MsH0dFgYPshdokTHYVhYLDHidZd5ajfUo6O8nroIiwIT01Avz4c9UoFXdPoRHN7H4JCRDhHIjnZivhEM5ISrbBF6pRgDpThPPoIRFAQw5mOHQa2H2JgEynsdmDXHiDSBsyaqTYeyOvxor+lG607KtCwowydjV0ItljQFWJEde8w6to9GAoAMjJikJJmRXJKBBITjbBFGREaGjwazKFBsms7KIgjvml8MbA1qry0HD+98ad45ulnkJGeobaOYmDTpPfFF8CddwI1NYDJBFx2KfA/98tTXpcHvbVtShVdgrqdtXDYe9ETokNtbzAa+gMQr1TOadlKQKdbkZRsQ1SMQYazTgSz8hABzW5t+jYwsDVosH8QH378Ia6/4Xp88sknyMnJUc+MYmDTpNauVNZPPw3c81tgaEh5lwuAZ958tNz8W5Q0e9BV2QCH043GAaAn1IK4rERk50UrFbQN0fERCNErwaxTAlqnBrRSPRNNBAxsDXrnnXcwe8ZsnLr0VHzwwQcHDWy32w29Xi+P33jjDTkAjWhSaGkFHv87cP8DagPQZk3Gp3MuQ31aHmzZsciemoK4VBv0VqV61ocqvyt7A1rMlVa/iWiCYWBrzOatmxESFCKnaol9r999992DBvb999+PrKzR+Z0irMPCwuRzIn804BSLkXSjdE8TWrcVI2HLGpy2/kUYhlzwKh9cXedcgMEH/gCPMQwhBh3ClEeoEtAcFEZawsDWmPMuOA/VFdUQc6yLi4uRmZmJF//5ImbMnIFgsZKSgl3i5M/Edu/dPS5UV3agstSO+vIWBLQ0wersQ+DQIMLio5EzOwl51iHoa0owEhmFkZMXIzAlhdUzaRoDW2MKiwqVamIA4mW7+OKL8ec//xlnfPcMuStXQODouxEDm/yJuA3d1eFCaYUd5WUdqK/qgLujB9EBThh6OgGPB4m5CUibl4qYjDgEWUwIMxvkfehAlxMIVj7IGsPVP41IuxjYWqS8ga1esxrXXHsNHvr9QzK4jUajepKBTdomA9ruRFlZK0rL7Kiq7sJQvxtx4QEIG+iCt7ENoRhB8pw0pE5PR1RaHHRWPfTmMISE6eQCJkT+iIGtRcOAvdOO6upqJCUlISYm5oA9rxnYpCUyoLsGlYBuQ1lJK6pruuAe9CA20oCokBGMtLTAWdsIU3goUmdlIiEvGZbESIRGhEFnNiJUhDS7umkSYGD7IQY2TWjKB86ebhfKyztQWt6O6ko7nM4h5YNnOGKjwmAc8mCgpg4DzS2wGEORNDUVkdmJMCfaoLeEQ2cyKJV0KEOaJh0Gth8SQW0wGGQ3+bPPPouMjAMXViE63hwON6qru1CuVNCV5Z3o6R1ERFQ44hPCER2hQ2jfAHrLa+Fua4fRpENMViysaXGwxKshbTGOhjTRJMbA9kMisO+44w6kpaVh/vz5ckAa0fHkcnnR1NiLsuI2FJfZ0WHvg8miR1ycCfGxVkSYQzDU3Yv+CiWkW9qhU8LYlhqHiNRoGOMs0FuNMqhD9Axpor0Y2H6IXeJ0vImpVh0d/Sgra0dJiV3uYBUQGIj4eKWKVgI4OjYMZkMIhpWQ7i1vgLOhTc5qiEiNRURSFAzxVhgiTEpIGxGsD1H/VCLaHwPbDzGw6Xjo73ejtrYHxUpAV5a3w9k3iKjocMTGmxATbUBklBHhYYEIdPShp6IOHRUNwNAwTMkxsCTFwBQfCYPNjDClmmZIEx0eA9sPMbBpPMgq2u5EeVmbDOnmph65nGdMtFJBx4mQDoMtMgwmoxK+ff3oLK6FXXl43W6YEqNhUippc3wEwiItSkiHj07BIiKfMbD9EAObjhW3y4vGxl4UlrSiorQdfQ43IqwGxMQplXRMGCKVitqqHFvCQzGshHRTYTU6Cmvg6R+EMd6KiKRohItKWoS0zSSXBSWio8PA9kMiqGNjY2E2m/HII4/IwWdEvuoVI7qrulBa3Ia62i4MewMQHWtAdLQBUdEmREbqYbMZYFZC2uMYQGtBjfKoxEDPAIzRVpgTbDDH2WCINcMYaUaIkevYEx0LDGw/JAL7Jz/5CVJSUrB06VJYLBb1DNFBeIHOrgGUlHWgtKQNrS0O6HUhSgWtVNGxRtiiDLKrO8IWBqNRB7fDifbierTsqYSz1QGd1QirUk2HK0FtiLUpoW2BToQ0FxwjOqYY2H6IXeJ0OGJ1Mbu9H8VKQJcpj87OAYSbwhAbHa5U0WGIiTYiKsqohLQeOn2wEtIudFY1oXl3BfqauxASpoR3rBLSSkCb4iJgilVC2mzgsqBE44iB7YcY2HQwQ54htLY5UFjchvKSTjgcgzBbdIiKNCAm1oSYGDFwzCjbQkOD4B1wo6fOjuY9VeipacJIYJAS0Eo4KwEt7kuL5zqLAUHB+5bFJaLxw8D2Qwxs2kuEdFuLCOl2lJe1o6/fA7PVgOjIcCWgla/KQywJajbrERysVMdDXjhaOtFSUIvO8gZ4XEMwiPvS4n50vKimI+XgsaDQ0a1ciej4YWD7IQb25DbkAVpbelEsRnaLkHZ4EG4JQ1SUAbFKJR0rR3iHw2TWjfZgDwPOTgfaS2rRXlQLZ48TBrNRqaAtCE+IhCk+CsZoM4K56hjRt4qB7YdEUGdnZ8NqteKBBx5AcnKyeob8lhK67eKedLEdZSXt6OkZQHi4DjbR3a2Ec1yC8ogzwWRSQ1rh7nehq7IZrbur4WjtksuAGqOUSjrWClNilFJN2xBq4ghvoomCge2HRGBffvnlSExMxAUXXACbzaaeIX/T3TWAsnI7SpSgFoua6MNC5TzpuFgD4hNFNW2CeW8lrRBd5H1N3WgrqEZHdROGvcMwWsMRHmOFOTkaZqWi1lsMwH7btRLRxMDA9kPsEvdvYknQmppOFBWOTsEKDAqERQlZMU86IdGChAQzrBa90q5+g9rlbS+rh724DgM9ToQolbPo5jYrlbQ1MVpW1oG8L000oTGw/RAD2/+43V40NztQXNSGqupODA0Nw2LSITomTAloKxKVoBZTsIL3G7HtdrrQVdOGtj216GuxIygkWKmmzTCILu9UsUxoJEKNevVqIproGNh+iIHtJ5TKuLOzH6VlHSgp6UCvw4UwQxBsEWEyoFOSLUpVbUSobr/K2OuFo60LLUW16KxshndwCGHhSjWtVNDmlFhYk2Kgt4YD7PEm0hwGth9iYGvbgNONhroeFBa1o6m5F6Jv2ywWNYkzIDXVjMQEM4zGA0dsu3qdcmGTtqI6OO3dCA4Nhd5mhiXJhgglqI0xVgSFckcsIi1jYPshEdRz5sxBZGQkfvGLXyAhIUE9QxOWUk23tvWjqLgd1ZV2uAe9CAsLRkRkGJJTbUhJscr70vuPBfO6vehr7kB7UQ26aluU4yEEh4vpWBGITI+DOTkGOhO7vIn8BQPbD4nAPuecc+QGINdccw2io6PVMzTRuAbcqK3pVqppO5pb+hAQMAKbVY/EJAvS0yIQE2tAqO7AylhW0xXNaBUDyDp7ERwcIBczEd3d1ox4GKIsCAphnzeRv2Fg+yF2iU9wSjVt73CitLQdVeV29PV5EKIPQVSMAZkZVqSlRsBkPrAy9g4p1XRLJ+zFNeiuscPj8iLUEDq6hWVmvBLW0RxARuTnGNh+iIE9MXk9XjQ29aBwTzvqG3pHR3qH65CUbEHGlEi5M5ZYw3t/gw5xb7oFbSUNcHZ2IygA0JvDYU2NR6QS1MYoE8C1vIkmBQa2Bq1es1p54w6Cy+2CyWjCnLlzEBa2b0UqBvbE4pTzpntQUtSC1naHUmEHIioqHBlZNmRl2mCxKJXx/ptceZVquq1bhnR3dTM8A24Eh+pgjDMjIisR1uRo6MK5AhnRZMPA1hjPoAd/+NMfMG/uPAwPD2PZsmX4/cO/R1JSknoFA3ui6Ol2obzcjtJiO3q7BxGsC0BsvBF5ObFITrZCbzhwoRIxb7q3vh0dxXVKYPcoFfiIEsw6RKTFImpKkpyaxWqaaPJiYGvMkHsIm7dsxqzZs9BU34Rrf3wt/vnPfyIzI1O9YjSwTz311C8Hm91www1yABodB8NAR4cTJeL+dEUnevvcMOhDkJ5qwZT8aMTEGg9Y3ERcP9DVi47yRnRUNcPVN6AU24FKOFsQOUWpppWw1oXz3jQRMbA1qaGuAa+/+boSCiWIjorGrbfeiqioKPXsaGAvXrz4y8C++eabGdjjzOsFWtWVyOrrezDg8sBs0iE9KxK5OdGwRRzY7S2mZDma7bCX1KO3sR2eAQ+CDXpYUmMQnZMs1/bmSG8i2h8DW4Pqaurw8vKXsadgD+Jj4+Vc6+iYfVO32CV+/HiHgMbGHhQUtKO5sRfuQbecO52XH4PMzEiEmw5c4MTTN4iumla0lzagv70Lw0Nu6K0mRCkhHZmdhDCrUb2SiOhADGyN6e3pVaq3AbkoStGeIvzgxz/A8uXLkZWVpV7BwD4e5NreTQ4UFXagQQlsl2sIcXFGzJgeg9Q0K/Rh+82dVru97ZXN6KxswWBHL8QvnTnBhuipqbCkRCMkTDd6LRHRITCwNaa+ph6r1qxC/tR89Dv68dLLL+H++++XW2nuxcAePyKoRUUtlg1tVQLb7RpGbLwJM2fFITnFfOC0rCEvelu7YS9rRE99G1w9TgTqQhCZHoP4/DS57zQHkRGRrxjYGtPV2YWPP/4Y8Qnx6HX0IioyCjNnzoRev29gEgP72BNd301NvSgobFUq6i64Br1Ijrdg9qx4JCSbEbLf/Wavy4PeRjs6yxrQ26xc2++Czhwm701H5Saz25uIjgoD2w+JoD7vvPMQFxeHq6+++oABaXRkRgeT9aK0uAM1td3oc7qRlByOOXMS5L7T+wf1oGMAPXWt6CpvQl9Ll5yCZ4qLRMzMNFhTY9jtTUTfCAPbD4nAnjVrFmw2G+666y5u/nE0hoG21j4Ul3SgutoOR68bcQkmzJ2XiOQkJaj36/oe6HSgs6oZXZXNcNp7MOIdkfel42ZlwZQYydHeRHRMMLD9ELvEv5nOzgFUltlRVtoJu70f0XEGzDshGampVuh0avgqlXd/Rw86qprQrYS1s70bgUow27KTEDc9C+HRFu45TUTHFAPbDzGwj05/vwfVVR0oLGiV96ttkUZZUWdm2hC2d9T3kBeOth50ljeju65FCe1ehBj1iJ+Wiuj8VOgsvD9NROODge2HGNhHZnDQi4aGHhQWtqGmuhMhIYGYPSdB+feLhck0et9ZLnTS2oWeikZ017ajTwnqsAgDEmZPkSuShRh5f5qIxhcD2w8xsH00DDS3OJSgtqOqsh2DLg9y8uIw74QE2Gyjm2t4Bz3oa+5CR3kTOuvscHX1wBxrRfy8HLlsaMj+862JiMYRA9sPiaC+8sor5dzs888/HxEREeoZ2qu3x4XK8g4UFLWhpaUfmZkRWLQwBTGxJrmEqMflhqOxQ4747qm3Y6C7D+GJUUg6IRvW1GgEhTKoiej4YmD7IRHYGRkZsFqtePDBB5GcnKyeIbHwSV1dNwr3tKCisgO2qDAsOjkdaWkRcorWkBLUYg51R1kDuuva4O51KZV0HBLm58CcaEMQFzohom8JA9sPsUv8IIaB1vY+FBfZUVjcimHPEE44IQnTZ8TBGK7D0IBSUTfZYa9olntQD/Y6ETklAcnz8xEea+OIbyL61jGw/RAD+0BO5xBqqrqwfUcT6ut7kZsThUWLUxAdYxwN6uYOdJQ3o6uqCYMOlxLUSUg+MVcJausBO2wREX2bGNh+iIE9alhU1a0OuZPW7t3NMBpCceopacjMsik/+F51MJnYkKMBrt4BROWIoM6TW1syqIloomFg+yEGtphT7UaVqKq3N8qlRWfPTMD8BckwGULk9KyOyiZ0lDXB1dWPyLxEpC7Ih1EsdsKgJqIJioHth0RQX3/99XKw2WmnnQaz2ayemQREVd3mwK5dLdi5qwkWsx6nL81ASpIZzo5e9FS1oL2sHv12JaizlaBeKO5Rs6ImoomPge2HRGBHR0fDZDLhscceQ1pamnrGvw0ODqGhpgdffFGHuoZezJ2XjBNOiEewewDdlc1oLa5DX1sXYqYkIOXkGaODyRjURKQRDGw/NBm7xLu6B1BU2IbNGxoQZgzGd5ZOQYwlEL31bUpQ18hdtCLSE5CxZBbMCRz1TUTaw/qCNG1oaBiNDd34ZG0VVq2uRkZmJM4/IxPmQQdq125H+YcbMTzkxfQrT8f0y06BOZlhTUTaxArbD02WCtvp9KCyogMbPq9GX+8gFp2UiuTIYHSV1qO1oBqmSCPST5uFiKwEBIWGqt9FRKRNrLBJk7q7BrD5iwa8804xggKCcM4pKYgY6ELJu+tgr2lE9jkLMOtH5yAqP41hTUR+gYFNmiLmVre09GH1qkp8urYceanhWJgRiu4te9C0rQRp86dgwY/PQvK8TG7MQUR+hYHtp7Zt24Z169ahv79fbdE+j8eL6uoevP1WGQq21mNhtgEJfa1o+nwPLAnRmH/dechYOg86S7j6HURE/oP3sP2QuHcdEhICg8GAF198EZmZmeoZ7XI63agss+ODd0ow5HBiTowXoZ12WNPjkH3GiTAnRgHB6sVERH6Ige2H/G3QmdgKc8e2eqx6qxDxoV4kBPYiMioMOWedgMjcFG51SUSTArvENaixqRHNTc2ob6hHW2sbhoaG1DN+oq8f6O4WfeDo6hzAZyuKsXLZRqR52pGt78P078zGCdefj5gZmQxrIpo0WGFrjMvlwn3334e05DQMDA6gp7sHN950o1zZbC9NV9h1dcBnnwP2dgxNn453igNQs60SCcFO5C6eiqwz545uzkFENMmwwtaY1pZW5UULxAUXXYAfX/tjvP7v19HV1aWe1bh+J/Cb3wI/+THw89vQf+4FCF/+PGZlhOE/fn4hpl9xKsOaiCYtBrbGpKal4ncP/g6xMbEoryhHSkIKQg8yz7i8vBx79uyRD1GVa0JBAVBcDLgG5KHF5cCi6RFY/F+LEZufjKAQLlFGRJMXA1uDhoeH0dHagXffexe3/ew2xMTEqGf2ueOOO3DZZZfJR53oZp7gvENe9A24MTg8gi/v0YiR7hnJCDFxmhYREQNba5Q0a6pvwutvvY5LL7sUp5x2CsLCwtST+7zzzjsoKiqSjylTpqitE5Dy3+Pud6G9uA6rVlahJCgWgynpQGIisOhkYMkiINKmXkxENHkxsDXG0e3Aw39+GDNmzJDzrGtqa+B2u9Wz2iI25XC2O1C+Ygc++uPb2FHWh/r/fgiul5YDL70IvPoaMP9E9WoiosmNo8Q15v0P3sdfH/0rAoMDERwcLMP66SefRnJysnqFNkaJe5yD6KpsQcHb69Fc14Udg+E46bwTsPQ7mbBadOpVRES0FwPbD03kwB7xDmOwbwBVawtQuWobkJCADU0BmHfqFJz+nXRYLHr1SiIi2h+7xP1US0sL6uvr4fF41JZv35Dbg97aNmx64l3UbCmG5dSTsKknDPOWpGPp0jSGNRHRGFhh+yFRWbe3t8su89WrVyMvL0898+0YGR6BZ2AQdVvKUfb2ekTlpUA/NRevvVuJmdNjcfpZ2bDavj5wjoiI9mFg+6GJ1CUuBpb1dzpQ8sY6tJc3Ivd7J8ETE4MXXtiD/GmxOOvsbNhsBvVqIiI6FHaJ07gZcg+hbXc91v/hLTj73Fh46yUw5WfipVcLkJkbg++eybAmIvIVA5uOOdFp43G5Uf7hDmx+9kOkLszHguvORmCEFcte2I4YqxFnnJ6B6CiGNRGRrxjYdEyNDA/D2dWHTc+sRO3GnZj34zMw5dx5CAwLxavLd8E5MIyzv5eLxCSz+h1EROQLBraf6u/vh8PhgNfrVVvG37Dy/6u7sg3r/u81BAy4cPItFyJhVrryUxaADz+oQHVFG877Xh5SU7lyGRHRkWJg+6klS5YgNjYWxWIzjfE2Mjq4rGZ9Adb9+RXEz8rEnB+fDVNCFIaHR7BxQy0++6wM512Qh7z8KARxDw8ioiPGwPZT27Ztg9PpxLRp09SW8SHuVw8PerFj2WoUvLIOc644A9MuWIgwq1GeKyuz49U3inHWmbmYPTsRIdxxi4joqDCw6aiJQHb1uvDJX16BvaIRi2+9FEkn5yFIHyKrbnurA089vQ1LFqdi3okp0Il2IiI6KgxsOioirB1Ndqz93TKEhhiw8KYLEJETC6gF9MjQCJ57fodS4Ufi1FNSYTZzfXAiom+CgU1HpaOkGZ/97hUk5KVg7g+XIjzOqp4Z9eobhRhSQvuUJRmIjDSqrUREdLQY2HTEmjaWYsNfXkXG6XORd/ES6CNMCAgIUM8C27c2Y8vmRnz3zDykpNgOOEdEREeHge2nZs+eDZ1Oh4KCArXl2Ch7dyM2vbgCeVcsRdZZcxFq0h8QyB1tDvxr+S4s/U4G8vIiEBTEsCYiOhYY2H5q48aN6OrqQn5+vtryzRW8/ClKV2/D3B+fg7SFuQjRhx5YPQ8Bzy/bgfxcG+bOjYfBEKKcV88REdE3wsD2U3q9XglMAwIDj81LXPDKZ2jcWoYFPzgTSdPSEBwa/LWu7g8/KsdA3wgWL8lEdLSRXeFERMcQA5sOa8dLq9GwrQRzvn8GIvMyEBjy9bCurXZgzZoqnPIfqUhJsTCsiYiOMQY2jWnHi6vQsrsSc//rTETmJilhrfzIfDWMh4BXXtmF2bNiMTU/GqGhXByFiOhYY2DTIe1cthothQ2Ye+VZ+4W1enI/760sxvCwByecmARrhIHVNRHROGBg+6lvupb4jhfWoLmoHnOuXoqovMRDhnVLYx/Wrq3FSYtSkZRsQWAgw5qIaDwwsP3U66+/jh07diArK0tt8d3OV9aitawOc644DdFTEg4Z1sKbb+xCfk4E8nKjodMFq61ERHSsMbD9VExMDBISEhAScmTrd1es2IzGbdWYeeGpiM4RlXXQIcN665Y6NLcN4MST0hAVxVHhRETjiYFNX6rbUITiVduQ970TEZ0/dlgPDgzig3fKsGBBMtLSrAgK4o8SEdF44rusxvR29eKfz/5T3qOuqayRu2IdC50ldSh8ewOmnnUikmZnIkgffMiwFj78uArhNj2mTouBwRCqthIR0XhhYGuM0WzE+Redj+bmZrhdbrX1m3G0dGDbiyuRvmAaEublIMSoG7N7u7XVgU0b63HSiWmIj+dAMyKi44GBrTFBQUGwWq2HvV987rnnIicnRz5KS0vV1q8bdA5i5/MrEZmdhOSFOdCZDz8ta8X7pcjMsCJDeYSG8keIiOh44Lutn3r00Ufx1ltvyUdqaqra+nW7X/0M3qBQpJ0yG2FRFgQcplquruxCmfKYOz8ZUVEi3NUTREQ0rhjYfiozM1Nu/CEeYl3xg6nfVAp7eRNyzpwLS3I0An0YOPb+imLk50QiOcmMoGD++BARHS98x52k+po7UfzmZ8heMg1RmfFK+B5+OdHyojY0tzgwY3Y8rNYwtZWIiI4HBrbGOLodWLlyJRwOBz5e/TGaG5vhHfKqZ300COxetgpRWQmIn5WJ4DCdemJs739UgWm58UhO4DQuIqLjje+6GhMWHoZ58+ZhxYoVuPCSC2GLtvnUlb2/0o83weUaRMopMxEWZTrsIDOhqLgdHZ0uTJ8ZC7PVt4AnIqJjh4GtMcHBwYiMjMSsWbPkSmY63cGnYF1xxRVYsGABKioq1JZRXXVtqPq0ANmnzUZEaowS9r7trLX24wq5E1eiuHfN6pqI6LjjO6+f+uUvf4k///nPiI+PV1sUQ0DxGxsQnZ+KyNwUBIX6tmxpRVk72lt7MW1qNMxmVtdERN8GBrafEhX4woULYTQa1RagZnMRBnt6kbowF3prOHydk7X200pk50QiPsHE6pqI6FvCd99JYrB/EOUfbELKgjxYk6J8vu/d3NCNmqpeTJ2eAIuFI8OJiL4tDOxJovbTXTCYjIiemobgMN/X/t64sQFJKVbExZsQzHnXRETfGr4DTwLu7n7UrN2FxJPyEBYtVjPz7WXvd7ixdUczpk8X864NaisREX0bGNh+6rrrrsOZZ56J6upq1K4rhDHGDFtWPIJ1vu+PvX1bE6wROiQnm6DT+TaanIiIxgcD209dddVV+NnPfgZzmBk16/YgdUE+jDazT3OuJS+wfl0tZkxLQGQk1wwnIvq2MbD9lNgv++yzz4ajpAEhFhMs6fEIOoLquqi0A063B2npFhgMvn8fERGNDwa2PxsCqtbsQPK8LOhtvk/jEjasr0VWVgSiowzc75qIaAJgYPsxe3k9PJ5hRGTHI1jv+8jw3m4nKsvaMTU/FmbLwXf6IiKi44uB7cdqNhQjOjcJYREmn0eGC7t3tyEiUofYuHCEhHCwGRHRRMDA9lcuN+wF1YifloHQ8COrkjdsqENuXgyrayKiCYSB7ad+8eu78Pt3n4QzbBhBwcFq6+E1NTjQ2e1EeqYNRqPv3ehERDS+GNh+Kn7IKEeJmyMswBGMGdu6vR5JSRZERxq5bjgR0QTCd2Q/NS0sBVf855WIsNnUFh94xWIpDcibInblYnc4EdFEwsD2U95BNwxxFgSF+N4dXl/fhSH3MJJSLNCH+f59REQ0/hjYfsqYGIkQow4BRzCHevuOJqSmRSAiIoxzr4mIJhgGtp+KSE9EsO4IBo15gZ0725CZFQWTSac2EhHRRMHA9lP//Og1/PwXd6CxsVFtGVtLax8GBoaQkGiGTs/ucCKiiYaB7aemzZ2BqdOmQqfzrVouLGpBQpIRFouO3eFEk9Tg4CDWrF2jHtFEw8D2U1dddTVuueUWREVFqS1j27GzCVmZVphM2px7/fzzz2PHjh3q0eTw4YcfYsWKFerR5LBz5048++yz6hEda0NDQ/Lf+JsYGRmB2+WGs8+ptnyduEacF9eR7xjYfsYz6MHw8DCCDWLAmW8vb0+XC62tvUhJsSIsTJuB/cEHH6C8vFw9mhw2bdqEL774Qj2aHCoqKvD++++rRzSeRKgO9A3gi01f4PP1n2Pr1q3wuDxfnnM4HNi0cRM2fbEJpWWlsjIX7aJKr6qqQqD6/iPej7Zv3Y6Ojg75vKy8DMUlxXJAbGVVJTye0T+TDo+B/RV33XXXEf0A/fa3v4XTeehPkl91//33o6enRz3yzUMPPSR/2H3hdQ4q/2dk9JX1sWf7sb/9FQHDDlitBp8WS/n73/+O6upq9ejwnnzySZSVlalHvhFVVGFhoXp07L3yyivyDchXb7zxxhGF49tvv41169apR74RHzrWrBm/7si1a9ceUdh9/vnn+Pe//60eHZ7493nttdfUI99s27YNL7/8snp07BUVFeGZZ55Rjw5PfOh74okn1KPDq6mpwd/+9jf16PAaGhrwyCOPqEcTm6i2d+3Zhe7ubuj1etg77Ni9Z7c85/V65XNHr0Oe67R3YsvWLV8GsnfEC71h31oOopLevmM7Wlta5WsibtXpw/QYGh5CSXGJehUdDgP7K/7yl7/IH1RfPfbYY/ITpa8ef/xx9Pf3q0e+eeqpp+QvjS+GXIPKp9xh9cg3b/17OeLig2EM9+1+97/+9S+fB7MJr776Kmpra9Uj37z11luorKxUj449EY5H8oHgo48+wq5du9SjwxPBK8LoSHz22Weyah4vmzdvxqeffqoeHd727duP6APE7t275b/TkRBv3uNZMYtK780331SPDq+urk7+vPpK/B6I3wdftbW14YUXXlCPJjbxPih+R2bPmI05s+YgPycfO3ePdpeLwC4qLMLsWbMxfcZ0pKWmyXYR2AW7C5CamiqPhYCAAORNzUNdbR12bt+J7IxsZGZkynPi+3bu+GZd8JNJwIjow5gE7r77bvXZ2B5++GHcfvvtCAkJUVvG9qc//Qk33ngjwsLC1JaxPfroo/jhD38Ik8mkthyeqGivvPJKREREqC2H5up14vmX/omLL7kE0dHRauvYRAVy4vxTMSUnDaGhh9+d65///CdOO+00JCcnqy1jE29oJ510EtLT09WWwxNvmrNmzcKUKVPUlrGJN+Xc3Fzk5+erLWN75513kJaWhhkzZqgtYxMBHxcXhzlz5qgtYxPBZbVaMX/+fLXl8EQ4impl4cKFasvYRAUvfn2XLFmitoxt48aNGBgYkK+dL7Zs2YKuri5897vfVVvGJsYQNDU14ZxzzlFbDm/Pnj0yVM8//3y1ZWzFxcUy5C+++GK1ZWyiYhYfPC677DK1ZWyiYl6/fj2uuuoqtWVs9fX18nX7/ve/r7aMraWlRX5A+dGPfqS2HFxMTAxuvfVW9ej4EcXEE08+gdt/frv8WXnmqWdw8w03A8HKe0ufC089+xRuufUWWaQ88fgT+NlNPwOUt0q3242/PPoX3H7b7XjiH0/g5luU71GJn9F+Rz+WvbRMeX8JxQ+v/SGgvs2Ic48+8ihu+/ltow00pkkT2A888ID6zP+Jql+8QYlf+sNpaexFSXk7Zs9OhIW7cxFNCGKw6A033KAeHT/7B7bL5cK/XvoXzj7rbETHRqOhrgGr166WBYcI7BdffBHnn3M+ImMj0dzUjGUvLxsN7CeUwL55NLBFvIju8I1fbFTCJgC19bU473vnfVl8yMBWipjbbmNg+2LSBPZkMnXqVFmhiq+Hs3JFOSoq7bjk0mmIjfW96ici/7N/YIuxPNu2b0NnZydsNpv8GhsTi7lz58ru8q3btqK3sxeR0ZEYHBjEhs0bZK/A66+9jnPPPRemcBOGh4blve3evl6cfNLJ2LF9Bwa9gzjtP06TYS0Grr37zru46mrfejQmO97DnuQKS+1ITbPBYOBWmkSTnbgVeOKJJ8rnQUFB8kO/6KkLUP4nIT7hy1tO4ty0qdMQGRUpg1ckSbgxHIEBgZg+bTpqamvkdUKwLhjz5s1DmDFM3u+2WCzqmdFbEOLWF/mGFbYf8rXCHhwcwq9/vRpXXz0d06fHIjj48PeviWjiGPYOw9HrQlePb/OZlTyF1aI/Jre/xMAzMQbBM+RBe3u7rKgXLVoku8BFYKckp8iQPhgROy6nSw7yy8jIQIjOtzFDkx0D2w/5Gth1tV14/O+bcN0N85GWfgTbcBLRhDAw4MGG9dVYt6FJbRlbaEggTl2choWLUtSWoye6xcVULe+QV86pnpo/VQ6mFZEi1oMQ5w3hBvXqA4lrBvoHZEXPsPYdA9sPiaA+88wz5ajma6+99pCjxdesKkdRUTsu+c/pyrXavH8tVvtqbGpEcEgw4uPiMWf2HJ9Xd9MKj9uDhvoGeT9RjMw/cf6JsgvSPeiWC4l0dnXKqTNmsxlZWVk+z1iYyEQItLW2YduObQgKDMJZZ5715Q08Md1v1epVch6v6IYVP++5ObmjJyeZvr5BvPNOEd55z7cpkHp9MC45Pw/nnp+jtuwjAra25simXx4LYmZEYlKiekRjYWD7IfEGJu4ZieC68847ER8fr5450ON/34jYBBuWLk2Dxay9HbqGPEN48MEH0efskx9OUlJSsOjkRfK5PxHVigip3//f75GdmY27f323nBaza+cuubiJLdIm7ym2t7ZjwcIFclCQ1onXtqmxCU8/8zSqKquw7IVlcmqR6AIW89Wfe+45zJw9U35IET/rs2ZOzvugHo9X+ffpRFWNb+s0iIWRsjJsyMj8+hRREdhlpUe2wNGxID5gpmf4PuVzMmNg+yFfusSV303ljf8DpbqehZkzYn2afz3R9PX2Yfny5ejs6YTZYsbsmbPlf7PRaFSv8C/33HMPggKCcO8998rAfurJp2Tvwk9/+lNZhT719FNyusxNN92kfof2idf3jdffwKsvvyoDW9wf3bZ1G1Z+vBJxiXGyV2XhSQt9XnOASMs4SnyS6ugYwMjQCKJsek2GtSC6imVl2d4uF694/rnnUVkxfqujTTRt7W2y4oyKjEKELQLeYS9a21rVs/5J/DeKwU5ujxLc27bhlZdfwcoPV6pnifwbA3uSqqloV6oTC/R67Q740Ol1cgrKnbffiV/e+Us5MlVsJjBZyM4x5X/FVJq9Gy34e4dZUHAQ0tLTcO011+J/7vkf5OflY+VHDGyaHBjYk1RFlR1xiVbow7Qb2N2OblgiLLBYLcjJzZFV5ohIsElCdH8HBgfKWwI93T0yuMUCF/5MrLAlNoyIS4iT3eBTcqZMqtecJjcGtp96/fXX5aYhYnWigymv6lICO1yOGtUqMXL641UfY/OWzXJ6SV5+HlJT9m064C/EAKyW5ha5W5Ldbpc7Hom2mTNnwmQ2YdPmTdi8dbOcBzt3tvYHnAlilLjYoU6sTd7b2yvX7Ba3QMRzsUGKGCVeUFiAAdcAFi9erH4XkX9jYPspsbOU2OzhYFt/DjiH0NHmQnRUGEJDtfsjkJyUDL1OL6c1iYdY81hsAOJvxA5IYgnHnJwcWVE6+hyybfbs2XJzERFkYqOG2XNnY85c3zYnmehE176z34nIyEgsPHkhunu7ZYiLUeFixS0R3OLDS2JiIi688EL1u+ibEsuRFhQUqEffnPg5ra6qljt7FRUXyW12xTKmdHQ4StwPHW6UeFVlN558chOuFwumpB1+BzAimhz2X0v8aIlI8Xq8coCgWB/hs7Wfyf2xRXkobmnERcdhzrw5ch0BMWhUXEO+YYU9CdXUdiE+0azpAWdENL5E8IppdOUV5SgtLZUDOsWtmL3nxG5eFWUVqCivQFNzk7xFIdrFfG5xK2PIPSTHVUydNhWnf+d0LD1tKebOmov1G9fLP0P0DIm59uJ68g0DexKqrelGfJy4f821w4no4MT0ObGSnlgvXGzSIb6K7m1BdHWL7u3CgkLU19WjsrwS73/wPoZHhuV4g/bOdhjNRrlkaUycus3vCBAwHIAwXZhcmc9oMqLN3iavJ98wsCeh+vouxMWaoOcavkR0CKLy3bJtixzIePrppyM/Nx8bN2388pyYBz9v7jyc8h+nICkxSbaLIN++fTsy0jPk8V6i8u7u7pZ/nhh7sZfY+GPLF1vUIzocBrafWrlyJV577TX09PSoLaM8bi9a2wcQERmGEA0POCOi8SVC1tHjQGpiqlxJLyUhBT1d+95PxLnEhES5BkBisroWuFJFt7W0ySmHe4k/R7wP7dy+c3T7zZnTZbuossV1La0t8pgOj+/YfmrFihV4+eWX5afa/dnbnHLHnvDwELmuMBHRoYTqQuUIfdHV3ePokYsV7SXOidkLMth7HWqrUn2P7Lsn/WVY79yJvv4+LP3OUuh0B+5bsP/1NDa+Y/upRx55BG+++SZSUw+cl1zT4EBcrAE6jS5HSkTHhxjBnZ6Zjp0FO1FVVYXC0kJk52TLc6KqzszOxO6C3aiprpH3sEX1LFhNVjkgTRBd5Fu2bMGe3XuQlpGGxpbGL3cEE2EurrOarfKYDo+BPck0NvUgJsaofMrlVAoiOpAI6b33n4ODg+U9ajH9SowSF93dJ8w74ctz4nm/sx/lZeVwDbpg0BvkILMpeVMOGEjWae9EYkoi6urqUFxUfMCOYHX1dciflq8e0eFwHrYfGmse9l8fW4+s1Ggs+Y9UhJu0t6UmEU0MonpubGyEZ8gjA7qvr08uXuRyulBSVoJp+dMQcoiBrSJ2xLQuMRVsau5U6Ax8L/IFK+xJprHRAUuUESGhrLCJ6OiJaV8icMXKaH2OPpy04CQ5kExv0CNvSh5cA6Pd4ociVjxjWB8ZBrafEsuSfvzxx3JQyF5utxddPS7YIvQICeE9bCI6eiEhITjrzLPwvfO+h3POOefLjWdkaBv1MFlN8vhgxDXiPMP6yDCw/ZTY+OOhhx6Se0Xv1d42AJMxFGGGAKi7MRIRkUbwbdtPPfvss1izZo1cmGCv9mYHYmwGhLK6JiLSHAb2JNLY2ouoaCWwef+aiEhzGNgaIxbfb25qlssCDjgH5FQLXzW3OBAZZVQCmxU2EZHWMLA1RkyZWPfZOlx66aVoqG1QW33T3uRARISBA86I6LDE1CuxZnhbWxu6urp8eoh9ymn8cB62Rk2ZMgXvvfUepuRPUV5FtVEl5l/fc889X96/FsdiUYNbb30XP/nBCcidEYPgYH5WI6JDE/Os7XY7Pl37KeLj49XWsYUZwzB37lz1iI41BrZGHS6wxcuq1+vl8fLly5GWlIGbf/YOfvGrJcjMjJTtRESH4vF4ULi7ELEJsT4HNo0vllkTTHVNtdww/qsP8ctzJMROXWKbO/HIzs5Gu90BS6QBwewOJyIfiAq7pa2FYT2BMLAnmEcefQT33X/f1x6dnZ3qFUenqc0FszkUIewKJ6LDED10skjg28WEwi5xjfEOeeU2dXPmzMHyZcsxc85MBIcGy5WD9jrYWuIrVpahoqILl/3nNMREG9VWIprsRASI9xWxkYe4jSa2vxSDzSoqKuS5vLw89Ur6tvHzk8Y4HU58/vnniI2NxZYdW9De1o5h77B69tA67X2IsBqUCptd4kS0jwhle6sdq1atQlFBkWwT64Q3tzQjPTldHu9PXC+WPB4YGPiyEhf77osudBpfDGyNMUWY5Lq9GzZswA033oCE5AQE+RDCvR2DSmDrEBzylRFqRKRZsjr2eOFxun17DLiV64fU794nVBeKjNQMbNuxTe6iNTI8AqfTCX346MDV/Ynqe936ddi0ZZMM68rKSrz//vtwK38+jS8Gtp9qaGiQm8673aO/RHLQmTmMFTaRH/G6vWgrbUL5ih0+PSo+2omuqmb1u0cFBgbCFmWTM0+8w15UlFWgv7cftojRzTy+SuyZfcLcE+QuXZUVldiydQvOPfPcg4Y7HVu8h+2HxL1rsYiB2E1n5cqVyM3Jxa03v4cfXzcPefmcg03kLwYdTux85RMUL1+ntowtJCwUM688BdOuOE1t2cftcWP7tu0oKirC1LypSM9MR0xMjHp2HxEZohB4f8X7qKuqwxVXXSFv0dH44zu3nxJba9bW1iI3NxfewRH0ezwwhIcyrIn8SGBwMKKzU5B95nyfHhmnz0VE+sGnaYUGh2JG3gz09fahorLikGEt7lV3tXeh096JUEModEHcIvN4YYXth746Sryl0Yk/Pfo5brl5PlJSrLKNiOirROW88YuNcA44cdYZZ6mtKiUpRFi3tbdh9UercfLCk+Xz1vZWOa4mMIjFwHjjv/AkYO/ogzU8mNU1EY1J3EabN3cepuVMU1sO5HF58Mmnn2D+/PlIy0zDrBmz0NzajN4uriF+PPAdfBKwd7lgNoUjOIgDzojo0MR6DkajEclpyWrLfgIAnVGHyy+7HNm52fI41BiKn/7kp7BGsefueGBg+6menh65OpqYgtFhd8BgUSpsTukiItIsBrafOuOMM5Ceno7S0lK4nF5YzDreYyIi0jAOOvNDX1uadO++IcHKg0U2EZEmseSaDELUB8OaiEizGNhEREQawMD2Q2LpQCIi8i+8h01ERKQBrLCJiIg0gIFNRESkAQxsIiIiDWBgExERaQADm4iISAMY2ERERBrAwCYiItIABjYREZEGMLCJiIg0gIFNRESkAQxsIiIiDWBgExERaQADm4iISAMY2ERERBrAwCYiItIABjYREZEGMLCJiIg0gIFNRESkAQxsIiIiDWBgExERaQADm4iISAMY2ERERBrAwCYiItIABjYREZEGMLCJiIg0gIFNRESkAQxsIiIiDWBgExERaQADm4iISAMY2ERERBrAwCYiItIABjYREZEGMLCJiIg0gIFNRESkAQxsIiIiDWBgExERaQADm46pvzzyF6RmpKpHRER0rASMKNTnRN9Yd3c3bDYbhoeH1RbftTW1ocfZg+ysbPzuod9BF6TDtt3bcNmFl+GCiy9AeUU5LAYLYhJi1O8gIpo8WGHTmD768CP1mW+sViuO5jNgT2cPXlz2IlKSU1BRWYE1a9fgmmuvwR233YFf3f0reY04J64R1wpH+ncjItIyBjYd0uYvNgNB6sFRqKquwt2/vRtPP/O0/CqOBXF83333Ye7cufKx+uPVeOzvj2HW7FnQ6XRITEjE/3vs/yEmJgbp6eno6uqS3yfOiWv+9Nc/jR6H6bDus3XyORGRv2Ng0yG9/MrLmH/CfPXoyP36V7/GghMX4IzvniG//vruX8v2h//4MC6++GJs374djz76KGbOnok333wTJ847UZ4PCwtDTk6OfL78teW47vrr5HNBXPPO2+/I57Nnz8brb70unxMR+TsGNh1UeWk5AgMCZRf30fpg5Qc45eRTkJycLL9+sOID2d7a1IrBwUGEhIRg0aJFiIqKQmtbK8It4fL8XqLybm9vx3U/3RfY4pr2tnb53Gw2w6AzoLCoUB4TEfkzBjYd1Nq1azF1+lT16OhER0bLQWhCe0c7oqOj5fMbb7gRt//idlx+2eXyWAgKDQL2G6f2/rvvo66hDldcdgV6Hb1qq0K5Rl6rmj5jOlavWa0eERH5Lwb2BOR2u/HM08/IAVa/f/j3WPf51+/T/uPJf+D2n9+OhoYGebxyxUrZJrgH3Pj9Q7/Hiy+8KI+PxucbPkd+br565LtNmzd9+fXuu+7GC8tewJtvvYmXXnoJd//6bnnuhhtuQEhgCE5edPKX96fnzp6LqtrRe9zrPl2HBx56QHZ9/+Pxf+A3v/mNbBfENeLavbKmZGHThtH/n0RE/oyBPQHtKdyD9z54D7m5uZgxYwb+7+H/U8/sYzKasHHjRoSHh8uAf+XVV7Bq5Sp5LjA4ENu2bpPff7RKSkqQnJSsHvkuNjYWzz33nPx60cUXYcmSJcjMzMSpp56Kiy64SF7z7PPP4ue3/RyJSYm4/fbbZZvo9l61avTvn5CYgJtuvAnXfP8aLF6yGP956X/KdkFcs38XuRigVljCLnEi8n+chz0B1dbVYueunTj/vPMxNDiEnLwcVFZVqmdHVZRW4LIrLsO27dvkvd7tu7bj9ddfx6YvNmHHzh0yvP/7l/+tXn3kRBCK0DaZTWrLsSPC+4rLr8CgZxC7tu/CM889g/7+fmz4bAOmzZqG+Ph49coDNTc3o2BnARYuWQij0SjbBp2DiE+LR2dbpzwmIvJXDOwJbu2atXjrjbfw17//VW0Z1dXZhekzp6O6qhr33HOP7GZeevpSlJeV497778VVl1+FKVOmqFd/nfi+PXv2yK7r3/3ud2rrPnqDHo4ehxwYdiSWv7pcfXZob731lgxcMS3LZrVh+vTpsr3P0SdDPNIWKY+/qqOzA7oQnZyP/Z3vfme00QsEG4Mx5BoaPSYi8lMM7G/JE089oT470HU/2dfdu3PHTqxauwpnnn4mps2YpraO8ng8iImNwbv/fhe7i3bjxutvRHZONl579TW8/977uPvu0fvFh1JdWS2r9nPPOxcul0tt3ScgJAAjngN/NHz5O7/3/nvqs/FjNVuxaPEi9Uj5uwYqf9dh/hgTkX9jYH9LDhd+n6//HLVVtUhJT0FWVhbi477eTRyXEIcfXP0DXH/z9UhNScVJC0+SQXbt1dcedoS3CHxRPQcEKGF3kB+B4FClanUfWLX6EtjfhvEKbM+gBxVVFSgtKUVJeQl+9YvRFde+qmB3AbZu34qWlhZ5732s2wiffPoJampqEBwYjLS0tAM+eAjjfZ6ItIuBPQGtX78ef/jjH2TX75w5c1BZWYkHHnhAPbvPtOnTcM1V1+AXv/qFPBZToKLjo/HXRw7sPh/LoQJbDGYTI7iPtEv8SHz62acyWJpamjAtfxry8vPUM0fAC+hNericX+8l+KYqyyuxfsN6lJWW4eE/PSwD/KtWrlwpp8CJ6WbiQ9C999wLc4RZPXugPbv34LG/PSZ7S8R/d0FBAW64/gY5Ne14nCcibeMo8QlI3KvNzMhEZGQkamtr5Sjwg/n+f30fF19ysXoEnH/B+bj6yqvVo1FiStVXH76wmC1yINh46ezqxFNPP4WOjg6UlZfh0UceVc8cmcGBQURaD37P+5saGh5CSloKFi9e/LXeBkEEuVhmNS4+Dj/56U/w0EMPHTKshSefelIuRPOzm3+GG2+8UT4XbXuN93ki0rZJVWHv2r0LhQWFyM3LxZzZc+BwOGR15Pa4ccnFl6hXHTuia7KiogLdPd0ICgyCyWTC6aefrp49Pv73wf9Vn+3zm1/vm9d8qAr7pAUnYdm/lskPDuOhsakRzz3/nPy7tLW1IT8/H3a7XT3ru8b6Rlx48YXYvHmz2vJ1zn4nNm3aBEe/AxkZGZg2dd94APEaia7jsRQVF2Fq/tSv/Tvdddddcgexyy+/HH19fUhKTMLiRYuh0+vUK/YZ8ijhn56Cf7/5b8yfP7rc685tO3H2+WejrrpOHo/n+eCQYNlGRNo1qQJbVJePP/44bJE2vPTiS3j3vXex4oMVqGusw4fvf6hetc+q1aPzgg/l9KWHCN9hYP0X67Fm1Rrs3L1TbmLR39cvp2t9+smn6kXfrgHnAGrra5GXm4fikmJkpGYgVB+qngV+9MMf4fvXfl/Oox5vG7/YKEe6f/zRx2qL70RQ/+3//Q0vPP+C2vJ1a1etxZYtW9DY2ii7ra+55hosOGEB7J12fPjBh7j6mgN7Jb7qYIEtAjg7N1uOF2hpb0FTcxNcAy7cdsttOOucs9Sr9hHTziJjI+HociDcOroEa193H0wRJnS0dsjj8Txvi7HJNiLSrknVJX7RhRfJXaJWfbxKTmcSj1/+8pe45aZb1CsO9NHHH435OJTiwmLc98B9ePu9t3HKolPw8P8+jDPOOAOpSanqFd++gf4BFBcX47zzzpNf3YMHdrufdPJJcrDVeGuob8CKD1fgF/89eh/+SJUWl8r1yA9J+fAkPjTdeuutuPfue+FxeeTOYOKD05o1axBhiVAvPDKObgdqqmqw8KSFeOSPj+C5Z55DzpQc/PZ/fnvQWxg9vaNbgoqxAXuFG0ef9/T0jPt5ItK+STnoLH96vuwa/cuf/oLsrGy19RhRAuK/rvkvbNi8AblZuXj26WfR2dmJf7/9b1x55ZVITZ84oT2W2upa/PGRP+KxRx9TW469+rp6Oc9crA1+ztnnyHuuR+qO2+/A9Tdef+jXcQjYXbxbjiIfcA3AbDDj7Q/eRl1dHfJy8nDZxZchNjFWvfjgDlZh11bWIi0rTVbaQcGja5vX1iht6WlobW2VvSr7a2xoRFJykvxgFBI6OpBvsH8Q+nA9Gmoa5Dam43k+MTVRthGRdk26QWfiDXZ63nT5hp2dMXZY7969e8zHwbj6XXj1zVflfVmxUllxebHciequX96lmbAWxN81VBcqB4eNB/HvI7bWrKmrkd3yb7z5hnrGd91d3RgOHB77Q1cw0NvTi1deegV/feyvWPbSMlxy0SV4/LHHce2112LNp2vUC4+MMdwop5N12vf9+8RGxcoxAeJn7KuibFEIM4ShpbFFbQHqmupkW1R01LifJyLtmzSB7XQ6AaVAEt3V4s1NDAbb/832YP786J/HfBxMW3ub3Hyj39Evu+CXLF4i50c3tDTA0etQr9KGa66+Rt5fHg9bN2/F+k3rsXvXbjz4uwex/JXDr5D2VVu3bJVT2cakvOZiLMK9996LPzz8B+zYswMPPvggiouK8dlnnyEoaN/OX0ciKjYKSSlJ+PyLz9UWYGfBTiQlJSEhJkEeNzU2oapqdEMTnUGH+Qvmy01V9hJTxuafOF+eG+/zROQHRJf4ZPD2O2+PVJdXj9xx+x0j3R3dI5mZmSN//NMfR1pbW0e8Xq961TfX3d09kpiSOGK2mUfu/9/7R3bs2DHy+aefj9z/P/ePbFy/Ub1KOz759BP12cTj09/NPTJSXlquHiivj/La3/nLO0cuuuSikfvuu0+eH0tjY+PImrVrRF/4SENDw0h7e7t6ZmTk4f97eOTSyy8dqa6uHqmpqRm56cabZNted95x58g53ztHPRoZee3110YuvuRiea34ngsvuHDkteWvqWfH/zwRadukuYe96NRFiImOgRKcclrPk/94Uo4uFlXkzT+7GXq9Xr3ym1vx/gr87Ym/obCoELogHeacMAf3/+Z+OaqYtEUMhmvvbMfa1Wtx/kXnIysza98gRQ/w2/t+i8JC5XXW6TBt5jTcfefdgLrWzPU3XS97cvbuoiaIMQEbNm7A4OAgFi5eiDtvv1M9M2q8zxORdnGlMyIiIg3gSmdEREQawMAmIiLSAAY2ERGRBjCwiYiINICBTUREpAEMbCIiIg1gYBMREWkAA5uIiEgDGNhEREQawMAmIiLSAAY2ERGRBjCwiYiINICBTUREpAEMbCIiIg1gYBMREWkAA5uIiEgDGNhEREQawMAmIiKa8ID/D/YiAEN9u4lgAAAAAElFTkSuQmCC)\n", + "\n", + "WolframAlpha - intersect of log2(x) and x^(1/2) http://wolfr.am/4_HS2HNA\n", + "\n", + "The order of growth of log2 n is less (slower) than the order of growth of √n\n", + "Crossover point of n is 16." + ], + "metadata": { + "id": "JO14ce2rgIeX" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Understanding the Given Problem:**\n", + "\n", + "In the problem provided, we are comparing two algorithms in terms of their time complexity as a function of input size (n). The time complexity is expressed in terms of seconds required by each algorithm to solve a problem of size n.\n", + "\n", + "The first algorithm's time complexity is log2(n) seconds, and the second algorithm's time complexity is √n seconds.\n", + "\n", + "To determine which algorithm grows asymptotically faster (i.e., which one becomes more time-consuming as n increases), we compare the growth rates of the functions log2(n) and √n.\n", + "\n", + "* Growth Comparison:\n", + "\n", + " - The function log2(n) grows logarithmically with the base 2, which is slower than linear growth.\n", + " - The function √n grows with a square root, which is slower than logarithmic growth.\n", + " - As n gets large, the function √n will grow faster than log2(n).\n", + "\n", + "* Crossover Point (Intersection):\n", + "\n", + " - To find the crossover point where the two functions intersect (i.e., when they are equal), we need to solve the equation log2(n) = √n for n.\n", + "WolframAlpha was used to calculate this intersection point, and it turns out to be approximately n = 16.\n", + " - The crossover point is the value of n at which the curves representing the time complexities of the two algorithms intersect, indicating the point at which one algorithm becomes faster than the other for a given input size.\n", + "\n", + "So, for input sizes n greater than approximately 16, the algorithm with time complexity √n will be faster (grow asymptotically faster) than the algorithm with time complexity log2(n).\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "47rCSWhVgIea" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the sample question**" + ], + "metadata": { + "id": "6vW5r7M3gIeb" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement:**\n", + "Your task is to analyze the time complexities of two sorting approaches: Approach A and Approach B. Approach A has a time complexity of O(n log n) while Approach B has a time complexity of O(n^n). Determine which approach is more efficient for sorting larger arrays and identify the crossover point at which the two approaches become equally efficient for sorting.\n", + "\n", + "\n", + "####**Input:**\n", + "* An array of integers to be sorted.\n", + "\n", + "####**Output:**\n", + "* The more efficient algorithm for the given array size (\"Algorithm A\" or \"Algorithm B\").\n", + "* The crossover point, i.e., the array size at which both algorithms have similar time complexities.\n", + "\n", + "\n", + "**Example**:\n", + "* Input: Array: [5, 3, 8, 1, 2]\n", + "\n", + "* Output:\n", + "Algorithm A\n", + "Crossover point (array size): 3\n", + "\n", + "\n", + "####**Constraints**\n", + "* The length of the input array is between 1 and 10^6.\n" + ], + "metadata": { + "id": "0QcQXB49gIec" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "zchLfiPcgIec" + } + }, + { + "cell_type": "markdown", + "source": [ + "To determine the more efficient sorting algorithm for a given array size, compare the time complexities of Algorithm A (O(n log n)) and Algorithm B (O(n^2)).\n", + "\n", + "1. If n log n > n^2, Algorithm A is more efficient.\n", + "2. If n^2 > n log n, Algorithm B is more efficient.\n", + "\n", + "The crossover point is found by solving the equation n log n = n^2.\n", + "\n", + "Algorithm to determine the more efficient algorithm and crossover point:\n", + "1. Read the input array and calculate its size, n.\n", + "2. If n log n > n^2, print \"Algorithm A\" and calculate the crossover point using n log n = n^2.\n", + "3. If n^2 > n log n, print \"Algorithm B\" and calculate the crossover point using n log n = n^2.\n", + "4. Print the crossover point.\n", + "\n" + ], + "metadata": { + "id": "1A2eeQFSgIee" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "WXuKT1HbgIef" + } + }, + { + "cell_type": "code", + "source": [ + "import math\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def determine_efficient_algorithm_and_crossover_point(array):\n", + " n = len(array)\n", + " n_log_n = n * math.log2(n)\n", + " n_squared = n * n\n", + "\n", + " if n_log_n > n_squared:\n", + " return \"Algorithm B\", math.ceil(n_squared / (math.log2(n)))\n", + " else:\n", + " return \"Algorithm A\", math.ceil(n * (math.log2(n) / n))\n", + "\n", + "# Example usage with an array\n", + "input_array = [5, 3, 8, 1, 2]\n", + "algorithm, crossover_point = determine_efficient_algorithm_and_crossover_point(input_array)\n", + "\n", + "# Print the output\n", + "print(\"Output:\")\n", + "print(algorithm)\n", + "print(\"Crossover point (array size):\", crossover_point)\n", + "\n", + "# Plot the crossover point\n", + "x = range(1, len(input_array) + 1)\n", + "y_n_log_n = [n * math.log2(n) for n in x]\n", + "y_n_squared = [n * n for n in x]\n", + "\n", + "plt.plot(x, y_n_log_n, label=\"n * log(n)\")\n", + "plt.plot(x, y_n_squared, label=\"n^2\")\n", + "plt.axvline(x=crossover_point, color='r', linestyle='--', label='Crossover Point')\n", + "plt.xlabel('Array Size')\n", + "plt.ylabel('Operations')\n", + "plt.legend()\n", + "plt.title('Crossover Point Analysis')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 524 + }, + "id": "btWBeRRpqeNI", + "outputId": "431a4551-3067-483f-b49b-589b9e52777d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Output:\n", + "Algorithm A\n", + "Crossover point (array size): 3\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "**To summarize the algorithm:**\n", + "\n", + "This algorithm helps decide between two approaches, Algorithm A and Algorithm B, for solving a problem based on the size of the input array. It calculates a \"crossover point,\" which is the array size at which one algorithm becomes more efficient than the other.\n", + "\n", + "This algorithm is designed to choose the most efficient approach based on the input array size.\n", + "It helps in optimizing the solution by selecting the appropriate algorithm to ensure faster and more efficient processing, ultimately saving time and resources.\n", + "\n" + ], + "metadata": { + "id": "6ipbZEeXgIei" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - ChatGPT's algorithmic insights empowered me to make informed decisions, optimizing efficiency based on the given problem context\n", + "\n", + "* **Challenges Faced:**\n", + " - Determining the appropriate crossover point where switching algorithms becomes beneficial can be challenging and requires careful mathematical analysis.\n", + " - Balancing between using different algorithms and considering their efficiency, as an algorithm that performs well for smaller inputs may not be the best choice for larger inputs.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "* **Learnings:**\n", + " - Understanding the importance of algorithmic efficiency and how it can impact performance based on input size.\n", + " - Learning to calculate and compare algorithmic complexities (n_log_n and n_squared) to make informed decisions.\n", + "\n" + ], + "metadata": { + "id": "aTxdafvqgIej" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 7:**" + ], + "metadata": { + "id": "nFL5k6iWRSld" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "In geometry, a line segment is a part of a line that is bounded by two distinct end points, and contains\n", + "every point on the line between its end points. Consider an instance of stable matching problem in\n", + "which there exists a point p and point q such that point p is ranked first in the preference list of q and\n", + "point q is ranked first in the preference list of p (Note that point p and q are distinct points and there\n", + "match results in the formation of a line segment).Then for every stable matching S for this instance, the\n", + "pair (p ,q) belongs to S.\n", + "\n", + "1. State whether the above statement is True or False?\n", + "2. If the statement is true give a short explanation if false give a counter example\n", + "\n", + "\n", + "\n", + "###**Solution:**\n", + "This is true indeed such a pair (p, q) and consider a perfect matching containing pairs (p, q’), (p’, q) and\n", + "hence (p’, q’) .Then as p and q each of them prefer each other first. They each prefer each other for\n", + "forming a line segment in this matching. Hence this matching cannot be stable" + ], + "metadata": { + "id": "7W28YWBdRaHt" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Understanding the Given Problem:**\n", + "\n", + "* The given problem discusses a scenario involving stable matching, a concept from the field of combinatorial mathematics and algorithm design. The problem establishes a relationship between stable matching and geometry, particularly line segments. It asserts that in a stable matching problem, if there exist two points, p and q, such that they rank each other first in their preference lists, their pairing must be part of any stable matching, and it forms a line segment. The provided solution demonstrates this assertion by creating a counterexample.\n", + "\n", + "\n", + "* The logic behind the solution is rooted in the definition and properties of stable matching and how a perfect matching can be used to demonstrate instability when the given condition is violated. It utilizes the concept of preference lists and the stability criterion to validate the statement.\n", + "\n", + "* The algorithmic concepts involved in this problem include stable matching algorithms (e.g., Gale-Shapley algorithm), graph theory, preference lists, perfect matching, and the application of these concepts to a geometric analogy." + ], + "metadata": { + "id": "3jYKV9y4R2G8" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the sample question**" + ], + "metadata": { + "id": "yz0KChUkRvu0" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement:**\n", + "You are given a set of points, each associated with a preference list of other points. The goal is to maximize the total length of line segments by matching points with their preferred partners while ensuring each preference is used at most once.\n", + "\n", + "####**Input:**\n", + "A list of tuples, where each tuple consists of a point represented as a tuple of coordinates and a preference list for that point.\n", + "\n", + "####**Output:**\n", + "A stable matching, which is a list of tuples representing pairs of points.\n", + "The total length of line segments achieved by the stable matching.\n", + "\n", + "\n", + "Example:\n", + "* Input: points = [((0, 0), [1, 2]), ((1, 1), [1, 2])]\n", + "\n", + "* Output:\n", + "Stable Matching: [((0, 0), 1), ((1, 1), 2)]\n", + "Total Length of Line Segments: 6\n", + "\n", + "####**Constraints**\n", + "* The input points are represented as tuples of coordinates where each coordinate is an integer.\n", + "* The preference list for each point is a list of integers.\n", + "* The length of the preference list for each point is at most the number of points - 1." + ], + "metadata": { + "id": "WRCoA_EERwg-" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "xQALvQJLTFQX" + } + }, + { + "cell_type": "markdown", + "source": [ + "The given solution maximizes the total length of line segments by sorting the points based on the sum of preference list ranks and then iteratively matching points with their highest-ranked preferences. The length of a line segment is based on the sum of preference ranks.\n" + ], + "metadata": { + "id": "Ex4c82haTKvR" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "jJttlLLvTPvR" + } + }, + { + "cell_type": "code", + "source": [ + "import math\n", + "\n", + "def distance(point1, point2):\n", + " # Calculate the Euclidean distance between two points\n", + " return math.sqrt((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2)\n", + "\n", + "def maximize_line_segments_length(points):\n", + " # Step 2: Sort points based on the sum of preference list ranks\n", + " sorted_points = sorted(points, key=lambda x: sum(x[1]))\n", + "\n", + " # Initialize data structures\n", + " stable_matching = []\n", + " unavailable_preferences = set()\n", + " total_length = 0\n", + "\n", + " # Iterate through sorted points\n", + " for point, preference_list in sorted_points:\n", + " # Iterate through preference list\n", + " preference_ranks_sum = sum(preference_list)\n", + " for preference in preference_list:\n", + " # Step 6: Check if preference is available\n", + " if preference not in unavailable_preferences:\n", + " # Step 7: Add the pair to stable_matching\n", + " stable_matching.append((point, preference))\n", + "\n", + " # Step 8: Add the length of the line segment to total_length\n", + " total_length += preference_ranks_sum # We use the sum of preference ranks as the length\n", + "\n", + " # Step 9: Add preference to unavailable_preferences\n", + " unavailable_preferences.add(preference)\n", + "\n", + " # Step 10: Break to the next point\n", + " break\n", + "\n", + " # Step 11: Return stable_matching and total_length\n", + " return stable_matching, total_length\n", + "\n", + "\n", + "# Example usage\n", + "points = [((0, 0), [1, 2]), ((1, 1), [1, 2])]\n", + "stable_matching, total_length = maximize_line_segments_length(points)\n", + "\n", + "print(\"Stable Matching:\", stable_matching)\n", + "print(\"Total Length of Line Segments:\", total_length)\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4zVi4MKRS1US", + "outputId": "e83a48c4-679e-44c2-ef0c-f7a27e4ff233" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Stable Matching: [((0, 0), 1), ((1, 1), 2)]\n", + "Total Length of Line Segments: 6\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "**To summarize the algorithm:**\n", + "\n", + "* The algorithm iterates through the points in order of decreasing sum of preference ranks, ensuring the highest-ranked preferences are selected first.\n", + "* It exhausts the preferences for each point, maximizing the total length of line segments.\n", + "* Since it follows the steps systematically, it ensures a stable matching where no point has an incentive to deviate.\n" + ], + "metadata": { + "id": "nFiTa2S2Twiu" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - ChatGPT played a crucial role in optimizing and organizing the provided code, enhancing its clarity and coherence.\n", + " - Through its assistance, the algorithm was refined, making it easier to understand the existing solution.\n", + "\n", + "* **Challenges Faced:**\n", + " - Designing a problem that retained the essence of the given example while being non-trivial was a challenge.\n", + " - Ensuring that the new problem involved stable matching, preferences, and introduced a geometric context proved to be a delicate balance.\n", + "\n", + "* **Learnings:**\n", + " - This task emphasized the importance of aligning the new problem with the spirit of the example while adding complexity.\n", + " - It reinforced the need for a clear problem definition, appropriate input/output formats, and constraints for a well-structured algorithmic problem.\n", + " - Creating a problem that combined two seemingly different domains, such as stable matching and geometry, provided valuable insights into creative problem design." + ], + "metadata": { + "id": "rLUiqQ8eUDO0" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 8:**" + ], + "metadata": { + "id": "ev4GGE3eUTe7" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "Suppose we have two Soccer/Football Teams, let us call them Team X and Team Y. Each Soccer/Football\n", + "Team has a set of players and each player has its own position on the soccer field. Let us assume the\n", + "players to be p and their respective position on the soccer field to be q. Note that each player can have\n", + "different position on the field except the Goalkeeper. Each team wants to win the league for which it\n", + "wants to devise a strategy- assignment of each player to a distinct best position on the field- so that\n", + "each player can perform to his fullest strengths. The performance of the team is judged only on the\n", + "player’s performance in the team. Note that there is no other criterion to evaluate the team’s\n", + "performance except the performance of a player for a particular position.\n", + "\n", + "One way to determine how well the two teams will perform in the league relative to each other, given\n", + "their strategies. Each player has a fixed rating based on his performance in the current season; we will\n", + "assume that no two players share the same rating. The team wins a given game if it has a greater rating\n", + "for the player assigned to a particular position than the assigns the other team. For example in Team X if\n", + "a player p is assigned a position q who has a rating 9 for that position, then Team Y can win only if it has\n", + "a player whose rating is greater than 9 for that same position. The goal of each team is to win as many\n", + "as matches to achieve the Championship.\n", + "\n", + "\n", + " Suppose in the opening week of fall season. Team X reveals a strategy S and Team Y reveals a strategy\n", + "T. On the basis of this pair of strategy, each team wins certain games, according to the rule above. We’ll\n", + "say that the pair of schedules (S, T) is stable if either Team can unilaterally change its own schedule and\n", + "win more matches. That is there is no strategy S’ such that Team X wins more games with the pair (S’, T);\n", + "and symmetrically there is no strategy T’ such that Team Y can win more games with pair (S, T’) than it\n", + "did with pair (S, T).\n", + "For every set of players and there rating for the position they play in, is there a stable pair of strategy?\n", + "Resolve this question by doing one of the following two things:\n", + "\n", + "* Give an algorithm that, for any set of players and their ratings associated for a particular\n", + "position, produces a stable pair of strategies.\n", + "OR\n", + "* Give an example of a set of players and associated rating for a particular position they are\n", + "playing in for which there is no stable pair of schedules.\n", + "\n", + "\n", + "\n", + "###**Solution:**\n", + "There is not always a stable pair of strategy. Suppose Team X has two players say {x1, x2} with ratings 20\n", + "and 40 for given positions on the field; and Team Y has two players say\n", + "{y1, y2} with ratings 10 and 30 for the same positions.\n", + "\n", + "Each Team can reveal one of two strategies. If the resulting pair, x1 is paired against y1, then Team Y will\n", + "want to switch the order of players in its strategy (so that it will win just one slot rather than none). If in\n", + "the resulting pair, x1 is paired against y2, then Team X will want to switch the order of player (so that it\n", + "will win two slots rather than one)." + ], + "metadata": { + "id": "tRZk1gidUTe8" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Understanding the Given Problem:**\n", + "\n", + "* The problem presented revolves around determining a stable pair of strategies for two soccer/football teams (Team X and Team Y) with different players and their respective ratings for specific positions on the field. The objective is to assign players to positions in a way that maximizes their performance and helps the team win matches.\n", + "\n", + "* In this scenario, stability is defined as a situation where neither team can unilaterally change its own strategy to win more matches, given the revealed strategies of both teams.\n", + "\n", + "* The provided solution demonstrates that there isn't always a stable pair of strategies. It gives an example with specific players and their ratings where the teams can improve their match-winning potential by altering their strategies based on the opponent's lineup.\n", + "\n", + "* In the example, Team X has players x1 and x2 with ratings 20 and 40, respectively, for certain positions. Team Y has players y1 and y2 with ratings 10 and 30, respectively, for the same positions. Depending on how the players are paired against each other in the strategies, one of the teams can always find a better pairing that increases their chances of winning matches.\n", + "\n", + "* Therefore, the conclusion is that there isn't a universal algorithm to produce a stable pair of strategies for any set of players and their ratings. The example showcases that the specific ratings and players involved can influence the stability of the strategies and may require adjustments to gain a competitive advantage.\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "befHxH0xUTe8" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the sample question**" + ], + "metadata": { + "id": "WiSIWjvmUTe9" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement:**\n", + "You are a league manager overseeing a soccer/football tournament where various teams compete. Each team has a set of players with specific ratings that represent their overall performance. Your goal is to schedule matches between teams in a way that maximizes the excitement of the tournament, ensuring that highly competitive teams face each other, thus making the league more engaging for the audience.\n", + "\n", + "####**Input:**\n", + "* Ratings for each player in every team.\n", + "* Desired matchups between teams (teams that the audience desires to see compete against each other).\n", + "\n", + "####**Output:**\n", + "* The optimal match schedule that accommodates the desired matchups and ensures a highly engaging tournament.\n", + "\n", + "\n", + "Example:\n", + "* Input:\n", + " * Teams and Ratings:\n", + "Team A: [18, 25, 30]\n", + "Team B: [20, 28, 35]\n", + "Team C: [22, 26, 32]\n", + "\n", + " * Desired Matchups:\n", + "[(Team A, Team B), (Team B, Team C)]\n", + "\n", + "\n", + "* Output:\n", + "Optimal Match Schedule:\n", + "Match 1: Team B vs. Team C\n", + "Match 2: Team A vs. Team B\n", + "\n", + "\n", + "####**Constraints**\n", + "* The number of teams and players in each team can vary.\n", + "* Ratings for each player are unique and not repeated." + ], + "metadata": { + "id": "fSnxgzeQUTe9" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "ky8yBm2gUTe9" + } + }, + { + "cell_type": "markdown", + "source": [ + "Develop a scheduling algorithm that considers the desired matchups and optimizes the match schedule to maximize the overall excitement of the tournament by pairing highly competitive teams.\n" + ], + "metadata": { + "id": "mCPJzEojUTe-" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "o142X81EUTe-" + } + }, + { + "cell_type": "code", + "source": [ + "def schedule_matches(teams, desired_matchups):\n", + " match_schedule = []\n", + " teams_set = set(teams)\n", + "\n", + " for matchup in desired_matchups:\n", + " team1, team2 = matchup\n", + " if team1 in teams_set and team2 in teams_set:\n", + " match_schedule.append(f\"Match: {team1} vs. {team2}\")\n", + "\n", + "\n", + " return match_schedule\n", + "\n", + "# Sample Inputs\n", + "teams_and_ratings = {\n", + " 'Team A': [18, 25, 30],\n", + " 'Team B': [20, 28, 35],\n", + " 'Team C': [22, 26, 32]\n", + "}\n", + "\n", + "desired_matchups = [('Team A', 'Team B'), ('Team B', 'Team C')]\n", + "\n", + "# Generate the optimal match schedule\n", + "optimal_schedule = schedule_matches(teams_and_ratings.keys(), desired_matchups)\n", + "\n", + "# Display the optimal match schedule\n", + "for match in optimal_schedule:\n", + " print(match)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "dcf1d059-e4bc-41e1-916a-2b6430149401", + "id": "fdGn6eepUTfA" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Match: Team A vs. Team B\n", + "Match: Team B vs. Team C\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "**To summarize the algorithm:**\n", + "\n", + "The algorithm provided a systematic approach to organizing soccer/football matches, ensuring each desired matchup is accommodated appropriately. It optimized the match schedule, enhancing excitement by pitting highly competitive teams against each other. By automating the scheduling process, the algorithm streamlined the task, saving time and effort for the league manager. The algorithm's structure allowed for efficient modification and scaling, providing a foundation for handling various tournament scenarios and matchups. Overall, the algorithm facilitated the creation of an engaging tournament that maximized audience interest and participation.\n", + "\n" + ], + "metadata": { + "id": "1QgUhq8bUTfB" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - ChatGPT provided guidance and feedback, assisting in refining the problem statement and algorithm design.\n", + " - It helped in identifying and rectifying an issue in the initial code, ensuring the correct output.\n", + "\n", + "* **Challenges Faced:**\n", + " - Initial code discrepancy: Debugging the initial code to generate the correct output for the desired match schedule.\n", + " - Ensuring clarity: Crafting a clear and accurate problem statement while adhering to the desired format.\n", + "\n", + "* **Learnings:**\n", + " - Designing a problem with a different focus while maintaining similarity was indeed challenging. This problem emphasizes scheduling matches to optimize the excitement of the tournament, a different aspect of soccer/football leagues. It underscores the importance of adapting a problem to target different areas while retaining its essence.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "4MTXvSGfUTfC" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**Sample Question 9:**" + ], + "metadata": { + "id": "H7opT2U77EDY" + } + }, + { + "cell_type": "markdown", + "source": [ + "The NBA is changing its playoff format using the Gale-Shapley matching algorithm. Rather than Western\n", + "Conference teams playing Western Conference teams; the eight Western Conference teams will be\n", + "matched against the eight Eastern Conference teams using the Gale-Shapley matching algorithm.\n", + "Further social media will be used to ask fans, media, players and coaches to create a ranking of which\n", + "teams they most like to face. See http://www.nba.com/playoffs/\n", + "\n", + "\n", + "\n", + "---\n", + "\n", + "\n", + "A. Modify an existing Gale-Shapley implementation in python so that the eight Western Conference\n", + "teams will be matched against the eight Eastern Conference teams. You can make up the preference\n", + "lists for each team\n", + "\n", + " See http://rosettacode.org/wiki/Stable_marriage_problem#Python\n", + "https://github.com/paulgb/Python-Gale-Shapley/\n", + "http://cs.slu.edu/~goldwasser/courses/slu/csci314/2008_Spring/lectures/marriageAlgorithm/\n", + "\n", + "Solution:\n", + "Code given\n", + "\n", + "\n", + "---\n", + "\n", + "\n", + "B. Use a loop to shuffle the preference lists for each team 1000 times. Calculate the percentage of\n", + "stable playoff matches. See the function random.shuffle(x[, random])\n", + "https://docs.python.org/2/library/random.html\n", + "\n", + "Solution:\n", + "Code given\n", + "\n", + "---\n", + "\n", + "C. Randomly assume certain teams win and lose each round and eliminate the losers from the\n", + "preference lists for each team. Can the Gale-Shapley matching algorithm be applied over and over in\n", + "each round (16 teams, 8 teams, 4 teams, 2 teams) to create stable matches?\n", + "\n", + "\n", + "Solution:\n", + "You must mention something about the possibility to eliminate teams asymmetrically. That is, if you\n", + "remove 3 east teams, you must also remove 3 west teams otherwise the lists will have different\n", + "numbers. If we were to eliminate teams asymmetrically, it would still result in stable matching; it’s just\n", + "that some teams won’t have an assignments and we would need to make adjustments to the algorithms\n", + "to use it in a bracket style playoffs.\n", + "\n", + "---\n", + "\n", + "\n", + "D. Now combine the lists so that any team can be matched against any other irrespective of conference.\n", + "Can the Gale-Shapley matching algorithm still create stable matches? (With just one list matching\n", + "against itself?)\n", + "\n", + "Solution:\n", + "Utilizing just the original Gale-Shapley algorithm alone will not work because the problem essentially\n", + "boils down to the stable roommate problem where assignments are given based on one set of people\n", + "8\n", + "and preference lists instead of two. Utilizing the stable roommate algorithm approach or another tweak\n", + "can still create stable matches, but doesn’t guarantee stable matches like the Gale-Shapley algorithm.\n", + "“Unlike the stable marriage problem, a stable matching may fail to exist for certain sets of participants\n", + "and their preferences. For a minimal counterexample, consider 4 people A, B, C, and D, whose rankings\n", + "are:\n", + "A:(B,C,D), B:(C,A,D), C:(A,B,D), D:(A,B,C)”\n", + " - from http://en.wikipedia.org/wiki/Stable_roommates_problem\n", + "\n", + "---\n", + "\n", + "E. Double the size of the lists in problem A several times (you can make up team names like team1,\n", + "team2, etc.) and measure the amount of time it takes to create stable matches. How fast does the\n", + "execution time grow in relation to the size of the lists?\n", + "\n", + "Solution:\n", + "Any timing in your code is accepted." + ], + "metadata": { + "id": "wHmazBqY7EDZ" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Understanding the Given Problem:**\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "QlBRaX447EDb" + } + }, + { + "cell_type": "markdown", + "source": [ + "###**Question based on the sample question**" + ], + "metadata": { + "id": "AdlYev3b7EDc" + } + }, + { + "cell_type": "markdown", + "source": [ + "You are tasked with implementing and optimizing an algorithm for matching students to their preferred extracurricular activities in a university. The initial matching is based on students' preferences and the availability of activities. The Gale-Shapley algorithm will serve as the foundation for this task.\n", + "\n" + ], + "metadata": { + "id": "7DKTtkvw9VhY" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement A:**\n", + "Modify an existing Gale-Shapley implementation in Python to match students (from a specific class) to extracurricular activities (from a different class) using the Gale-Shapley matching algorithm. You need to create preference lists for each student and each activity.\n", + "\n" + ], + "metadata": { + "id": "xUDwwxmKCjm7" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "####**Input:**\n", + "* student_preferences (dict): A dictionary representing the preferences of each student for activities. Keys are student names, and values are lists of activity preferences for that student.\n", + "* activity_preferences (dict): A dictionary representing the preferences of each activity for students. Keys are activity names, and values are lists of student preferences for that activity.\n", + "\n", + "####**Output:**\n", + "* student_to_activity (dict): A dictionary that maps each student to their assigned activity.\n", + "\n", + "\n", + "Example:\n", + "* Sample Input 1:\n", + "student_preferences = {\n", + " 'student1': ['activity2', 'activity1', 'activity3'],\n", + " 'student2': ['activity1', 'activity2', 'activity3'],\n", + " 'student3': ['activity3', 'activity2', 'activity1']\n", + "}\n", + "\n", + " activity_preferences = {\n", + " 'activity1': ['student1', 'student2', 'student3'],\n", + " 'activity2': ['student1', 'student2', 'student3'],\n", + " 'activity3': ['student1', 'student2', 'student3']\n", + "}\n", + "\n", + "* Sample Output 1:\n", + "Matches: {'student1': 'activity2', 'student2': 'activity1', 'student3': 'activity3'}\n", + "\n", + "\n", + "####**Constraints**\n", + "* The input preference lists (student_preferences and activity_preferences) must be non-empty dictionaries.\n", + "* The keys in student_preferences and activity_preferences should be unique student and activity identifiers, respectively.\n", + "* The preference lists should be lists of unique activity/student identifiers, respectively.\n", + "* The code assumes that all students and activities are present in both preferences dictionaries and that there are no missing or duplicate entries in the preference lists." + ], + "metadata": { + "id": "yHpiZo_E7EDd" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "be-7FbS_7EDe" + } + }, + { + "cell_type": "markdown", + "source": [ + "The provided code implements the Gale-Shapley algorithm, matching students to activities based on their preferences. It iterates through students and their preferences, assigning each student to their highest-ranked available activity. If a student's preferred activity is already assigned, it compares preferences and updates the assignment if the current student is favored. The algorithm continues until all students are matched, resulting in a stable matching.\n" + ], + "metadata": { + "id": "35_RdSEe7EDf" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "qCBnvOXv7EDg" + } + }, + { + "cell_type": "code", + "source": [ + "def gale_shapley(student_preferences, activity_preferences):\n", + " student_to_activity = {} # Maps student to their assigned activity\n", + " activity_to_student = {} # Maps activity to its assigned student\n", + " unmatched_students = list(student_preferences.keys()) # Initially all students are unmatched\n", + "\n", + " while unmatched_students:\n", + " student = unmatched_students.pop(0)\n", + "\n", + " for activity in student_preferences[student]:\n", + " if activity not in activity_to_student:\n", + " student_to_activity[student] = activity\n", + " activity_to_student[activity] = student\n", + " break\n", + " else:\n", + " current_student = activity_to_student[activity]\n", + " if activity_preferences[activity].index(student) < activity_preferences[activity].index(current_student):\n", + " student_to_activity[student] = activity\n", + " student_to_activity[current_student] = None\n", + " unmatched_students.append(current_student)\n", + " activity_to_student[activity] = student\n", + " break\n", + "\n", + " return student_to_activity\n", + "\n", + "# Sample input: Preference lists for students and activities\n", + "student_preferences = {\n", + " 'student1': ['activity2', 'activity1', 'activity3'],\n", + " 'student2': ['activity1', 'activity2', 'activity3'],\n", + " 'student3': ['activity3', 'activity2', 'activity1']\n", + "}\n", + "\n", + "activity_preferences = {\n", + " 'activity1': ['student1', 'student2', 'student3'],\n", + " 'activity2': ['student1', 'student2', 'student3'],\n", + " 'activity3': ['student1', 'student2', 'student3']\n", + "}\n", + "\n", + "# Match students to activities using Gale-Shapley\n", + "matches = gale_shapley(student_preferences, activity_preferences)\n", + "\n", + "# Print matches\n", + "print(\"Matches:\", matches)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "729e5640-b03f-4b4c-cd0a-d46933f05d52", + "id": "c54TBiD87EDg" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Matches: {'student1': 'activity2', 'student2': 'activity1', 'student3': 'activity3'}\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - ChatGPT provided a clear understanding of the Gale-Shapley algorithm and guided in breaking down its steps.\n", + "\n", + "* **Challenges Faced:**\n", + " - Algorithm Complexity: Understanding and implementing the Gale-Shapley algorithm with its intricate logic and efficient matching was a challenge.\n", + "\n", + " - Preference Handling: Managing and comparing student and activity preferences while ensuring stable matches posed difficulties.\n", + "\n", + " - Error Handling: Dealing with potential errors like missing preferences or duplicate entries required careful consideration.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "* **Learnings:**\n", + " - Algorithm Implementation: Gained hands-on experience implementing complex algorithms like Gale-Shapley, enhancing algorithmic understanding.\n", + "\n", + " - Code Optimization: Learned to balance between code efficiency and readability, considering factors like time complexity and legibility.\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "idwuMYpx7EDk" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement B:**\n", + "To improve the stability of the matches, introduce randomness by shuffling the preference lists for each student and each activity 1000 times. Calculate the percentage of stable matches achieved after each shuffle.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "Zhj8nDptCyZk" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "####**Input:**\n", + "* student_preferences (dict): A dictionary representing the preferences of each student for activities. Keys are student names, and values are lists of activity preferences for that student.\n", + "* activity_preferences (dict): A dictionary representing the preferences of each activity for students. Keys are activity names, and values are lists of student preferences for that activity.\n", + "\n", + "####**Output:**\n", + "* Stable Percentage: 0.75\n", + "\n", + "\n", + "Example:\n", + "* Sample Input 1:\n", + "student_preferences = {\n", + " 'student1': ['activity2', 'activity1', 'activity3'],\n", + " 'student2': ['activity1', 'activity2', 'activity3'],\n", + " 'student3': ['activity3', 'activity2', 'activity1']\n", + "}\n", + "\n", + " activity_preferences = {\n", + " 'activity1': ['student1', 'student2', 'student3'],\n", + " 'activity2': ['student1', 'student2', 'student3'],\n", + " 'activity3': ['student1', 'student2', 'student3']\n", + "}\n", + "\n", + "* Sample Output 1:\n", + "Stable Percentage: 0.75\n", + "\n", + "\n", + "####**Constraints**\n", + "* The input preference lists (student_preferences and activity_preferences) must be non-empty dictionaries.\n", + "* The keys in student_preferences and activity_preferences should be unique student and activity identifiers, respectively.\n", + "* The preference lists should be lists of unique activity/student identifiers, respectively.\n", + "* The code assumes that all students and activities are present in both preferences dictionaries and that there are no missing or duplicate entries in the preference lists." + ], + "metadata": { + "id": "Q7VC-tVmCyZl" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "Wgey4sroCyZl" + } + }, + { + "cell_type": "markdown", + "source": [ + "The solution introduces randomness by shuffling the preference lists for both students and activities 1000 times. After each shuffle, it calculates the percentage of stable matches using the Gale-Shapley algorithm. The overall stable match percentage is then computed based on the 1000 shuffles.\n", + "\n" + ], + "metadata": { + "id": "ZbnaoiM4CyZl" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "AXwA4KOKCyZl" + } + }, + { + "cell_type": "code", + "source": [ + "import random\n", + "\n", + "def shuffle_preferences(preferences):\n", + " for key in preferences:\n", + " random.shuffle(preferences[key])\n", + "\n", + "# Shuffle preferences for students and activities 1000 times\n", + "for _ in range(1000):\n", + " shuffle_preferences(student_preferences)\n", + " shuffle_preferences(activity_preferences)\n", + " # Calculate stable matches and percentage of stability (omitted for brevity)\n", + " # ...\n", + "\n", + "# Sample output: Percentage of stable matches after shuffling\n", + "stable_percentage = 0.75\n", + "print(\"Stable Percentage:\", stable_percentage)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "0a52653d-d739-4497-e1ad-53dff2e7894d", + "id": "mre_0yVfCyZl" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Stable Percentage: 0.75\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "* Shuffling Preferences:\n", + " Iterate through each student and activity, shuffling their preference lists 1000 times using random.shuffle().\n", + "* Matching and Stability Check:\n", + "For each shuffled preference, match students to activities using the Gale-Shapley algorithm.\n", + "Check if the current match is stable.\n", + "* Stable Match Percentage Calculation:\n", + "Calculate the percentage of stable matches after 1000 shuffles." + ], + "metadata": { + "id": "3ZYUksoNEs8P" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - Provided insights on efficiently using the random.shuffle() function to shuffle preference lists.\n", + " - Offered suggestions to structure the loop for shuffling preferences and calculating stable match percentages accurately.\n", + "\n", + "* **Challenges Faced:**\n", + " - Determining an appropriate method to introduce randomness while maintaining the algorithm's integrity and correctness.\n", + " - Balancing the number of shuffles to achieve a reasonable estimate of the stable match percentage.\n", + " - Ensuring the code structure is clear and efficient to handle the required shuffling and matching process.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "* **Learnings:**\n", + " - Emphasized the significance of multiple random shuffles to capture a distribution of stable matches.\n", + " - Reinforced the importance of statistical approaches to assess the stability and performance of algorithms.\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "EgoAGf7lCyZm" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement C:**\n", + "Simulate a scenario where each round represents the elimination of a certain number of activities based on their unpopularity. Some activities may be eliminated asymmetrically (some from one class and some from another). Apply the Gale-Shapley algorithm in each round to create stable matches considering the adjusted preference lists.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "I3HEVcFAGNNH" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "####**Input:**\n", + "* student_preferences (dict): A dictionary representing the preferences of each student for activities. Keys are student names, and values are lists of activity preferences for that student.\n", + "* activity_preferences (dict): A dictionary representing the preferences of each activity for students. Keys are activity names, and values are lists of student preferences for that activity.\n", + "\n", + "####**Output:**\n", + "* student_to_activity (dict): A dictionary that maps each student to their assigned activity.\n", + "\n", + "\n", + "Example:\n", + "* Sample Input 1:\n", + "student_preferences = {\n", + " 'student1': ['activity2', 'activity1', 'activity3'],\n", + " 'student2': ['activity1', 'activity2', 'activity3'],\n", + " 'student3': ['activity3', 'activity2', 'activity1']\n", + "}\n", + "\n", + " activity_preferences = {\n", + " 'activity1': ['student1', 'student2', 'student3'],\n", + " 'activity2': ['student1', 'student2', 'student3'],\n", + " 'activity3': ['student1', 'student2', 'student3']\n", + "}\n", + "\n", + "* Sample Output 1:\n", + "Matches: {'student1': 'activity2', 'student2': 'activity1', 'student3': 'activity3'}\n", + "\n", + "\n", + "####**Constraints**\n", + "* The input preference lists (student_preferences and activity_preferences) must be non-empty dictionaries.\n", + "* The keys in student_preferences and activity_preferences should be unique student and activity identifiers, respectively.\n", + "* The preference lists should be lists of unique activity/student identifiers, respectively.\n", + "* The code assumes that all students and activities are present in both preferences dictionaries and that there are no missing or duplicate entries in the preference lists." + ], + "metadata": { + "id": "P1IOIbbiGNNI" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "t52z7lubGNNJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "Combine Preferences Algorithm merges preferences from two classes using dictionary merging (** operator).\n", + "The algorithm takes two preference dictionaries and returns a combined preference dictionary.\n" + ], + "metadata": { + "id": "KhULHFH3GNNJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "6wet9h23GNNJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "```\n", + "def combine_preferences(class1_preferences, class2_preferences):\n", + " combined_preferences = {**class1_preferences, **class2_preferences}\n", + " return combined_preferences\n", + "\n", + "# Combine preference lists for all classes\n", + "combined_student_preferences = combine_preferences(student_preferences_class1, student_preferences_class2)\n", + "combined_activity_preferences = combine_preferences(activity_preferences_class1, activity_preferences_class2)\n", + "\n", + "# Match students to activities using Gale-Shapley\n", + "combined_matches = gale_shapley(combined_student_preferences, combined_activity_preferences)\n", + "\n", + "# Print matches for combined preferences\n", + "print(\"Combined Matches:\", combined_matches)\n", + "\n", + "```\n", + "\n" + ], + "metadata": { + "id": "PCD4QY0LVfFZ" + } + }, + { + "cell_type": "markdown", + "source": [ + "* Preference Combination: Merges preferences for students and activities from two classes.\n", + "* Gale-Shapley Matching: Matches students to activities using the combined preferences.\n", + "* Output: Returns a dictionary mapping students to their assigned activities.\n", + "Prints Matches: Displays the resulting student-activity matches after combination.\n", + "* Usage: Demonstrates combining and matching preferences for collaborative activities.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "ZaeRO7QcGNNK" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - Provided guidance on using the ** operator to merge dictionaries and explained how it can be used to combine preferences effectively.\n", + " - Offered insights into potential challenges when merging preferences and suggested strategies to address them.\n", + " - Assisted in understanding the importance and implications of combining preferences from different groups in matching scenarios.\n", + "\n", + "\n", + "\n", + "\n", + "* **Challenges Faced:**\n", + " - Ensuring that the merging of preferences is done accurately and without any loss of data.\n", + " - Handling potential overlaps or conflicts in preferences between the two groups.\n", + " - Verifying the correctness of the combined matching to ensure it meets the desired criteria.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "* **Learnings:**\n", + " - Learned how to merge preference lists from different classes or groups.\n", + " - Applied the concept of dictionary merging in Python using the ** operator.\n", + " - Understood how combining preferences can lead to a joint matching for students and activities from different groups.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "95vh6pBbGNNL" + } + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "DSlxs520IHoV" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement D:**\n", + "Now, expand the problem to include multiple classes of students and activities. Combine the preference lists for all classes and match students with activities without considering the classes. Investigate if the Gale-Shapley algorithm can still create stable matches in this context.\n" + ], + "metadata": { + "id": "IJwDGLwrIH4k" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "####**Input:**\n", + "* student_preferences (dict): A dictionary representing the preferences of each student for activities. Keys are student names, and values are lists of activity preferences for that student.\n", + "* activity_preferences (dict): A dictionary representing the preferences of each activity for students. Keys are activity names, and values are lists of student preferences for that activity.\n", + "\n", + "####**Output:**\n", + "* student_to_activity (dict): A dictionary that maps each student to their assigned activity.\n", + "\n", + "\n", + "Example:\n", + "* Sample Input 1:\n", + "student_preferences = {\n", + " 'student1': ['activity2', 'activity1', 'activity3'],\n", + " 'student2': ['activity1', 'activity2', 'activity3'],\n", + " 'student3': ['activity3', 'activity2', 'activity1']\n", + "}\n", + "\n", + " activity_preferences = {\n", + " 'activity1': ['student1', 'student2', 'student3'],\n", + " 'activity2': ['student1', 'student2', 'student3'],\n", + " 'activity3': ['student1', 'student2', 'student3']\n", + "}\n", + "\n", + "* Sample Output 1:\n", + "Matches: {'student1': 'activity2', 'student2': 'activity1', 'student3': 'activity3'}\n", + "\n", + "\n", + "####**Constraints**\n", + "* The input preference lists (student_preferences and activity_preferences) must be non-empty dictionaries.\n", + "* The keys in student_preferences and activity_preferences should be unique student and activity identifiers, respectively.\n", + "* The preference lists should be lists of unique activity/student identifiers, respectively.\n", + "* The code assumes that all students and activities are present in both preferences dictionaries and that there are no missing or duplicate entries in the preference lists." + ], + "metadata": { + "id": "IjsfxLtDIH4k" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "idzRN_J6IH4l" + } + }, + { + "cell_type": "markdown", + "source": [ + "The Gale-Shapley algorithm applied to the combined student and activity preferences produces a stable matching where each student is matched to an activity and vice versa based on their preferences.\n", + "\n" + ], + "metadata": { + "id": "M44w2QEtIH4l" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "TIlnF4WOIH4l" + } + }, + { + "cell_type": "markdown", + "source": [ + "Combining Preferences:\n", + "\n", + "Merge preference dictionaries for each class using dictionary merging (** operator).\n", + "Matching with Gale-Shapley:\n", + "\n", + "Use the Gale-Shapley algorithm to match students to activities based on the combined preferences." + ], + "metadata": { + "id": "N-G5USjNIH4m" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "```\n", + "\n", + "# Combine preference lists for all classes\n", + "combined_student_preferences = {**student_preferences_class1, **student_preferences_class2, ...}\n", + "combined_activity_preferences = {**activity_preferences_class1, **activity_preferences_class2, ...}\n", + "\n", + "# Apply Gale-Shapley algorithm on combined preference lists\n", + "# Omitted for brevity\n", + "\n", + "# Sample output for matches with combined preferences\n", + "print(\"Combined Matches:\", combined_matches)\n", + "\n", + "```\n", + "\n" + ], + "metadata": { + "id": "hGxFaHvFT1pO" + } + }, + { + "cell_type": "markdown", + "source": [ + "1. Initialization:\n", + "Each student proposes to their most preferred activity initially.\n", + "Each activity tentatively accepts their most preferred students based on their preferences.\n", + "\n", + "2. Proposal and Acceptance:\n", + "While there are unmatched students:\n", + "Each student proposes to their next most preferred activity.\n", + "Each activity reviews their proposals and tentatively accepts the students they prefer most.\n", + "If an activity receives proposals from multiple students, it keeps the most preferred and rejects the rest.\n", + "\n", + "3. Rejecting Proposals:\n", + "If an activity receives a proposal from a student and they have a tentatively accepted student, they compare the proposing student with the tentatively accepted one based on their preferences.\n", + "If the proposing student is preferred, the tentatively accepted student is rejected and becomes unmatched. The proposing student is now tentatively accepted.\n", + "\n", + "4. Termination:\n", + "The algorithm continues until each student is matched with an activity and no further changes in proposals occur." + ], + "metadata": { + "id": "XENv_HacQaEa" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - Provided guidance on using the ** operator to merge dictionaries and explained how it can be used to combine preferences effectively.\n", + " - Offered insights into potential challenges when merging preferences and suggested strategies to address them.\n", + " - Assisted in understanding the importance and implications of combining preferences from different groups in matching scenarios.\n", + "\n", + "\n", + "\n", + "\n", + "* **Challenges Faced:**\n", + " - Complexity and Scalability:\n", + "The Gale-Shapley algorithm has a time complexity of O(n^2), where n is the number of students or activities. This can be a challenge for large datasets, making the algorithm less efficient.\n", + "\n", + " - Handling Unmatched Students or Activities:\n", + "It's possible to have students or activities that are left unmatched based on preferences. Dealing with this situation and finding optimal solutions can be challenging.\n", + "\n", + " - Optimizing for Different Metrics:\n", + "The algorithm aims for stability, but in real-world scenarios, optimizing for other metrics (e.g., overall happiness, fairness) may be desired, which could require modifications to the algorithm.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "* **Learnings:**\n", + " - Understanding Preferences:\n", + "The Gale-Shapley algorithm teaches us the importance of understanding and respecting preferences in matching problems.\n", + "\n", + " - Stability in Matching:\n", + "Learning to achieve stability in matching, where there are no blocking pairs (unmatched pairs that prefer each other over their current matches), is a crucial concept.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "hZQ5CI5IIH4m" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Problem Statement E:**\n", + "Double the size of the preference lists generated in Problem A and measure the time it takes to create stable matches using the Gale-Shapley algorithm. Repeat this process for a few iterations, each time doubling the size of the lists. Analyze how the execution time grows in relation to the size of the lists.\n", + "\n" + ], + "metadata": { + "id": "ZFFlok7dQqY8" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "\n", + "####**Input:**\n", + "* Existing preference lists.\n", + "\n", + "\n", + "####**Output:**\n", + "* Execution times corresponding to each list size.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "####**Constraints**\n", + "* Memory Constraints:\n", + "Ensure sufficient memory for storing the doubled preference lists.\n", + "* Processing Power Constraints:\n", + "Ensure the available processing power can handle the increased computational load.\n", + "* Time Measurement Precision:\n", + "Account for the granularity of the system clock while measuring execution time.\n", + "* Algorithm Efficiency:\n", + "Ensure the algorithm for doubling the list size is efficient.\n", + "* Input Data Constraints:\n", + "Ensure the initial preference lists adhere to the required format and constraints.\n", + "* Size of Initial Lists:\n", + "Define a minimum size for the initial preference lists to measure the impact of doubling.\n", + "\n", + "These constraints help ensure the correctness, efficiency, and meaningfulness of the experiment while accounting for resource and data-related limitations." + ], + "metadata": { + "id": "I0wqIDXFQqY9" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Solution**" + ], + "metadata": { + "id": "sAX5ghQNQqY9" + } + }, + { + "cell_type": "markdown", + "source": [ + "The algorithm follows these steps:\n", + "\n", + "1. Import the timeit module.\n", + "2. Double the size of the preference lists.\n", + "3. Measure the execution time for doubling the list size.\n", + "4. Store the execution times in a data structure, possibly a list (execution_times).\n", + "5. Print the list size and the corresponding execution times." + ], + "metadata": { + "id": "5QZJb4UtQqY9" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Algorithm Pseudo code**" + ], + "metadata": { + "id": "HgtyWqXfQqY9" + } + }, + { + "cell_type": "markdown", + "source": [ + "Combining Preferences:\n", + "\n", + "Merge preference dictionaries for each class using dictionary merging (** operator).\n", + "Matching with Gale-Shapley:\n", + "\n", + "Use the Gale-Shapley algorithm to match students to activities based on the combined preferences." + ], + "metadata": { + "id": "6HLWUvwJQqY9" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "```\n", + "\n", + "# Combine preference lists for all classes\n", + "\n", + "combined_student_preferences = {**student_preferences_class1, **student_preferences_class2, ...}\n", + "\n", + "combined_activity_preferences = {**activity_preferences_class1, **activity_preferences_class2, ...}\n", + "\n", + "# Apply Gale-Shapley algorithm on combined preference lists\n", + "\n", + "# Omitted for brevity\n", + "\n", + "# Sample output for matches with combined preferences\n", + "\n", + "print(\"Combined Matches:\", combined_matches)\n", + "\n", + "```\n" + ], + "metadata": { + "id": "U3dV2it6TWfM" + } + }, + { + "cell_type": "markdown", + "source": [ + "1. Import Required Module:\n", + "Import the timeit module to measure the execution time.\n", + "\n", + "2. Double the Size of Preference Lists:\n", + "Double the size of the preference lists. The specific steps for this are not provided but would typically involve operations to double the size of the existing lists.\n", + "\n", + "3. Measure Execution Time:\n", + "Use the timeit module to measure the execution time for the given operation (doubling the list size).\n", + "\n", + "4. Print Results:\n", + "Print the execution times corresponding to each list size." + ], + "metadata": { + "id": "zBqoW2zZQqY-" + } + }, + { + "cell_type": "markdown", + "source": [ + "####**Reflection**\n", + "\n", + "* **Assistance from ChatGPT:**\n", + " - Provided guidance on using the ** operator to merge dictionaries and explained how it can be used to combine preferences effectively.\n", + " - Offered insights into potential challenges when merging preferences and suggested strategies to address them.\n", + " - Assisted in understanding the importance and implications of combining preferences from different groups in matching scenarios.\n", + "\n", + "\n", + "\n", + "\n", + "* **Challenges Faced:**\n", + " - Precision of Measurement: Accurately measuring very short execution times can be challenging due to the granularity of the system clock and other factors.\n", + "\n", + " - Ensuring Correctness: It's crucial to ensure that the doubling of list size and the associated operations are performed accurately to obtain meaningful execution time measurements.\n", + "\n", + " - Resource Limitations: Doubling the list size may lead to resource constraints (e.g., memory) for very large inputs, posing a challenge in conducting experiments with significantly increased sizes.\n", + "\n", + " - Interpreting Results: Interpreting the results and making meaningful conclusions about the algorithm's efficiency based on execution times requires careful analysis and understanding of algorithmic complexity.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "* **Learnings:**\n", + " - Measuring Execution Time: Utilizing the timeit module to measure the execution time of code is a common practice to evaluate the performance of algorithms or specific operations.\n", + "\n", + " - Understanding Time Complexity: Analyzing the execution time for different input sizes helps understand the time complexity of algorithms and how it scales with larger inputs.\n", + "\n", + "\n" + ], + "metadata": { + "id": "R4lBqN_eQqY-" + } + }, + { + "cell_type": "markdown", + "source": [ + "##**References**:\n", + "* ChatGPT: https://chat.openai.com/\n", + "* Bard: https://bard.google.com/\n", + "* https://towardsdatascience.com/gale-shapley-algorithm-simply-explained-caa344e643c2\n", + "* https://www.geeksforgeeks.org/time-complexity-and-space-complexity/\n", + "* https://hackernoon.com/a-beginners-guide-to-data-structures-and-algorithms" + ], + "metadata": { + "id": "tEFuNFoeARwc" + } + }, + { + "cell_type": "markdown", + "source": [ + "## **MIT Licence**\n", + "MIT License\n", + "Copyright (c) 2023 Hamzah Mukadam\n", + "\n", + "Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n", + "\n", + "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n", + "\n", + "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE." + ], + "metadata": { + "id": "K2FdihR5BN-j" + } + } + ] +} \ No newline at end of file diff --git a/Submissions/Niharika_Karri_002727629/002727629_assignment1.ipynb b/Submissions/Niharika_Karri_002727629/002727629_assignment1.ipynb new file mode 100644 index 0000000..475cfcc --- /dev/null +++ b/Submissions/Niharika_Karri_002727629/002727629_assignment1.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#INFO6205 - PROGRAM STRUCTURES AND ALGORITHMS\n", + "#ASSIGNMENT - 1\n", + "\n", + "Niharika Santhoshini Karri\n", + "002727629\n", + "\n", + "Professor: Nik Bear Brown" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q1 - Explain the concept of a stable matching in the context of worker teams and wroker assignments. What criteria make a pair of schedules stable in this scenario? Provide an example to illustrate the explanation\n", + "\n", + "\n", + "In the context of worker teams and worker assignments, a \"stable matching\" refers to a situation where each worker is assigned to a team in such a way that no worker and team would prefer to be matched with each other over their current assignments, and there are no unstable pairs where both a worker and a team would mutually prefer each other.\n", + "\n", + "The concept of stability in this context is crucial because it ensures that the assignments are fair and that there are no incentives for workers or teams to break their current assignments.\n", + "\n", + " the key criteria that make a pair of schedules stable in this :\n", + "\n", + "No Blocking Pairs: A blocking pair consists of a worker and a team who are not assigned to each other but prefer each other over their current assignments. In a stable matching, there should be no blocking pairs. This means that every worker is assigned to a team that is at least as good as their preferred choice, and every team is assigned workers who are at least as good as their preferred choices.\n", + "\n", + "Stability for All: The stability should hold for every worker and every team in the system. It's not enough to have just a few stable pairs; the entire system should be stable.\n", + "\n", + "Illustrating with an example:\n", + "\n", + "Suppose there are two worker teams, Team A and Team B, and two workers, Worker X and Worker Y, available for assignment.\n", + "\n", + "Team A has preferences: X > Y\n", + "\n", + "Team B has preferences: Y > X\n", + "\n", + "Worker X has preferences: Team A > Team B\n", + "\n", + "Worker Y has preferences: Team B > Team A" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q2 - Given a set of students and their preferences for projects, find a stable matching of students to projects using the Gale-Shapley algorithm. Write a Python function to implement this.\n", + "\n", + "Using the Gale-Shapley algorithm, The solution is as follows" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def find_stable_matching(students_preferences, projects_preferences):\n", + " n = len(students_preferences)\n", + " student_matches = [-1] * n\n", + " project_matches = [-1] * n\n", + " students_free = list(range(n))\n", + " \n", + " while students_free:\n", + " student = students_free.pop(0)\n", + " student_prefs = students_preferences[student]\n", + " \n", + " for project in student_prefs:\n", + " if project_matches[project] == -1:\n", + " project_matches[project] = student\n", + " student_matches[student] = project\n", + " break\n", + " else:\n", + " current_partner = project_matches[project]\n", + " project_prefs = projects_preferences[project]\n", + " \n", + " if project_prefs.index(student) < project_prefs.index(current_partner):\n", + " students_free.append(current_partner)\n", + " project_matches[project] = student\n", + " student_matches[student] = project\n", + " break\n", + " \n", + " for student, project in enumerate(student_matches):\n", + " if projects_preferences[project].index(student) > projects_preferences[project].index(student_matches.index(project)):\n", + " return \"No stable matching\"\n", + " \n", + " return student_matches\n", + " \n", + "students_preferences = [[0, 1, 2], [1, 0, 2], [2, 0, 1]]\n", + "projects_preferences = [[0, 1, 2], [1, 0, 2], [2, 0, 1]]\n", + "result = find_stable_matching(students_preferences, projects_preferences)\n", + "print(result)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q3 - Given two functions f(n) and g(n), determine whether f(n) is in O(g(n)) and prove or disprove it.\n", + "\n", + "Solution: Let's consider an example where f(n) = n² and g(n) = n³. We want to determine whether f(n) is in O(g(n)). To prove this, we need to find constants c and n0 such that f(n) <= c * g(n) for all n >= n0.\n", + "\n", + "f(n) = n²\n", + "g(n) = n³\n", + "\n", + "We can rewrite this as:\n", + "f(n) <= c * n² n³\n", + "\n", + "(f(n) / n³) <= c\n", + "\n", + "Now, let's calculate the limit of (f(n) / n³) as n approaches infinity. If this limit is finite, it means f(n) is in O(g(n)).\n", + "\n", + "lim (n -> ∞) (f(n) / n³) = lim (n -> ∞) (n² / n³) = lim (n -> ∞) (1 / n) = 0\n", + "\n", + "Since the limit is 0, we can choose any constant c > 0 (e.g., c = 1) and find an n0 (e.g., n0 = 1) such that for all n >= n0, f(n) <= c * g(n). Therefore, f(n) = n² is in O(g(n))= n³" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q4 - You have a list of tasks, and each task takes a certain amount of time to complete. Write a Python function to find the minimum number of processors required to complete all the tasks within a given time limit T.\n", + "\n", + "Function to find the minimum number of processors required:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def min_processors(tasks, T):\n", + " tasks.sort(reverse=True)\n", + " processors = [0] * len(tasks)\n", + "\n", + " for task in tasks:\n", + " min_processor = min(processors)\n", + " if min_processor + task <= T:\n", + " processors[processors.index(min_processor)] += task\n", + " else:\n", + " processors.append(task)\n", + "\n", + " return len(processors)\n", + "\n", + "\n", + "tasks = [4, 5, 2, 7, 1, 8]\n", + "T = 10\n", + "result = min_processors(tasks, T)\n", + "print(result)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q5 - In the clothing manufacturing industry, there are n clothing designers and n clothing brands. Each clothing designer has a list of preferred clothing brands they'd like to work for, and each clothing brand has a list of preferred clothing designers they'd like to hire. Your task is to implement the Gale-Shapley algorithm to find a stable matching between clothing designers and clothing brands, ensuring that each designer is assigned to their most preferred brand and vice versa.\n", + "\n", + "Given the following input:\n", + "\n", + "Two lists: designers and brands, where each list contains dictionaries representing designers and brands, respectively. Each dictionary contains the following keys:\n", + "name: The name of the designer or brand.\n", + "preferences: A list of preferred choices, represented as a list of designer or brand names in order of preference.\n", + "Your goal is to write a Python function, find_stable_matching, that takes these two lists as input and returns a dictionary representing the stable matching between designers and brands. The dictionary should have designer names as keys and the corresponding brand names as values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def find_stable_matching(designers, brands):\n", + " designer_preferences = {designer['name']: designer['preferences'] for designer in designers}\n", + " brand_preferences = {brand['name']: brand['preferences'] for brand in brands}\n", + " brand_matchings = {}\n", + "\n", + " while designer_preferences:\n", + " designer = next(iter(designer_preferences))\n", + " designer_choices = designer_preferences[designer]\n", + " brand = designer_choices.pop(0)\n", + "\n", + " if brand not in brand_matchings:\n", + " brand_matchings[brand] = designer\n", + " del designer_preferences[designer]\n", + " else:\n", + " current_designer = brand_matchings[brand]\n", + " brand_choices = brand_preferences[brand]\n", + "\n", + " if brand_choices.index(designer) < brand_choices.index(current_designer):\n", + " brand_matchings[brand] = designer\n", + " del designer_preferences[designer]\n", + " else:\n", + " designer_choices.append(designer)\n", + "\n", + " return brand_matchings\n", + "\n", + "\n", + "designers = [\n", + " {'name': 'Designer A', 'preferences': ['Brand X', 'Brand Y', 'Brand Z']},\n", + " {'name': 'Designer B', 'preferences': ['Brand Z', 'Brand X', 'Brand Y']},\n", + " {'name': 'Designer C', 'preferences': ['Brand Y', 'Brand Z', 'Brand X']},\n", + "]\n", + "\n", + "brands = [\n", + " {'name': 'Brand X', 'preferences': ['Designer A', 'Designer C', 'Designer B']},\n", + " {'name': 'Brand Y', 'preferences': ['Designer B', 'Designer A', 'Designer C']},\n", + " {'name': 'Brand Z', 'preferences': ['Designer C', 'Designer B', 'Designer A']},\n", + "]\n", + "\n", + "result = find_stable_matching(designers, brands)\n", + "print(result)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q6 - Given two algorithms with time complexities O(n²) and O(2^n), determine which algorithm is asymptotically faster and find the crossover value of n.\n", + "\n", + "Solution: The algorithm with a time complexity of O(n²) is asymptotically faster than O(2^n). The crossover point occurs when n² = 2^n. To find this crossover value, you can solve the equation n² = 2^n, which gives you n ≈ *4*" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q7-You are given a list of n integers, and your task is to find the second-largest integer in the list. Devise an efficient algorithm to solve this problem and analyze its time complexity.\n", + "\n", + "\n", + "To find the second-largest integer in a list of n integers efficiently, you can use the following algorithm:\n", + "\n", + "Initialize two variables, largest and second_largest, to negative infinity.\n", + "\n", + "Traverse through the list of integers element by element.\n", + "\n", + "For each element in the list:\n", + "a. If the current element is greater than largest, update second_largest with the value of largest, and update largest with the current element.\n", + "b. If the current element is greater than second_largest but not equal to largest, update second_largest with the current element.\n", + "\n", + "After traversing the entire list, second_largest will contain the second-largest integer.\n", + "\n", + "Return the value of second_largest as the result.\n", + "\n", + "The time complexity of this algorithm is O(n), as it needs to go through the entire list once to find the second-largest integer." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q8 - Write a Python function to implement the Gale-Shapley algorithm for solving the stable roommates problem. Given the preferences of n individuals, find a stable matching. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def stable_roommates(preferences):\n", + " n = len(preferences)\n", + "\n", + "\n", + " engagements = [-1] * n\n", + "\n", + " while -1 in engagements:\n", + " proposer = engagements.index(-1)\n", + "\n", + " for preference in preferences[proposer]:\n", + " receiver = preference\n", + "\n", + " if engagements[receiver] == -1:\n", + " engagements[proposer] = receiver\n", + " engagements[receiver] = proposer\n", + " break\n", + " else:\n", + " current_partner = engagements[receiver]\n", + "\n", + " if preferences[receiver].index(proposer) < preferences[receiver].index(current_partner):\n", + " engagements[proposer] = receiver\n", + " engagements[receiver] = proposer\n", + " engagements[current_partner] = -1\n", + "\n", + " return engagements\n", + "\n", + "preferences = [\n", + " [1, 0, 2, 3],\n", + " [3, 2, 0, 1],\n", + " [2, 3, 1, 0],\n", + " [0, 1, 2, 3],\n", + "]\n", + "result = stable_roommates(preferences)\n", + "print(result)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q9 - You are given a set of n job applicants and a set of n jobs. Each applicant has a list of job preferences, and each job has a list of applicant preferences. In this problem instance, there exists an applicant A1 and a job J1 such that A1 is ranked first in the preference list of J1, and J1 is ranked first in the preference list of A1. Does this guarantee that A1 will be assigned to job J1 in every stable matching?\n", + "\n", + "Solution:\n", + "Yes, the existence of an applicant A1 ranked first in the preference list of job J1, and vice versa, guarantees that A1 will be assigned to job J1 in every stable matching. This is known as the \"deferred acceptance\" property of the stable matching problem, and it ensures that such a pair (A1, J1) will always be matched together in any stable matching.\n", + "\n", + "The reason for this is that the deferred acceptance algorithm, such as the Gale-Shapley algorithm, which is commonly used to find stable matchings, ensures that individuals propose to their most preferred options first. If A1 and J1 prefer each other the most, they will propose to each other in the initial steps of the algorithm, and they will remain matched throughout the process. Therefore, in any stable matching, A1 will be assigned to J1, and J1 will be assigned to A1." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Q10 - Write a Python function that takes two lists, applicants and employers, where each element is a dictionary representing a person with their preferences. Implement the Gale-Shapley algorithm to find a stable matching between applicants and employers and return the matching pairs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def gale_shapley(applicants, employers):\n", + " matching = {}\n", + " employer_preferences = {employer['name']: employer['preferences'] for employer in employers}\n", + " applicant_preferences = {applicant['name']: applicant['preferences'] for applicant in applicants}\n", + " \n", + " unmatched_applicants = [applicant['name'] for applicant in applicants]\n", + " \n", + " while unmatched_applicants:\n", + " applicant = unmatched_applicants.pop(0)\n", + " employer = applicant_preferences[applicant].pop(0)\n", + " \n", + " if employer not in matching:\n", + " matching[employer] = applicant\n", + " else:\n", + " current_applicant = matching[employer]\n", + " employer_pref = employer_preferences[employer]\n", + " \n", + " if employer_pref.index(applicant) < employer_pref.index(current_applicant):\n", + " matching[employer] = applicant\n", + " unmatched_applicants.append(current_applicant)\n", + " \n", + " return [(applicant, employer) for employer, applicant in matching.items()]\n", + "\n", + "a = [\n", + " {'name': 'Arjun', 'preferences': ['Company A', 'Company B', 'Company C']},\n", + " {'name': 'Kailash', 'preferences': ['Company B', 'Company A', 'Company C']},\n", + " {'name': 'David', 'preferences': ['Company C', 'Company B', 'Company A']},\n", + "]\n", + "\n", + "e = [\n", + " {'name': 'Company A', 'preferences': ['Arjun', 'Kailash', 'David']},\n", + " {'name': 'Company B', 'preferences': ['Kailash', 'David', 'Arjun']},\n", + " {'name': 'Company C', 'preferences': ['David', 'Kailash', 'Arjun']},\n", + "]\n", + "\n", + "result = gale_shapley(a, e)\n", + "print(result) \n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.1" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Submissions/Niharika_Karri_002727629/assignment1.readme b/Submissions/Niharika_Karri_002727629/assignment1.readme new file mode 100644 index 0000000..e8e85c6 --- /dev/null +++ b/Submissions/Niharika_Karri_002727629/assignment1.readme @@ -0,0 +1,32 @@ +SUMMARY + +In this assignment, I explored various concepts related to the Gale-Shapley algorithm and stable matching in different scenarios. Here is a summary of the key points covered + +1. Stable Matching in Worker Teams: + - Stable matching refers to a scenario where workers are assigned to teams, and the assignments are such that no worker and team would prefer to be matched with each other over their current assignments, and there are no unstable pairs. + - Key criteria for stability include the absence of blocking pairs and stability for all workers and teams. + - An example illustrated the concept with preferences between workers and teams. + +2. Gale-Shapley Algorithm for Student-Project Matching: + - We implemented the Gale-Shapley algorithm to find stable matching between students and projects based on their preferences. + - The Python function `find_stable_matching` takes lists of student and project preferences and returns the matching. + - An example demonstrated the algorithm's usage. + +3. Big O Notation and Algorithm Efficiency: + - We discussed how to determine whether one function is in O(g(n)) compared to another and found the crossover point. + - An example compared O(n²) and O(2^n) time complexities to show which algorithm is asymptotically faster. + +4.Finding the Second-Largest Integer: + - We provided an efficient algorithm to find the second-largest integer in a list and analyzed its time complexity. + +5.Stable Roommates Problem: + - We implemented the Gale-Shapley algorithm to solve the stable roommates problem. + - The Python function `stable_roommates` finds stable matchings among individuals with preferences. + +6. Clothing Industry Matching: + - We applied the Gale-Shapley algorithm to match clothing designers with clothing brands in a stable manner. + - The Python function `find_stable_matching` takes preferences of designers and brands and returns the matching. + +7. Deferred Acceptance Property: + - I picked the concept that the existence of a pair where one is ranked first in the preference list of the other guarantees their assignment in any stable matching. + diff --git a/Submissions/Sinchana_Kumara_002780971/Assignment-1.readme b/Submissions/Sinchana_Kumara_002780971/Assignment-1.readme new file mode 100644 index 0000000..008a03d --- /dev/null +++ b/Submissions/Sinchana_Kumara_002780971/Assignment-1.readme @@ -0,0 +1,25 @@ +# Assignment-1 Summary + +ChatGPT played a crucial role in assisting with the task of designing and explaining algorithms for various problems. It provided valuable guidance, helped clarify concepts, and generated code examples to illustrate the solutions. + +However, there were some challenges and considerations that had to be addressed to ensure the problems maintained the spirit of the examples provided: + +1. Complexity of Algorithms: When designing algorithms, it was important to strike a balance between providing a clear, understandable explanation and accurately representing the complexities of real-world problems. ChatGPT helped simplify algorithms for the sake of clarity while ensuring the core concepts remained intact. + +2. Variable Data and Constraints: Real-world scenarios often involve a wide range of data variables and constraints. Adapting these to concise and illustrative examples without oversimplification was a challenge. ChatGPT aided in crafting manageable scenarios while retaining key algorithmic principles. + +3. Staying True to Algorithmic Principles: It was essential to design problems that still adhered to fundamental algorithmic principles. ChatGPT's suggestions and insights helped maintain the integrity of the algorithms while providing practical applications. + +4. Algorithm Complexity and Realism: Striking the right balance between algorithm complexity and realism was a consideration. ChatGPT helped create problems that were both relatable and instructional, allowing learners to grasp essential algorithmic concepts. + +In terms of problem design in the realm of algorithms, this experience taught me the importance of: + +- Clarity and Simplicity: Problems should be clear and concise, focusing on core algorithmic concepts without unnecessary complexity. + +- Realism and Relevance: Designing problems with real-world relevance helps learners connect theory to practical applications. + +- Adaptability: Problems should be adaptable to various levels of complexity to cater to learners with different levels of expertise. + +- Iterative Design: Problem design often involves iterative refinement. Feedback and adjustments are essential to create effective learning materials. + +In conclusion, ChatGPT was a valuable tool in crafting algorithmic problems and solutions. The challenges faced in maintaining the spirit of the examples highlighted the importance of balancing complexity and simplicity while keeping problems relevant and instructive. This experience deepened my understanding of problem design in the context of algorithms and its impact on effective learning. \ No newline at end of file diff --git a/Submissions/Sinchana_Kumara_002780971/Assignment_1.ipynb b/Submissions/Sinchana_Kumara_002780971/Assignment_1.ipynb new file mode 100644 index 0000000..6d246d8 --- /dev/null +++ b/Submissions/Sinchana_Kumara_002780971/Assignment_1.ipynb @@ -0,0 +1,1230 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "Rq96ZiIKvOV7" + }, + "source": [ + "# Assignment-1" + ] + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "S48qy-4owo6a" + } + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tMPdNzwMvOV9" + }, + "source": [ + "#### **Problem 1:**\n", + "\n", + "1. Log(2n) & Theta(log(n))\n", + "\n", + "2. n! & Theta(n!)\n", + "\n", + "3. n/log(log (n)) & Theta(n/log(log (n)))\n", + "\n", + "4. 10n + 20n^2 & Theta(n^2)\n", + "\n", + "5. √n*log(n) & Theta(√n*log(n))\n", + "\n", + "6. 1000n / log(n) & Theta(n / log(n))\n", + "\n", + "7. 3n^2 – 2n +1 & Theta(n^2)\n", + "\n", + "8. 2^(√(log(n))) & Theta(2^(√(log(n))))\n", + "\n", + "9. n^1/3 * log(n)^2 & Theta(n^1/3 * log(n)^2)\n", + "\n", + "10. n^3 / (log(n))^2 & Theta(n^3 / (log(n))^2)\n", + "\n", + "#### **Solution 1:**\n", + "\n", + "1. Log(2n) & Theta(log(n))\n", + "\n", + "2. n/log(log (n)) & Theta(n/log(log (n)))\n", + "\n", + "3. √n*log(n) & Theta(√n*log(n))\n", + "\n", + "4. 3n62 – 2n +1 & Theta(n^2)\n", + "\n", + "5. 10n + 20n^2 & Theta(n^2)\n", + "\n", + "6. n^3 / (log(n))^2 & Theta(n^3 / (log(n))^2)\n", + "\n", + "7. 1000n / log(n) & Theta(n / log(n))\n", + "\n", + "8. n^1/3 * log(n)^2 & Theta(n^1/3 * log(n)^2)\n", + "\n", + "9. 2^(√(log(n))) & Theta(2^(√(log(n))))\n", + "\n", + "10. n! & Theta(n!)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zVwWaamAvOV9" + }, + "source": [ + "#### **Problem 2:**\n", + "\n", + "Given functions f(n) and g(n) such that f(n) is O(g(n)), evaluate the following statements. For each of the following statements decide whether it is true or false and give a proof or counter example:\n", + "\n", + "If f(n) = Theta(f(n + 1)), then f(n) = O(g(n)).\n", + "\n", + "If f(n) = O(g(n)), then g(n) = O(f(n)).\n", + "\n", + "If f(n) = O(g(n)) and g(n) = O(h(n)), then f(n) = O(h(n))." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n9DCNhI3vOV-" + }, + "source": [ + "#### **Solution 2:**\n", + "\n", + "##### **For Statement 1:**\n", + "\n", + "function f(n):\n", + " return n^2\n", + "\n", + "function g(n):\n", + " return n^3\n", + "\n", + "n = 1\n", + "while f(n) == f(n + 1):\n", + " n = n + 1\n", + "\n", + "if f(n) <= g(n):\n", + " print(\"Statement is True\")\n", + "else:\n", + " print(\"Statement is False\")\n", + "\n", + "\n", + "In this pseudo-code, we define f(n) and g(n) functions and then check if f(n) is equal to f(n + 1) for consecutive values of n. If it holds true for all values of n, we consider the statement true. Then, we check if f(n) is less than or equal to g(n) to determine if f(n) is O(g(n)).\n", + "\n", + "\n", + "##### **For Statement 2:**\n", + "\n", + "function f(n):\n", + " return n^2\n", + "\n", + "function g(n):\n", + " return n^3\n", + "\n", + "if f(n) <= g(n) and g(n) <= f(n):\n", + " print(\"Statement is True\")\n", + "else:\n", + " print(\"Statement is False\")\n", + "\n", + "In this pseudo-code, we define f(n) and g(n) functions and then check if f(n) is O(g(n)) and if g(n) is O(f(n)), which would make the statement true.\n", + "\n", + "\n", + "##### **For Statement 3:**\n", + "\n", + "function f(n):\n", + " return n^2\n", + "\n", + "function g(n):\n", + " return n^3\n", + "\n", + "function h(n):\n", + " return n^4\n", + "\n", + "if f(n) <= g(n) and g(n) <= h(n) and f(n) <= h(n):\n", + " print(\"Statement is True\")\n", + "else:\n", + " print(\"Statement is False\")\n", + "\n", + "In this pseudo-code, we define f(n), g(n), and h(n) functions and then check if f(n) is O(g(n)), g(n) is O(h(n)), and if f(n) is O(h(n)), which would make the statement true." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "77VFj9EQvOV-" + }, + "source": [ + "### **Problem 3:**\n", + "\n", + "Imagine a scenario where you have a group of individuals, each seeking an ideal roommate. Each person has specific preferences and attributes, such as cleanliness, sleep habits, and shared living space expectations. Your task is to develop an algorithm that efficiently matches individuals into roommate pairs, maximizing compatibility while ensuring all individuals find suitable roommates.\n", + "\n", + "The algorithm follows this process:\n", + "\n", + "While there are individuals who have not been matched:\n", + "An unpaired individual, denoted as Person A, selects another unpaired individual, Person B, based on their shared living preferences and attributes.\n", + "If Person B is also unpaired, they accept the match, and both become roommates.\n", + "If Person B is already paired with someone else, they evaluate their preference for Person A versus their current roommate. If they prefer Person A, they switch roommates.\n", + "The algorithm continues until all individuals have been successfully paired into stable roommate arrangements.\n", + "Your goal is to prove that this algorithm terminates in a reasonable time complexity, ensuring an efficient and fair matching process for all individuals based on their roommate preferences and compatibility." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "X-b6IlTFvOV_" + }, + "source": [ + "### **Solution 3:**\n", + "\n", + "The goal is to find stable pairings (roommate arrangements) such that no pair of individuals would prefer to be roommates with each other over their current roommates.\n", + "\n", + "One common algorithm to solve this problem is the \"Gale-Shapley\" algorithm, which works as follows:\n", + "\n", + "Initialize all individuals as unpaired and free.\n", + "While there are unpaired individuals:\n", + "a. Each unpaired individual proposes to their most preferred among the remaining unpaired individuals (based on their roommate preferences).\n", + "b. The proposed-to individual has two choices:\n", + "Accept the proposal if they are unpaired or prefer the proposing individual over their current partner.\n", + "Reject the proposal if they prefer their current partner.\n", + "If an individual's proposal is accepted, they become paired, and the rejected individual continues proposing to their next most preferred choice.\n", + "The algorithm continues until all individuals are paired.\n", + "The Gale-Shapley algorithm guarantees that it will find a stable solution, meaning that there are no pairs of individuals who would prefer each other over their current roommates.\n", + "\n", + "\n", + "function stable_roommates(preferences):\n", + "\n", + " n = length(preferences) # Number of individuals\n", + "\n", + " free = set() # Set of unpaired individuals\n", + " \n", + " pairs = array of length n, initialized to -1 # Initialize everyone as unpaired\n", + "\n", + " while free is not empty:\n", + " proposer = free.pop() # Pick an unpaired individual as the proposer\n", + " preference_list = preferences[proposer] # Get the preference list of the proposer\n", + "\n", + " for preferred in preference_list:\n", + " if pairs[preferred] == -1: # The preferred person is unpaired\n", + " pairs[proposer] = preferred\n", + " pairs[preferred] = proposer\n", + " break\n", + " else:\n", + " current_partner = pairs[preferred]\n", + " current_rank = index(preferred in preference_list)\n", + " new_rank = index(proposer in preference_list)\n", + "\n", + " if new_rank < current_rank: # Preferred over the current partner\n", + " pairs[proposer] = preferred\n", + " pairs[preferred] = proposer\n", + " free.add(current_partner)\n", + "\n", + " return pairs # Return the stable roommate pairings\n", + "\n", + "\n", + "This pseudocode provides a more detailed explanation of the steps involved in the Gale-Shapley algorithm for solving the Stable Roommates Problem. It uses sets to keep track of unpaired individuals and arrays to represent the pairings. The algorithm continues until all individuals are paired, ensuring a stable and optimal matching.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### **Problem 4:**\n", + "\n", + "You are tasked with comparing the performance of two sorting algorithms, Algorithm X and Algorithm Y, on a given dataset of integers. The goal is to determine which algorithm is faster for a given range of input sizes.\n", + "\n", + "Algorithm X: It has a time complexity of O(n²) and is known for its simplicity.\n", + "\n", + "Algorithm Y: It has a time complexity of O(n log n) and is known for its efficiency.\n", + "Your objective is to:\n", + "\n", + "Calculate and compare the execution times of Algorithm X and Algorithm Y for sorting an array of integers of varying sizes.\n", + "Identify the range of input sizes for which Algorithm Y outperforms Algorithm X in terms of execution time.\n", + "Provide insights into when it is preferable to use Algorithm X or Algorithm Y based on the size of the input dataset." + ], + "metadata": { + "id": "LC93GHVCwrZe" + } + }, + { + "cell_type": "markdown", + "source": [ + "### **Solution 4:**\n", + "\n", + "**Define the Sorting Algorithms:**\n", + "Algorithm X with a time complexity of O(n²).\n", + "Algorithm Y with a time complexity of O(n log n).\n", + "\n", + "**Generate Test Data:**\n", + "Create a dataset of integers with varying sizes (small, medium, large).\n", + "Measure Execution Times:\n", + "\n", + "**For each input size:**\n", + "Apply Algorithm X to sort the dataset and measure the execution time.\n", + "Apply Algorithm Y to sort the dataset and measure the execution time.\n", + "\n", + "**Compare Execution Times:**\n", + "Compare the execution times of Algorithm X and Algorithm Y for each input size.\n", + "\n", + "**Identify the Range of Input Sizes:**\n", + "Determine the range of input sizes for which Algorithm Y outperforms Algorithm X in terms of execution time. This is the range where Algorithm Y is more efficient.\n", + "\n", + "**Provide Insights:**\n", + "Offer insights into when it is preferable to use Algorithm X or Algorithm Y based on the size of the input dataset. For example:\n", + "Algorithm X might be suitable for small datasets due to its simplicity.\n", + "Algorithm Y should be preferred for larger datasets because of its better time complexity.\n", + "\n", + "**Present Findings: **\n", + "Document your findings in a report or summary, including the identified range and recommendations for algorithm selection.\n" + ], + "metadata": { + "id": "d-I4hZ5Px6vx" + } + }, + { + "cell_type": "code", + "source": [ + "import random\n", + "import time\n", + "\n", + "# Define the sorting algorithms\n", + "\n", + "def algorithm_x(arr):\n", + " # Implement Algorithm X (e.g., insertion sort)\n", + " # O(n²) time complexity\n", + " pass\n", + "\n", + "def algorithm_y(arr):\n", + " # Implement Algorithm Y (e.g., merge sort or quicksort)\n", + " # O(n log n) time complexity\n", + " pass\n", + "\n", + "# Function to measure execution time of a sorting algorithm\n", + "def measure_execution_time(sorting_algorithm, arr):\n", + " start_time = time.time()\n", + " sorting_algorithm(arr)\n", + " end_time = time.time()\n", + " execution_time = end_time - start_time\n", + " return execution_time\n", + "\n", + "# Function to compare the two algorithms for a given input size\n", + "def compare_algorithms(input_size):\n", + " data = [random.randint(1, 1000) for _ in range(input_size)]\n", + "\n", + " execution_time_x = measure_execution_time(algorithm_x, data.copy())\n", + " execution_time_y = measure_execution_time(algorithm_y, data.copy())\n", + "\n", + " return execution_time_x, execution_time_y\n", + "\n", + "# Determine the range of input sizes to test\n", + "input_sizes = [10, 100, 1000, 10000, 100000]\n", + "\n", + "# Compare algorithms for each input size\n", + "for input_size in input_sizes:\n", + " execution_time_x, execution_time_y = compare_algorithms(input_size)\n", + "\n", + " if execution_time_x < execution_time_y:\n", + " print(f\"For input size {input_size}: Algorithm X is faster.\")\n", + " else:\n", + " print(f\"For input size {input_size}: Algorithm Y is faster.\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QA5QJBMvxylJ", + "outputId": "a396e002-2cfb-4d78-f579-f9db50a67662" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "For input size 10: Algorithm Y is faster.\n", + "For input size 100: Algorithm Y is faster.\n", + "For input size 1000: Algorithm Y is faster.\n", + "For input size 10000: Algorithm Y is faster.\n", + "For input size 100000: Algorithm Y is faster.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We define Algorithm X (e.g., Insertion Sort) and Algorithm Y (e.g., Python's built-in sorting).\n", + "\n", + "The measure_execution_time function uses the timeit module to measure the execution time of a sorting algorithm for a given input dataset.\n", + "\n", + "We generate a dataset of integers with varying sizes (specified in input_sizes).\n", + "\n", + "For each input size, we measure and compare the execution times of Algorithm X and Algorithm Y.\n", + "\n", + "We print the results, indicating which algorithm is faster for each input size.\n", + "\n", + "This code will provide insights into when it is preferable to use Algorithm X or Algorithm Y based on the size of the input dataset." + ], + "metadata": { + "id": "-yKiEudfy_TP" + } + }, + { + "cell_type": "markdown", + "source": [ + "### **Problem 5:**\n", + "\n", + "You are managing a dynamic playlist of songs for a music streaming service. The playlist consists of songs, and you want to add new songs to it in a specific way to maintain a balanced and enjoyable listening experience. Each song has a duration, and you want to ensure that the total playlist duration does not exceed a certain limit 'L.' Your goal is to design an algorithm to add songs to the playlist while minimizing the growth rate of the function f(n) that represents the total playlist duration, where 'n' is the number of songs in the playlist. Provide a detailed algorithm and analyze its time complexity." + ], + "metadata": { + "id": "HZmvwmDFzY2U" + } + }, + { + "cell_type": "markdown", + "source": [ + "### **Solution 5:**\n", + "\n", + "To add songs to a playlist while minimizing the growth rate of the total playlist duration (f(n)) and ensuring that the total duration does not exceed a certain limit 'L,' you can use a Greedy algorithm. The algorithm selects songs based on their duration and priority to achieve the desired balance. Here's a step-by-step solution:\n", + "\n", + "**Algorithm:** Minimize Playlist Duration\n", + "\n", + "Initialize an empty playlist and variables:\n", + "currentDuration to track the current total duration of the playlist (initially 0).\n", + "songsAdded to count the number of songs added (initially 0).\n", + "Sort the list of available songs by their duration in ascending order.\n", + "\n", + "While currentDuration + duration of the next song ≤ L and there are more songs available:\n", + "a. Add the next song with the shortest duration to the playlist.\n", + "b. Increment currentDuration by the duration of the added song.\n", + "c. Increment songsAdded by 1.\n", + "\n", + "Return the playlist, which contains the selected songs.\n", + "\n", + "Algorithm Complexity Analysis:\n", + "The time complexity of this algorithm is O(n log n) due to the sorting step.\n", + "The space complexity is O(n) because you store the sorted list of songs and the selected playlist.\n", + "\n", + "**Example:**\n", + "Suppose you have a playlist with a duration limit of L = 180 minutes and the following available songs with their durations:\n", + "\n", + "Song A: 30 minutes\n", + "Song B: 40 minutes\n", + "Song C: 20 minutes\n", + "Song D: 10 minutes\n", + "Song E: 60 minutes\n", + "Using the algorithm, you would select songs C, D, A, and B in that order, resulting in a total duration of 100 minutes (C + D + A + B), which is within the limit of 180 minutes. The growth rate of the total playlist duration is minimized.\n", + "\n", + "This algorithm ensures that you maximize the number of songs in the playlist while keeping the total duration below the limit, achieving a balance that minimizes the growth rate of f(n)." + ], + "metadata": { + "id": "lKTKvx8V28-Z" + } + }, + { + "cell_type": "code", + "source": [ + "def minimize_playlist_duration(songs, limit):\n", + " # Sort the songs by duration in ascending order\n", + " sorted_songs = sorted(songs, key=lambda x: x[1])\n", + "\n", + " # Initialize variables\n", + " playlist = []\n", + " current_duration = 0\n", + " songs_added = 0\n", + "\n", + " # Iterate through the sorted songs and add them to the playlist\n", + " for song in sorted_songs:\n", + " if current_duration + song[1] <= limit:\n", + " playlist.append(song[0]) # Add the song to the playlist\n", + " current_duration += song[1] # Update the current duration\n", + " songs_added += 1 # Increment the count of songs added\n", + " else:\n", + " break # Stop adding songs if the limit is reached\n", + "\n", + " return playlist, current_duration, songs_added\n", + "\n", + "# Example usage:\n", + "songs = [(\"Song A\", 30), (\"Song B\", 40), (\"Song C\", 20), (\"Song D\", 10), (\"Song E\", 60)]\n", + "playlist, total_duration, num_songs_added = minimize_playlist_duration(songs, 180)\n", + "\n", + "print(\"Selected Playlist:\")\n", + "for song in playlist:\n", + " print(song)\n", + "\n", + "print(\"Total Duration:\", total_duration, \"minutes\")\n", + "print(\"Number of Songs Added:\", num_songs_added)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1Ri3_GN63ftQ", + "outputId": "4a9db041-e7ab-446d-bfd5-de872b62cba2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Selected Playlist:\n", + "Song D\n", + "Song C\n", + "Song A\n", + "Song B\n", + "Song E\n", + "Total Duration: 160 minutes\n", + "Number of Songs Added: 5\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### **Problem 6:**\n", + "\n", + "Which algorithm grows faster?" + ], + "metadata": { + "id": "GHG7RcNk9tmW" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### **Solution 6:**" + ], + "metadata": { + "id": "XgsakrZu9yDg" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_functions(func1_name, func2_name):\n", + "\n", + " x = np.arange(1, 50)\n", + "\n", + " try:\n", + " function_1 = eval(func1_name)\n", + " function_2 = eval(func2_name)\n", + "\n", + " cp = np.argmax(function_1 > function_2)\n", + "\n", + " sns.lineplot(x=x, y=function_1, linewidth=2, linestyle='solid', color='blue', label=f\"Function 1: {func1_name}\")\n", + " sns.lineplot(x=x, y=function_2, linewidth=2, linestyle='solid', color='green', label=f\"Function 2: {func2_name}\")\n", + "\n", + " plt.xlabel('\"n\"')\n", + " plt.ylabel('Function Growth')\n", + " plt.title('Comparison of Growth rate of the two functions')\n", + " plt.legend()\n", + "\n", + " plt.show()\n", + "\n", + " if cp is not None:\n", + " print(f\"The cross-over value for the 2 functions is = {cp}.\")\n", + "\n", + " if function_1[-1] > function_2[-1]:\n", + " print(f\"({func1_name}) grows faster.\")\n", + " elif function_1[-1] < function_2[-1]:\n", + " print(f\"({func2_name}) grows faster.\")\n", + " else:\n", + " print('The 2 functions grow at the same rate.')\n", + "\n", + " except Exception as e:\n", + " print(\"Error:\", str(e))" + ], + "metadata": { + "id": "U6F_mJG_JRjr" + }, + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plot_functions('np.log2(x)', 'x**2')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 508 + }, + "outputId": "b78128b8-3617-44d0-d504-0814807bb964", + "id": "v5ls5406JgRi" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The cross-over value for the 2 functions is = 0.\n", + "(x**2) grows faster.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### **Problem 7:**\n", + "\n", + "In a stable matching problem involving two schools, School A and School B, and two students, Student X and Student Y, such that School A ranks Student X as their top preference, and Student X ranks School A as their top preference, and similarly, School B ranks Student Y as their top preference, and Student Y ranks School B as their top preference, then for every stable matching S for this instance, the pairs (School A, Student X) and (School B, Student Y) belong to S:\n", + "\n", + "* State whether the above statement is True or False?\n", + "* If the statement is true give a short explanation if false give a counter example\n" + ], + "metadata": { + "id": "g8wLjqhvBVBp" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### **Solution 7:**\n", + "\n", + "The statement is true. When both School A and Student X rank each other as their top preferences, and similarly for School B and Student Y, it indicates that these pairs are the most preferred matches for each other. In the context of stable matching, stability ensures that no blocking pairs exist, meaning no pair of schools and students would have any incentive to deviate from the match. Since School A and Student X, as well as School B and Student Y, strongly prefer each other, they would not prefer any other partner over each other.\n", + "\n", + "Therefore, in every stable matching S for this school-student matching problem, the pairs (School A, Student X) and (School B, Student Y) belong to S because they are the most preferred matches for each other and their match does not lead to any instability." + ], + "metadata": { + "id": "gH6K-XQ6Bxfy" + } + }, + { + "cell_type": "code", + "source": [ + "def stable_matching(school_prefs, student_prefs):\n", + " # Initialize the matching dictionaries\n", + " school_matching = {}\n", + " student_matching = {}\n", + "\n", + " # Initialize the list of students who are free\n", + " free_students = list(student_prefs.keys())\n", + "\n", + " # While there are free students\n", + " while free_students:\n", + " student = free_students[0]\n", + " student_prefs_list = student_prefs[student]\n", + "\n", + " # Find the first school in the student's preference list\n", + " school = student_prefs_list.pop(0)\n", + "\n", + " # Check if the school is already matched\n", + " if school not in school_matching:\n", + " # School is unmatched, so match the student and school\n", + " school_matching[school] = student\n", + " student_matching[student] = school\n", + " free_students.remove(student)\n", + " else:\n", + " # School is already matched, check if the student is preferred\n", + " current_match = school_matching[school]\n", + " if school_prefs[school].index(student) < school_prefs[school].index(current_match):\n", + " # Student is preferred, so swap the matches\n", + " student_matching[student] = school\n", + " student_matching[current_match] = None\n", + " free_students.remove(student)\n", + " free_students.append(current_match)\n", + "\n", + " return school_matching, student_matching\n", + "\n", + "# Define school and student preference lists\n", + "school_prefs = {\n", + " \"School A\": [\"Student X\", \"Student Y\"],\n", + " \"School B\": [\"Student Y\", \"Student X\"]\n", + "}\n", + "\n", + "student_prefs = {\n", + " \"Student X\": [\"School A\", \"School B\"],\n", + " \"Student Y\": [\"School B\", \"School A\"]\n", + "}\n", + "\n", + "# Find the stable matching\n", + "school_matching, student_matching = stable_matching(school_prefs, student_prefs)\n", + "\n", + "# Print the stable matching\n", + "print(\"Stable Matching:\")\n", + "for school, student in school_matching.items():\n", + " print(f\"{school} - {student}\")\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_4NgbXzZCi3q", + "outputId": "cd542a0c-62f8-4d31-9f57-578ff7bf0fac" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Stable Matching:\n", + "School A - Student X\n", + "School B - Student Y\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### **Problem 8:**\n", + "\n", + "Imagine a university with two departments, Department A and Department B, each offering a set of courses with different instructors. Each course has a fixed capacity, and students from both departments can enroll in any course based on their preferences. The goal is to create a stable course scheduling system that maximizes student satisfaction and minimizes course conflicts.\n", + "\n", + "Each student has preferences for a list of courses they want to enroll in, and each course has a fixed number of seats available. A stable schedule means that no student wants to drop any of their enrolled courses to join another, and no instructor wants to remove a student from their course.\n", + " \tEach course has a specific schedule, including days of the week and time slots.\n", + "*\tStudents have their own schedules, indicating the days and times they are available for classes.\n", + "*\tA student can only enroll in a course if it aligns with their availability, and they won't drop it unless there's a suitable replacement within their availability.\n", + "The challenge is to design a scheduling algorithm that assigns students to courses while considering these timing constraints, ensuring:\n", + "*\tEach student is enrolled in their most preferred set of courses that fit their schedules and for which they meet the prerequisites.\n", + "*\tEach course is filled to its capacity without exceeding it and adhering to its schedule.\n", + "*\tNo student wishes to drop a course and enroll in another because they prefer their current set of courses and their schedules.\n", + "\n", + "The question to resolve is whether there exists a stable course scheduling system that satisfies all these conditions for any given set of students, courses, their preferences, and timing constraints. Provide an algorithm to determine if a stable course schedule is possible or an example where it is not possible." + ], + "metadata": { + "id": "dPzmJqs3Cqk3" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### **Solution 8:**\n", + "\n", + "Solving the Stable Course Scheduling Problem with timing constraints and student prerequisites requires a careful algorithmic approach. Here's an algorithm to determine if a stable course schedule is possible:\n", + "Algorithm: Stable Course Scheduling with Prerequisites and Timing Constraints\n", + "\n", + "1.\tInitialization:\n", + "* Initialize an empty schedule for each student.\n", + "* Initialize a list of unenrolled courses for each student.\n", + "\n", + "2.\tEnrollment Based on Preferences and Prerequisites:\n", + "* For each student:\n", + "* Sort their course preferences based on priority (most preferred first).\n", + "*\tFor each course in the sorted list:\n", + "*\tCheck if the student meets the prerequisites for the course.\n", + "*\tIf prerequisites are met and the course has available seats, enroll the student in the course.\n", + "*\tIf prerequisites are not met or the course is full, mark the course as unenrollable for this student.\n", + "\n", + "3.\tSchedule Alignment:\n", + "*\tFor each student:\n", + "*\tSort the enrolled courses based on the student's schedule constraints (e.g., days and times).\n", + "*\tStarting with the highest-priority course, assign it to a suitable time slot in the student's schedule, considering course timings and capacity.\n", + "*\tRepeat this process for all enrolled courses, making sure they fit within the student's availability.\n", + "\n", + "4.\tCheck for Stability:\n", + "*\tAfter scheduling, check if any student wishes to drop a course and enroll in another due to preference changes.\n", + "*\tIf any student wishes to change, go back to step 2 and repeat the enrollment process.\n", + "\n", + "5.\tStability Evaluation:\n", + "*\tAfter multiple iterations, if no student wishes to change their courses or the available courses cannot accommodate the students' preferences and schedules, the schedule is stable.\n", + "\n", + "6.\tConclusion:\n", + "*\tIf a stable schedule is achieved, it satisfies all conditions, including student preferences, prerequisites, and timing constraints.\n", + "*\tIf a stable schedule cannot be reached after several iterations, it indicates that the constraints are too tight, and a stable schedule may not be possible.\n", + "\n", + "The algorithm may need multiple iterations, especially when students have changing preferences and schedules. Additionally, in cases where there is no stable schedule possible due to conflicting prerequisites, the algorithm should provide that insight. Adjusting prerequisites or course offerings may be necessary in such situations." + ], + "metadata": { + "id": "QDqi524VDUkm" + } + }, + { + "cell_type": "code", + "source": [ + "def stable_course_scheduling(students, courses, course_preferences, prerequisites, course_schedule):\n", + " # Initialize an empty schedule for each student\n", + " student_schedule = {student: [] for student in students}\n", + "\n", + " # Initialize a list of unenrolled courses for each student\n", + " unenrolled_courses = {student: list(courses) for student in students}\n", + "\n", + " stable = False\n", + "\n", + " while not stable:\n", + " stable = True\n", + "\n", + " for student in students:\n", + " # Sort course preferences based on priority (most preferred first)\n", + " preferred_courses = sorted(course_preferences[student], key=lambda course: course_preferences[student][course])\n", + "\n", + " for course in preferred_courses:\n", + " if course in unenrolled_courses[student]:\n", + " # Check if prerequisites are met\n", + " if all(prereq in student_schedule[student] for prereq in prerequisites[course]):\n", + " # Check if the course has available seats\n", + " if len(student_schedule[student]) < course_schedule[course]['capacity']:\n", + " # Sort enrolled courses based on student's schedule constraints\n", + " enrolled_courses = sorted(student_schedule[student], key=lambda c: course_schedule[c]['time'])\n", + "\n", + " # Find a suitable time slot for the course\n", + " suitable_slot = None\n", + " for slot in course_schedule[course]['time']:\n", + " if all(slot not in course_schedule[enrolled_course]['time'] for enrolled_course in enrolled_courses):\n", + " suitable_slot = slot\n", + " break\n", + "\n", + " # Assign the course to the schedule if a suitable slot is found\n", + " if suitable_slot:\n", + " student_schedule[student].append(course)\n", + " unenrolled_courses[student].remove(course)\n", + " stable = False\n", + "\n", + " return student_schedule\n", + "\n", + "# Example data\n", + "students = ['Student A', 'Student B']\n", + "courses = ['Course X', 'Course Y']\n", + "course_preferences = {\n", + " 'Student A': {'Course X': 1, 'Course Y': 2},\n", + " 'Student B': {'Course X': 2, 'Course Y': 1}\n", + "}\n", + "prerequisites = {\n", + " 'Course X': [],\n", + " 'Course Y': ['Course X']\n", + "}\n", + "course_schedule = {\n", + " 'Course X': {'time': ['Monday 9 AM'], 'capacity': 1},\n", + " 'Course Y': {'time': ['Tuesday 10 AM'], 'capacity': 1}\n", + "}\n", + "\n", + "# Run the stable course scheduling algorithm\n", + "result = stable_course_scheduling(students, courses, course_preferences, prerequisites, course_schedule)\n", + "\n", + "# Print the resulting schedules for each student\n", + "for student, schedule in result.items():\n", + " print(f\"{student}'s Schedule: {schedule}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NCPOrTyKEY-K", + "outputId": "e1083a99-e19b-4f2d-ab69-cad6c43c66cc" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Student A's Schedule: ['Course X']\n", + "Student B's Schedule: ['Course X']\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### **Problem 9:**\n", + "\n", + "In a regional Karate tournament, participants are divided into two groups based on their weight categories: Lightweight (under 70 kg) and Heavyweight (70 kg and above). Participants are eager to find suitable partners for the tournament and have provided their preferences for potential partners within their respective weight categories.They are implementing a Matching Algorithm, inspired by the Gale-Shapley Algorithm.\n", + "\n", + "Write a code to match participants in the same Category:" + ], + "metadata": { + "id": "1Ft7zJznFcxx" + } + }, + { + "cell_type": "code", + "source": [ + "def gale_shapley(participants, preferences):\n", + " matches = {}\n", + " proposals = {participant: 0 for participant in participants}\n", + "\n", + " while len(matches) < len(participants):\n", + " free_participants = [participant for participant in participants if participant not in matches]\n", + " proposer = free_participants[0]\n", + " preference_rank = proposals[proposer]\n", + " potential_partners = preferences[proposer][preference_rank:]\n", + "\n", + " for partner in potential_partners:\n", + " if partner not in matches:\n", + " matches[proposer] = partner\n", + " matches[partner] = proposer\n", + " break\n", + " else:\n", + " current_partner = matches[partner]\n", + " partner_preferences = preferences[partner]\n", + " if partner_preferences.index(proposer) < partner_preferences.index(current_partner):\n", + " matches[proposer] = partner\n", + " matches[partner] = proposer\n", + " free_participants.append(current_partner)\n", + "\n", + " proposals[proposer] += 1\n", + "\n", + " return matches\n", + "\n", + "def divide_participants(participants, weights):\n", + " divided_participants = {}\n", + " for weight_category in set(weights.values()):\n", + " divided_participants[weight_category] = [participant for participant in participants if weights[participant] == weight_category]\n", + " return divided_participants\n", + "\n", + "# Example input data (participants, preferences, and weights)\n", + "participants = [\"Participant1\", \"Participant2\", \"Participant3\", \"Participant4\", \"Participant5\", \"Participant6\"]\n", + "weights = {\n", + " \"Participant1\": \"Lightweight\",\n", + " \"Participant2\": \"Heavyweight\",\n", + " \"Participant3\": \"Lightweight\",\n", + " \"Participant4\": \"Heavyweight\",\n", + " \"Participant5\": \"Lightweight\",\n", + " \"Participant6\": \"Heavyweight\",\n", + "}\n", + "preferences = {\n", + " \"Participant1\": [\"PartnerA\", \"PartnerB\", \"PartnerC\", \"PartnerD\"],\n", + " \"Participant2\": [\"PartnerC\", \"PartnerB\", \"PartnerA\", \"PartnerD\"],\n", + " \"Participant3\": [\"PartnerD\", \"PartnerA\", \"PartnerC\", \"PartnerB\"],\n", + " \"Participant4\": [\"PartnerA\", \"PartnerC\", \"PartnerB\", \"PartnerD\"],\n", + " \"Participant5\": [\"PartnerB\", \"PartnerC\", \"PartnerA\", \"PartnerD\"],\n", + " \"Participant6\": [\"PartnerD\", \"PartnerB\", \"PartnerC\", \"PartnerA\"],\n", + "}\n", + "\n", + "# Divide participants into weight categories\n", + "divided_participants = divide_participants(participants, weights)\n", + "\n", + "# Apply Gale-Shapley algorithm within each weight category\n", + "for weight_category, category_participants in divided_participants.items():\n", + " category_preferences = {participant: preferences[participant] for participant in category_participants}\n", + " category_matches = gale_shapley(category_participants, category_preferences)\n", + "\n", + " # Print the matching pairs within the current weight category\n", + " print(f\"Matching Pairs in {weight_category} Category:\")\n", + " for participant, partner in category_matches.items():\n", + " print(f\"{participant} is matched with {partner}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hZT5JQG8FwXq", + "outputId": "e6a1448b-fa50-4e2e-c70e-e596b743a9d9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Matching Pairs in Lightweight Category:\n", + "Participant1 is matched with PartnerA\n", + "PartnerA is matched with Participant1\n", + "Participant3 is matched with PartnerD\n", + "PartnerD is matched with Participant3\n", + "Matching Pairs in Heavyweight Category:\n", + "Participant2 is matched with PartnerC\n", + "PartnerC is matched with Participant2\n", + "Participant4 is matched with PartnerA\n", + "PartnerA is matched with Participant4\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now can we match participants irrespective of weight category?" + ], + "metadata": { + "id": "xhc1xp7tF3m8" + } + }, + { + "cell_type": "code", + "source": [ + "import random\n", + "\n", + "def gale_shapley(participants, preferences):\n", + " matches = {}\n", + " proposals = {participant: 0 for participant in participants}\n", + "\n", + " while len(matches) < len(participants):\n", + " free_participants = [participant for participant in participants if participant not in matches]\n", + " proposer = free_participants[0]\n", + " preference_rank = proposals[proposer]\n", + " potential_partners = preferences[proposer][preference_rank:]\n", + "\n", + " for partner in potential_partners:\n", + " if partner not in matches:\n", + " matches[proposer] = partner\n", + " matches[partner] = proposer\n", + " break\n", + " else:\n", + " current_partner = matches[partner]\n", + " partner_preferences = preferences[partner]\n", + " if partner_preferences.index(proposer) < partner_preferences.index(current_partner):\n", + " matches[proposer] = partner\n", + " matches[partner] = proposer\n", + " free_participants.append(current_partner)\n", + "\n", + " proposals[proposer] += 1\n", + "\n", + " return matches\n", + "\n", + "def random_matching(participants, preferences, n):\n", + " shuffled_preferences = {participant: random.sample(preferences[participant], len(preferences[participant])) for participant in participants}\n", + " matches = {}\n", + "\n", + " for _ in range(n):\n", + " new_matches = gale_shapley(participants, shuffled_preferences)\n", + " matches.update(new_matches)\n", + "\n", + " return matches\n", + "\n", + "# Example input data (participants and preferences)\n", + "participants = [\"Participant1\", \"Participant2\", \"Participant3\", \"Participant4\"]\n", + "preferences = {\n", + " \"Participant1\": [\"PartnerA\", \"PartnerB\", \"PartnerC\", \"PartnerD\"],\n", + " \"Participant2\": [\"PartnerC\", \"PartnerB\", \"PartnerA\", \"PartnerD\"],\n", + " \"Participant3\": [\"PartnerD\", \"PartnerA\", \"PartnerC\", \"PartnerB\"],\n", + " \"Participant4\": [\"PartnerA\", \"PartnerC\", \"PartnerB\", \"PartnerD\"],\n", + "}\n", + "\n", + "# Specify the number of times to shuffle preferences (up to 'n')\n", + "n = 3\n", + "\n", + "# Get the randomly shuffled matching pairs\n", + "random_matches = random_matching(participants, preferences, n)\n", + "\n", + "# Print the randomly shuffled matching pairs\n", + "for participant, partner in random_matches.items():\n", + " print(f\"{participant} is matched with {partner}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rwhBzO6H7FLG", + "outputId": "1c05eadd-4f86-4d21-e391-31d434153c5f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Participant1 is matched with PartnerD\n", + "PartnerD is matched with Participant1\n", + "Participant2 is matched with PartnerB\n", + "PartnerB is matched with Participant2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Write a code to shuffle preferencees n number of times" + ], + "metadata": { + "id": "SN5xd1RTGid5" + } + }, + { + "cell_type": "code", + "source": [ + "import random\n", + "\n", + "def gale_shapley(participants, preferences):\n", + " matches = {}\n", + " proposals = {participant: 0 for participant in participants}\n", + "\n", + " while len(matches) < len(participants):\n", + " free_participants = [participant for participant in participants if participant not in matches]\n", + " proposer = free_participants[0]\n", + " preference_rank = proposals[proposer]\n", + " potential_participants = preferences[proposer][preference_rank:]\n", + "\n", + " for partner in potential_participants:\n", + " if partner not in matches:\n", + " matches[proposer] = partner\n", + " matches[partner] = proposer\n", + " break\n", + " else:\n", + " current_partner = matches[partner]\n", + " partner_preferences = preferences[partner]\n", + " if partner_preferences.index(proposer) < partner_preferences.index(current_partner):\n", + " matches[proposer] = partner\n", + " matches[partner] = proposer\n", + " free_participants.append(current_partner)\n", + "\n", + " proposals[proposer] += 1\n", + "\n", + " return matches\n", + "\n", + "def random_matching_within_category(participants, preferences, category):\n", + " category_participants = [p for p, w in participants.items() if w == category]\n", + " shuffled_preferences = {p: random.sample(preferences[p], len(preferences[p])) for p in category_participants}\n", + " matches = gale_shapley(category_participants, shuffled_preferences)\n", + "\n", + " return matches\n", + "\n", + "# Example input data (participants, preferences, and weights)\n", + "participants = {\n", + " \"Participant1\": \"Lightweight\",\n", + " \"Participant2\": \"Heavyweight\",\n", + " \"Participant3\": \"Lightweight\",\n", + " \"Participant4\": \"Heavyweight\",\n", + "}\n", + "preferences = {\n", + " \"Participant1\": [\"PartnerA\", \"PartnerB\", \"PartnerC\", \"PartnerD\"],\n", + " \"Participant2\": [\"PartnerC\", \"PartnerB\", \"PartnerA\", \"PartnerD\"],\n", + " \"Participant3\": [\"PartnerD\", \"PartnerA\", \"PartnerC\", \"PartnerB\"],\n", + " \"Participant4\": [\"PartnerA\", \"PartnerC\", \"PartnerB\", \"PartnerD\"],\n", + "}\n", + "\n", + "# Specify the number of times to shuffle preferences (up to 'n')\n", + "n = 3\n", + "\n", + "# Match participants within the \"Lightweight\" category\n", + "lightweight_matches = random_matching_within_category(participants, preferences, \"Lightweight\")\n", + "\n", + "# Match participants within the \"Heavyweight\" category\n", + "heavyweight_matches = random_matching_within_category(participants, preferences, \"Heavyweight\")\n", + "\n", + "# Print the randomly shuffled matching pairs within each category\n", + "print(\"Lightweight Category Matches:\")\n", + "for participant, partner in lightweight_matches.items():\n", + " print(f\"{participant} is matched with {partner}\")\n", + "\n", + "print(\"\\nHeavyweight Category Matches:\")\n", + "for participant, partner in heavyweight_matches.items():\n", + " print(f\"{participant} is matched with {partner}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OqXTaBnF7FuY", + "outputId": "22facf60-a5bd-419b-e620-328ff79c8076" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Lightweight Category Matches:\n", + "Participant1 is matched with PartnerB\n", + "PartnerB is matched with Participant1\n", + "\n", + "Heavyweight Category Matches:\n", + "Participant2 is matched with PartnerC\n", + "PartnerC is matched with Participant2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "D.Can we add elimation to this and check each possibility" + ], + "metadata": { + "id": "eCwnm8Xh9EDz" + } + }, + { + "cell_type": "markdown", + "source": [ + "Yes we can add Elimation\n", + "\n", + "Function gale_shapley(participants, preferences):\n", + " Initialize an empty dictionary matches to store matching pairs\n", + " Initialize a dictionary proposals with all participants, each set to 0\n", + " \n", + " While the number of matches is less than the total number of participants:\n", + " Find the list of free participants (participants not in matches)\n", + " Select a proposer from the free participants\n", + " Determine the preference rank of the proposer\n", + " Find potential partners based on their preferences\n", + " \n", + " For each potential partner in potential partners:\n", + " If the partner is not already matched:\n", + " Add the pair (proposer, partner) to matches\n", + " Mark the partner as matched with the proposer\n", + " Exit the loop\n", + " \n", + " Else if the partner is already matched:\n", + " Find the current partner of the partner\n", + " Determine the preferences of the partner\n", + " If the proposer has a higher preference rank than the current partner:\n", + " Replace the current partner with the proposer in matches\n", + " Update the matching for the proposer and partner\n", + " Add the current partner back to the list of free participants\n", + " \n", + " Return the matches dictionary\n", + "\n", + "Function random_matching_within_category(participants, preferences, category):\n", + " Create a list category_participants containing participants with the specified category\n", + " Create a shuffled_preferences dictionary with shuffled preference lists for category participants\n", + " Use the gale_shapley function to find matches based on shuffled_preferences\n", + " Return the matches for the category\n", + "\n", + "Function elimination_tournament(participants, preferences, n_rounds):\n", + " Initialize an empty winners dictionary to store winners of each round\n", + " Create a copy of participants called remaining_participants\n", + " Iterate through rounds from 1 to n_rounds:\n", + " Print the current round number\n", + " \n", + " Initialize an empty round_matches dictionary\n", + " \n", + " For each unique category in the set of participant categories:\n", + " Find matches within the category using random_matching_within_category\n", + " Update round_matches with the matches within the category\n", + " \n", + " Print the matches for the current round\n", + " \n", + " Update remaining_participants with participants from round_matches\n", + " Update winners with the matches from the current round\n", + " \n", + " If there is only one remaining participant:\n", + " Print the overall winner\n", + " Break the loop\n", + " \n", + " Return the winners dictionary\n" + ], + "metadata": { + "id": "8q0Vg2yC9I4P" + } + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4, + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/Submissions/Swapnil_Salsankar_002747372/Assignment-1.readme b/Submissions/Swapnil_Salsankar_002747372/Assignment-1.readme new file mode 100644 index 0000000..33aec22 --- /dev/null +++ b/Submissions/Swapnil_Salsankar_002747372/Assignment-1.readme @@ -0,0 +1,10 @@ +**Name : Swapnil Salsankar** +NUID: 002747372 +Date : 24th September 2023 + + +Assignment1 Reflection： + +1. I read, used ChatGPT to deepen my understanding of the problem, tried to get it to tell me what the problem's field and nature were, and then, after figuring it out, asked him if there were any other questions that were similar. I then read and understood the problem thoroughly, came up with my own questions, and provided answers. I have tried using chatGPT to get my questions answered. I saw that chatGPT always provided me with varied replies, but I ultimately decided to stick with my responses. +2. Throughout this process, I ran across numerous issues and difficulties. First off, I frequently struggled to understand the content of the questions; for instance, I had no idea what the terms Omega and Theta meant outside of the capital O. I had to spend a lot of time using chatGPT to decipher the questions. After that, I struggled to ask inquiries of a similar nature since I lacked the necessary knowledge. The fact that chatGPT occasionally provides different responses from mine, which I believe to be incorrect, as in the case of the first question about the ranking of time complexity, is even another challenge. +3. The first lesson I've learnt is the importance of clarity; unclear queries can be challenging to comprehend. The ability to divide complicated issues into smaller, easier-to-manage issues is another talent. Then, to make the problem more rigorous, you need to add certain limitations to the design process. So that we may solve difficulties of this nature, we should be adept at comprehending the essence of algorithmic problems. The algorithm problem must also evaluate the algorithm's complexity, which is, in my opinion, the fundamental component of the algorithm. diff --git a/Submissions/Swapnil_Salsankar_002747372/Assignment_1.ipynb b/Submissions/Swapnil_Salsankar_002747372/Assignment_1.ipynb new file mode 100644 index 0000000..60b0788 --- /dev/null +++ b/Submissions/Swapnil_Salsankar_002747372/Assignment_1.ipynb @@ -0,0 +1,1207 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "RyuM_2PXTGv7" + }, + "source": [ + "**Name : Swapnil Salsankar**\n", + "\n", + "Date : 24th September 2023\n", + "\n", + "\"In the response generated by ChatGPT...\"\n", + "\n", + "https://medium.com/aiskunks/understanding-gale-shapley-stable-matching-algorithm-and-its-time-complexity-4b814ee2642\n", + "https://web.stanford.edu/~ashishg/cs261/win21/notes/l5_note.pdf\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mo7mb_ayHNgZ" + }, + "source": [ + "***Problem 1:***\n", + "\n", + "\n", + "\n", + "Problem: \"Time Complexity Challenge\"\n", + "\n", + " Given a set of functions with their corresponding time complexities and a set of statements about their relationships. Your task is to determine the validity of each statement and provide proof or a counterexample.\n", + "\n", + "Input:\n", + "\n", + "A set of functions, each represented as a pair (name, time complexity).\n", + "\n", + "A set of statements in the form of triplets (function1, relationship, function2), where:\n", + "\n", + "function1 and function2 are names of functions from the input.\n", + "\n", + "relationship is one of the following: \"=\", \"O\", \"Θ\", \"Ω\".\n", + "\n", + "The input functions and statements are formatted in a way that resembles the provided example problem.\n", + "\n", + "Output:\n", + "\n", + "For each statement, print either \"True\" or \"False\" along with a brief explanation or a counterexample if applicable.\n", + "\n", + "Example:\n", + "\n", + "Input:\n", + "Functions:\n", + "f(n) = O(n)\n", + "\n", + "g(n) = Θ(n^2)\n", + "\n", + "h(n) = O(log n)\n", + "\n", + "Statements:\n", + "1. f(n) = Θ(f(n/2))\n", + "2. g(n) = O(f(n^2))\n", + "3. h(n) = O(g(n))\n", + "4. g(n) = Ω(f(n))\n", + "\n", + "Output:\n", + "1. True\n", + " Explanation: f(n) = O(n) is indeed Θ(f(n/2)) because f(n/2) = O(n/2) is within a constant factor of f(n).\n", + "\n", + "2. False\n", + " Counterexample: g(n) = Θ(n^2) is not O(f(n^2)) because f(n^2) = O(n^2) is not within a constant factor of g(n).\n", + "\n", + "3. False\n", + " Counterexample: h(n) = O(log n) is not O(g(n)) because g(n) = Θ(n^2) grows faster than h(n).\n", + "\n", + "4. True\n", + " Explanation: g(n) = Θ(n^2) is indeed Ω(f(n)) because f(n) = O(n) is within a constant factor of g(n).\n", + "\n", + "In this problem, participants need to apply their knowledge of time complexity analysis to determine the validity of statements about function relationships. This problem requires a deep understanding of algorithmic complexity and the ability to provide proofs or counterexamples based on the provided functions and statements.\n", + "\n", + "\n", + "**Reflection**\n", + "\n", + "My understanding of the task's requirements and structure was greatly improved because to ChatGPT. It gave a precise explanation of the problem statement, which helped me fully understand the setting and demands.\n", + "\n", + "Making sure that the functions and statements provided in the input were correctly parsed and evaluated presented one difficulty in upholding the example's spirit. To appropriately assess the time complexities and relationships, the reasoning had to be applied with care. Additionally, in order to make the output informative, clear and succinct justifications or counterexamples for each statement were required.\n", + "\n", + "This challenge's design demonstrated the value of concise problem formulations, particularly when discussing algorithms and temporal complexity analyses. A clearly stated problem with precise instructions is essential since ambiguity can result in the wrong solutions. It also underlined the significance of extensive testing to guarantee that the constraints and interactions between functions of the problem are effectively modeled.\n", + "\n", + "Overall, this problem design experience served to emphasize the need of accuracy and clarity in algorithmic challenges as well as the necessity of properly drafting input-output specifications to successfully direct players.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JSAxduvupIiH" + }, + "source": [ + "***Problem 2:***\n", + "\n", + "**Problem Statement:**\n", + "\n", + "A hospital is selecting a group of residents for its residency program using the Gale-Shapley matching algorithm. The hospital has a list of its preferred residents, and the residents have a list of their preferred hospitals. Each resident can be matched with one hospital, and each hospital can accept one resident.\n", + "\n", + "There are two groups: Group 1, consisting of H hospitals, and Group 2, consisting of R residents. The hospital's preferences are based on factors such as the resident's qualifications, skills, and experience, while the resident's preferences are based on factors such as the hospital's reputation, location, and available resources.\n", + "\n", + "To make the selections, the hospital and the residents will use the Gale-Shapley matching algorithm, which will match each resident with the hospital that is the best match according to their preferences. The algorithm will continue until there are no more possible matches or until all residents have been matched with a hospital.\n", + "\n", + "Additionally, the hospital will consider input from patients, staff, and other stakeholders through social media to create a ranking of which residents they would most like to see in the program. This ranking will be taken into consideration when making the final selections.\n", + "\n", + "**Input Format:**\n", + "\n", + "The input consists of:\n", + "\n", + "An integer H (1 ≤ H ≤ 50), representing the number of hospitals in Group 1.\n", + "\n", + "An integer R (1 ≤ R ≤ 50), representing the number of residents in Group 2.\n", + "\n", + "H lines, each containing R distinct integers separated by spaces, representing the preferences of each hospital. The integers are the IDs of residents in order of preference (1 to R).\n", + "\n", + "R lines, each containing H distinct integers separated by spaces, representing the preferences of each resident. The integers are the IDs of hospitals in order of preference (1 to H).\n", + "\n", + "**Output Format:**\n", + "\n", + "A list of pairs (hospital_id, resident_id) representing the final matching of residents to hospitals.\n", + "\n", + "\n", + "**Constraints:**\n", + "\n", + "1 ≤ H, R ≤ 50 (number of hospitals and residents).\n", + "\n", + "Preferences are distinct and within the range 1 to R (for residents) and 1 to H (for hospitals).\n", + "\n", + "All hospitals and residents will be matched.\n", + "\n", + "The matching will be stable according to the Gale-Shapley algorithm.\n", + "\n", + "\n", + "\n", + "reflection:\n", + "\n", + "Making sure that the task description adequately reflected the Gale-Shapley matching technique was one of the primary problems in keeping the example's spirit. The problem description had to be very explicit because this algorithm is complicated and has special stability and preference rules. Additionally, the hospital's inclusion of outside input into the matching process introduced another level of complexity that required succinct explanation.\n", + "This problem's design demonstrated how crucial it is to describe algorithms and their guidelines in clear, precise detail, particularly when they involve several participants with differing opinions. It also underlined the necessity to strike a balance between giving participants just enough information to grasp the issue at hand while avoiding giving them too much information. Algorithm problem design should concentrate on accurately capturing the fundamental ideas and specifications of the algorithm while eliminating needless complication.\n", + "\n", + "This challenge served as a reminder of the value of exact problem statement creation, clear communication of algorithmic principles, and the necessity of taking into account real-world circumstances in order to make problems interesting and accessible for participants.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gJlLQS7RpT0p" + }, + "source": [ + "A.\tWrite a Python implementation of the Gale-Shapley algorithm to match residents to hospitals. Assume there are 10 hospitals and 30 residents, with each hospital having 3 slots available. You can make up preference lists for the residents and hospitals." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "341npQURpaqW", + "outputId": "ec2a98dc-d92a-4086-e32f-c995b8ed2825" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hospital 38 matched with residents [0, 4, 20]\n", + "Hospital 36 matched with residents [1, 5, 29]\n", + "Hospital 31 matched with residents [2, 7, 17]\n", + "Hospital 39 matched with residents [3, 18, 23]\n", + "Hospital 35 matched with residents [6, 8, 22]\n", + "Hospital 30 matched with residents [12, 19, 14]\n", + "Hospital 33 matched with residents [13, 15, 21]\n", + "Hospital 37 matched with residents [24, 9, 28]\n", + "Hospital 34 matched with residents [25, 26, 16]\n", + "Hospital 32 matched with residents [10, 27, 11]\n" + ] + } + ], + "source": [ + " import random\n", + "\n", + "# Define the number of residents and hospitals\n", + "n_residents = 30\n", + "n_hospitals = 10\n", + "\n", + "# Define the number of slots available for each hospital\n", + "slots_per_hospital = 3\n", + "\n", + "# Generate preference lists for residents and hospitals\n", + "# Residents rank hospitals, and hospitals rank residents\n", + "# Residents are represented by integers 0 to n_residents - 1\n", + "# Hospitals are represented by integers n_residents to n_residents + n_hospitals - 1\n", + "\n", + "resident_prefs = {}\n", + "hospital_prefs = {}\n", + "\n", + "for resident in range(n_residents):\n", + " # Generate a random preference list of hospitals for this resident\n", + " hospital_list = list(range(n_residents, n_residents + n_hospitals))\n", + " random.shuffle(hospital_list)\n", + " resident_prefs[resident] = hospital_list\n", + "\n", + "for hospital in range(n_hospitals):\n", + " # Generate a random preference list of residents for this hospital\n", + " resident_list = list(range(n_residents))\n", + " random.shuffle(resident_list)\n", + " hospital_prefs[hospital + n_residents] = resident_list\n", + "\n", + "# Implement the matching algorithm\n", + "matches = {}\n", + "unmatched_residents = list(range(n_residents))\n", + "\n", + "while unmatched_residents:\n", + " resident = unmatched_residents.pop(0)\n", + " resident_prefs_list = resident_prefs[resident]\n", + "\n", + " for hospital in resident_prefs_list:\n", + " if hospital not in matches:\n", + " matches[hospital] = [resident]\n", + " break\n", + " elif len(matches[hospital]) < slots_per_hospital:\n", + " matches[hospital].append(resident)\n", + " break\n", + " else:\n", + " current_residents = matches[hospital]\n", + " hospital_prefs_list = hospital_prefs[hospital]\n", + " if hospital_prefs_list.index(resident) < hospital_prefs_list.index(current_residents[-1]):\n", + " unmatched_residents.append(current_residents.pop())\n", + " matches[hospital].append(resident)\n", + " break\n", + "\n", + "# Print the matches\n", + "for hospital, residents in matches.items():\n", + " print(f\"Hospital {hospital} matched with residents {residents}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-lD4TrsproYR" + }, + "source": [ + "B.\tConsider a variation of the problem where there are two rounds of matching. In the first round, residents apply to hospitals, and in the second round, hospitals apply to residents. Modify the Gale-Shapley algorithm to account for this and write a Python implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "75Por1otrrYc", + "outputId": "ef7fc330-0d56-4a86-ee62-727845c667e7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'R3': 'H1', 'R2': 'H3', 'R1': 'H2'}\n" + ] + } + ], + "source": [ + "def two_round_gale_shapley(res_pref, hos_pref):\n", + "\n", + "# Round 1: residents propose to hospitals\n", + " hos_proposals = {}\n", + " for res in res_pref:\n", + " for hos in res_pref[res]:\n", + " if hos not in hos_proposals:\n", + " hos_proposals[hos] = []\n", + " hos_proposals[hos].append(res)\n", + " break\n", + "\n", + " res_matches = {}\n", + " hos_matches = {}\n", + " while hos_proposals:\n", + " hos, res_list = hos_proposals.popitem()\n", + " for res in res_list:\n", + " if res not in res_matches:\n", + " res_matches[res] = hos\n", + " hos_matches[hos] = res\n", + " break\n", + " else:\n", + " curr_hos = res_matches[res]\n", + " if hos_pref[res].index(hos) < hos_pref[res].index(curr_hos):\n", + " res_matches[res] = hos\n", + " hos_matches[hos] = res\n", + " del hos_matches[curr_hos]\n", + " hos_proposals[curr_hos].extend([r for r in res_pref if r != res])\n", + " break\n", + "\n", + " # Round 2: hospitals propose to residents\n", + " res_proposals = {}\n", + " for hos in hos_pref:\n", + " for res in hos_pref[hos]:\n", + " if res not in res_matches:\n", + " if res not in res_proposals:\n", + " res_proposals[res] = []\n", + " res_proposals[res].append(hos)\n", + " break\n", + "\n", + " while res_proposals:\n", + " res, hos_list = res_proposals.popitem()\n", + " for hos in hos_list:\n", + " if hos not in hos_matches:\n", + " res_matches[res] = hos\n", + " hos_matches[hos] = res\n", + " break\n", + " else:\n", + " curr_res = hos_matches[hos]\n", + " if res_pref[hos].index(res) < res_pref[hos].index(curr_res):\n", + " res_matches[res] = hos\n", + " hos_matches[hos] = res\n", + " del res_matches[curr_res]\n", + " res_proposals[curr_res].extend([h for h in hos_pref if h != hos])\n", + " break\n", + "\n", + " return res_matches\n", + "\n", + "res_pref = {\n", + " 'R1': ['H2', 'H3', 'H1'],\n", + " 'R2': ['H3', 'H1', 'H2'],\n", + " 'R3': ['H1', 'H2', 'H3']\n", + "}\n", + "\n", + "hos_pref = {\n", + " 'H1': ['R2', 'R1', 'R3'],\n", + " 'H2': ['R1', 'R3', 'R2'],\n", + " 'H3': ['R1', 'R2', 'R3']\n", + "}\n", + "\n", + "res_matches = two_round_gale_shapley(res_pref, hos_pref)\n", + "print(res_matches)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ERcJiGf9uDW-" + }, + "source": [ + "***Problem 3:***\n", + "\n", + "**Problem Statement:**\n", + "\n", + "Algorithm Efficiency Comparison\n", + "\n", + "You are tasked with comparing the efficiency of two algorithms, Algorithm A and Algorithm B, as the input size, denoted by 'n', grows to infinity. Each algorithm has its own time complexity represented by functions f(n) and g(n).\n", + "\n", + "Write a program that takes the time complexities of Algorithm A (f(n)) and Algorithm B (g(n)) as input and determines which algorithm is more efficient as 'n' approaches infinity.\n", + "\n", + "**Input Format:**\n", + "\n", + "The input consists of two lines, each containing a mathematical expression representing the time complexity of an algorithm. The expressions will be in terms of 'n' and can include mathematical operations (+, -, *, /), constants, and exponents (^). The expressions are well-formed.\n", + "\n", + "**Output Format:**\n", + "\n", + "The output should indicate which algorithm is more efficient as 'n' grows to infinity. Specifically, it should output one of the following:\n", + "\n", + "\"Algorithm A is more efficient.\"\n", + "\n", + "\"Algorithm B is more efficient.\"\n", + "\n", + "\"Both algorithms have the same efficiency.\"\n", + "\n", + "**\n", + "**\n", + "\n", + "Input:\n", + "f(n) = 3n^2 + 2n + 1\n", + "g(n) = 2n^3 - 4n^2\n", + "\n", + "Output:\n", + "Algorithm B is more efficient.\n", + "\n", + "Input:\n", + "f(n) = 5n + 3\n", + "g(n) = 3n + 2\n", + "\n", + "Output:\n", + "Both algorithms have the same efficiency.\n", + "\n", + "\n", + "**Constraints:**\n", + "\n", + "The input expressions represent valid mathematical functions and are well-formed.\n", + "The input expressions do not exceed 100 characters in length.\n", + "The coefficients and exponents in the expressions are integers or floating-point numbers.\n", + "The constants in the expressions are integers or floating-point numbers.\n", + "The input values of 'n' are positive integers.\n", + "\n", + "**Reflection:**\n", + "\n", + "Accurately illustrating the idea of algorithm efficiency comparison as 'n' approaches infinity was one of the challenges in keeping the example's spirit. This necessitated creating a program that could evaluate, compare, and calculate the growth rates of intricate mathematical expressions. In order to convey the idea that efficiency comparison should remain valid as 'n' increases to infinity, it was also crucial.\n", + "\n", + "This challenge's design emphasized some essential facets of problem design in the context of algorithms:\n", + "\n", + "Precision and Clarity: It brought attention to the significance of stating the problem in a precise and unambiguous manner, particularly when working with mathematical expressions and algorithmic ideas.\n", + "This problem needs a thorough understanding of algorithmic time complexity analysis as well as the capacity to contrast various growth rates using mathematical expressions.\n", + "\n", + "Handling Complexity: It's important to achieve a balance between complexity and clarity in the problem description because dealing with mathematical expressions and comparing the efficiency of algorithms might be difficult.\n", + "\n", + "Testability: It was important to make sure that the problem could be tested and that a computer could identify the accurate algorithm efficiency comparison.\n", + "\n", + "This issue design experience has, in general, highlighted the importance of accuracy, clarity, and a firm grasp of algorithmic ideas when formulating challenges pertaining to algorithm analysis and efficiency comparison. It also emphasized how crucial it is to give participants clear input-output criteria so they can solve the problem successfully.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HxMbtvApyFEY", + "outputId": "8b354f8f-8921-49be-e9a7-3b394a507b43" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Both algorithms have the same efficiency.\n" + ] + } + ], + "source": [ + "from sympy import symbols, simplify\n", + "from sympy.calculus.util import function_range\n", + "import sympy\n", + "\n", + "def compare_algorithm_efficiency(f_expression, g_expression):\n", + " # Define the variable 'n' as a symbol\n", + " n = symbols('n')\n", + "\n", + " # Parse the input expressions and simplify them\n", + " f = simplify(sympy.sympify(f_expression))\n", + " g = simplify(sympy.sympify(g_expression))\n", + "\n", + " # Calculate the limits of the functions as n approaches infinity\n", + " limit_f = sympy.limit(f, n, sympy.oo)\n", + " limit_g = sympy.limit(g, n, sympy.oo)\n", + "\n", + " # Compare the limits to determine efficiency\n", + " if limit_f > limit_g:\n", + " return \"Algorithm A is more efficient.\"\n", + " elif limit_f < limit_g:\n", + " return \"Algorithm B is more efficient.\"\n", + " else:\n", + " return \"Both algorithms have the same efficiency.\"\n", + "\n", + "# Example usage:\n", + "if __name__ == \"__main__\":\n", + " f_expression = \"3*n**2 + 2*n + 1\"\n", + " g_expression = \"2*n**3 - 4*n**2\"\n", + "\n", + " result = compare_algorithm_efficiency(f_expression, g_expression)\n", + " print(result)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sAlBCph7CRt7" + }, + "source": [ + "***Problem 4:***\n", + "\n", + "**Problem Title:** Growth Rate Comparison\n", + "\n", + "You are given a list of mathematical expressions, each representing a function of 'n'. Your task is to compare and classify these expressions based on their growth rates concerning 'n'. You need to determine whether each expression's growth rate is \"Lower,\" \"Equal,\" or \"Higher\" compared to a reference expression.\n", + "\n", + "**Input:**\n", + "\n", + "An integer 'k' (1 ≤ k ≤ 10), representing the number of mathematical expressions.\n", + "\n", + "A reference expression 'ref' representing a function of 'n'.\n", + "'k' mathematical expressions represented as strings, each containing a function of 'n'.\n", + "\n", + "**Output:**\n", + "\n", + "A list of classifications for each expression in the input list. Each classification can be one of the following: \"Lower,\" \"Equal,\" or \"Higher\" compared to the reference expression.\n", + "\n", + "Example:\n", + "\n", + "Input:\n", + "\n", + "k = 5\n", + "Reference Expression (ref): \"0.9n + 9\"\n", + "Expressions:\n", + "[\"log(1000n)\", \"10n + 20n\", \"0.9n + 9\", \"n / log(n)\", \"log(n) + n^(1/3)\"]\n", + "Output:\n", + "\n", + "css\n", + "Copy code\n", + "[\"Higher\", \"Equal\", \"Equal\", \"Lower\", \"Higher\"]\n", + "Note:\n", + "\n", + "The output lists whether each expression's growth rate is \"Lower,\" \"Equal,\" or \"Higher\" compared to the reference expression.\n", + "Constraints:\n", + "\n", + "The input list of expressions contains 'k' elements (1 ≤ k ≤ 10).\n", + "Each expression in the list is expressed in a valid format and represents a valid mathematical function.\n", + "The reference expression is one of the expressions provided in the list.\n", + "The expressions may vary in complexity and can involve different mathematical operations and functions.\n", + "\n", + "reflection:\n", + "\n", + "One of the challenges in maintaining the spirit of the example was accurately conveying the concept of comparing the growth rates of mathematical expressions. This required designing a program that could parse and evaluate mathematical expressions and determine their relative growth rates concerning a reference expression. Additionally, handling various mathematical operations and functions within the expressions while maintaining simplicity and clarity was a consideration.\n", + "\n", + "Designing this problem in the realm of algorithms highlighted several important aspects:\n", + "\n", + "Input Validation: Ensuring that the input expressions are well-formed and can be evaluated programmatically is crucial. Participants should be able to parse and analyze these expressions.\n", + "\n", + "Algorithmic Thinking: Creating a solution for comparing growth rates involves algorithmic thinking, as it requires analyzing and comparing functions with different complexities.\n", + "\n", + "Interpretability: The problem statement should be clear and easily understandable to participants, especially when dealing with mathematical expressions and growth rate comparisons.\n", + "\n", + "Testability: Ensuring that the problem can be effectively tested, and that the correct growth rate comparisons can be determined programmatically, is essential.\n", + "\n", + "Overall, this problem design experience reinforced the importance of clarity, precision, and a solid understanding of algorithmic concepts when creating problems related to algorithm analysis and growth rate comparisons. It also emphasized the need for providing clear examples and constraints to guide participants in solving the problem effectively." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZFGU-Wz426Ku" + }, + "source": [ + "***Problem 5:***\n", + "\n", + "**Problem Statement:**\n", + "Tree Planting Rows\n", + "\n", + "You are tasked with planting trees in rows, where the number of trees in each row follows a specific mathematical sequence or function with slow growth. Your goal is to determine how many rows are needed to plant a specified total number of trees.\n", + "\n", + "**Input Format:**\n", + "\n", + "The input consists of two integers separated by a space:\n", + "\n", + "The total number of trees to be planted, denoted as 'T' (1 ≤ T ≤ 10^9).\n", + "\n", + "The choice of a slow-growth mathematical sequence or function, represented by an integer 'S':\n", + "\n", + "1: Fibonacci sequence (default)\n", + "\n", + "2: Triangular numbers\n", + "\n", + "3: Powers of 2\n", + "\n", + "4: Custom sequence (you provide the function)\n", + "\n", + "\n", + "**Output Format:**\n", + "\n", + "A single integer representing the minimum number of rows required to plant the specified total number of trees.\n", + "\n", + "Sample Inputs and Outputs:\n", + "\n", + "Input 1:50 1\n", + "\n", + "Output 1:5\n", + "\n", + "Input 2:28 2\n", + "\n", + "Output 2:7\n", + "\n", + "\n", + "Input 3:\n", + "100 3\n", + "\n", + "Output 3:\n", + "7\n", + "\n", + "**Constraints:**\n", + "\n", + "The total number of trees 'T' is a positive integer (1 ≤ T ≤ 10^9).\n", + "\n", + "The choice of mathematical sequence 'S' is an integer from 1 to 4.\n", + "\n", + "Custom sequence (S=4) will be defined in a specific format (e.g., as a function or recurrence relation) provided by the user.\n", + "\n", + "The growth rate of the chosen sequence or function must be relatively slow (e.g., Fibonacci, triangular numbers, powers of 2) to ensure manageable planting.\n", + "\n", + "Reflection:\n", + "\n", + "One challenge in maintaining the spirit of the example was selecting appropriate mathematical sequences with slow growth rates that would result in manageable planting. The choice of sequences such as the Fibonacci sequence, triangular numbers, and powers of 2 was important to ensure that the problem remained practical and realistic. Additionally, accommodating the option for a custom sequence added complexity but allowed for flexibility in problem-solving.\n", + "\n", + "Designing this problem in the realm of algorithms highlighted several key considerations:\n", + "\n", + "Mathematical Sequences: Carefully selecting and defining mathematical sequences or functions that align with the problem's context and objectives is crucial.\n", + "\n", + "Input Flexibility: Allowing for custom sequences introduces variability in input and requires clear instructions for defining these sequences, ensuring that participants can provide valid custom functions.\n", + "\n", + "Scalability: Considering the constraints and scalability of the problem, especially when dealing with large numbers like 10^9, is essential to ensure feasibility.\n", + "\n", + "Interpretability: The problem statement should be easily interpretable by participants, and the expected output should be clearly defined.\n", + "\n", + "Overall, this problem design experience underscored the importance of clarity, precision, and thoughtful selection of mathematical sequences when creating problems related to algorithms and mathematical operations. It also highlighted the need for providing specific instructions when dealing with user-defined custom functions to ensure that participants can effectively solve the problem.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7_P4YlBW2FPR", + "outputId": "cf26c5c6-3c1f-40ff-e573-918c54ba3585" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50 1\n", + "10\n" + ] + } + ], + "source": [ + "def fibonacci(n):\n", + " if n <= 0:\n", + " return 0\n", + " elif n == 1:\n", + " return 1\n", + " else:\n", + " return fibonacci(n - 1) + fibonacci(n - 2)\n", + "\n", + "def triangular(n):\n", + " return n * (n + 1) // 2\n", + "\n", + "def powers_of_2(n):\n", + " return 2**n\n", + "\n", + "def rows_needed_to_plant_trees(total_trees, sequence_choice=1):\n", + " n = 1\n", + " while True:\n", + " if sequence_choice == 1:\n", + " trees_in_row = fibonacci(n)\n", + " elif sequence_choice == 2:\n", + " trees_in_row = triangular(n)\n", + " elif sequence_choice == 3:\n", + " trees_in_row = powers_of_2(n)\n", + " # Add more custom sequences here with additional elif branches.\n", + " elif sequence_choice == 4:\n", + " # Define your custom sequence function here.\n", + " pass\n", + " else:\n", + " raise ValueError(\"Invalid sequence choice.\")\n", + "\n", + " if trees_in_row >= total_trees:\n", + " return n\n", + " n += 1\n", + "\n", + "# Example usage:\n", + "total_trees_to_plant, sequence_choice = map(int, input().split())\n", + "rows_required = rows_needed_to_plant_trees(total_trees_to_plant, sequence_choice)\n", + "print(rows_required)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-auqQ-Ah9sOk" + }, + "source": [ + "***Problem 6:***\n", + "\n", + "**Problem Statement:**\n", + "\n", + "Identifying Articulation Points and Bridges\n", + "\n", + "You are given an undirected graph, and your task is to identify the articulation points (nodes whose removal disconnects the graph) and bridges (edges whose removal increases the number of connected components) using Depth-First Search (DFS).\n", + "\n", + "**Input Format:**\n", + "\n", + "The input consists of two parts:\n", + "An integer 'V' representing the number of vertices in the graph (1 ≤ V ≤ 10^5).\n", + "'E' lines, each containing two space-separated integers 'u' and 'v' (0 ≤ u, v < V), indicating an edge between vertices 'u' and 'v'.\n", + "Output Format:\n", + "\n", + "Two separate lists:\n", + "A list of integers representing the articulation points found in the graph.\n", + "A list of pairs (u, v) representing the bridges found in the graph. Each pair denotes an edge between nodes 'u' and 'v' that is a bridge.\n", + "Sample Inputs and Outputs:\n", + "\n", + "Input:\n", + "5\n", + "\n", + "(0 1),(0 2),(1 2),(2 3),(3 4)\n", + "\n", + "Output:\n", + "\n", + "Articulation Points: [0, 2]\n", + "\n", + "Bridges: [(3, 4)]\n", + "\n", + "Input:\n", + "\n", + "7\n", + "\n", + "(0 1),(0 2),(1 2),(1 3),(3 4),(3 5),(6 3)\n", + "\n", + "Output:\n", + "\n", + "Articulation Points: [1, 3]\n", + "\n", + "Bridges: [(3, 4), (3, 5)]\n", + "\n", + "**Constraints:**\n", + "\n", + "The number of vertices 'V' is a positive integer (1 ≤ V ≤ 10^5).\n", + "\n", + "The edges are given in a valid format, and there are no self-loops or duplicate edges.\n", + "\n", + "The graph is guaranteed to be connected, with no isolated nodes.\n", + "\n", + "reflection:\n", + "\n", + "creating realistic and varied test cases while adhering to the given constraints was important to test participants' DFS-based algorithms effectively.\n", + "\n", + "Designing this problem in the realm of algorithms highlighted several key considerations:\n", + "\n", + "Graph Representation: Clearly defining how the graph is represented and ensuring that the provided input format is suitable for representing the graph's edges is crucial.\n", + "\n", + "Output Format: Designing a clear and understandable output format, such as lists of articulation points and bridges, allows participants to easily interpret the results of their algorithm.\n", + "\n", + "Correctness and Efficiency: Ensuring that the problem can be solved efficiently using DFS while also producing accurate results is essential.\n", + "\n", + "Realistic Test Cases: Generating meaningful test cases that reflect real-world scenarios and cover different aspects of graph connectivity and articulation points is important.\n", + "\n", + "Overall, this problem design experience reinforced the importance of clarity, precision, and a deep understanding of graph algorithms and graph theory when creating problems related to graph analysis. It also emphasized the need for well-defined input-output specifications to guide participants effectively in solving the problem.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ldii7r6l8ckL", + "outputId": "551a6aeb-a6f4-45b5-e841-e5ba85cf60a6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Articulation Points and Bridges:\n", + "Bridge: (3, 4)\n", + "Bridge: (3, 5)\n", + "Bridge: (3, 6)\n", + "Bridge: (1, 3)\n", + "Articulation Points:\n", + "1\n", + "3\n" + ] + } + ], + "source": [ + "from collections import defaultdict\n", + "\n", + "class Graph:\n", + " def __init__(self, vertices):\n", + " self.V = vertices\n", + " self.graph = defaultdict(list)\n", + " self.time = 0\n", + "\n", + " def add_edge(self, u, v):\n", + " self.graph[u].append(v)\n", + " self.graph[v].append(u)\n", + "\n", + " def _dfs(self, u, visited, parent, disc, low, ap):\n", + " children = 0\n", + " disc[u] = self.time\n", + " low[u] = self.time\n", + " self.time += 1\n", + " visited[u] = True\n", + "\n", + " for v in self.graph[u]:\n", + " if not visited[v]:\n", + " children += 1\n", + " self._dfs(v, visited, u, disc, low, ap)\n", + " low[u] = min(low[u], low[v])\n", + "\n", + " # Check for articulation point\n", + " if parent == -1 and children > 1:\n", + " ap[u] = True\n", + " if parent != -1 and low[v] >= disc[u]:\n", + " ap[u] = True\n", + "\n", + " # Check for bridges\n", + " if low[v] > disc[u]:\n", + " print(f\"Bridge: ({u}, {v})\")\n", + "\n", + " elif v != parent:\n", + " low[u] = min(low[u], disc[v])\n", + "\n", + " def find_articulation_points_and_bridges(self):\n", + " visited = [False] * self.V\n", + " disc = [float(\"inf\")] * self.V\n", + " low = [float(\"inf\")] * self.V\n", + " ap = [False] * self.V\n", + "\n", + " for i in range(self.V):\n", + " if not visited[i]:\n", + " self._dfs(i, visited, -1, disc, low, ap)\n", + "\n", + " print(\"Articulation Points:\")\n", + " for i, is_ap in enumerate(ap):\n", + " if is_ap:\n", + " print(i)\n", + "\n", + "# Example usage:\n", + "# g = Graph(5)\n", + "# g.add_edge(0, 1)\n", + "# g.add_edge(0, 2)\n", + "# g.add_edge(1, 2)\n", + "# g.add_edge(2, 3)\n", + "# g.add_edge(3, 4)\n", + "\n", + "g = Graph(7)\n", + "g.add_edge(0, 1)\n", + "g.add_edge(0, 2)\n", + "g.add_edge(1, 2)\n", + "g.add_edge(1, 3)\n", + "g.add_edge(3, 4)\n", + "g.add_edge(3, 5)\n", + "g.add_edge(6, 3)\n", + "\n", + "print(\"Articulation Points and Bridges:\")\n", + "g.find_articulation_points_and_bridges()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VDNy7_qC_z9k" + }, + "source": [ + "***Problem 7:***\n", + "\n", + "\n", + "The Word Ladder Problem is a classic problem in artificial intelligence and graph theory. The goal is to find the shortest transformation sequence from a start word to an end word by changing one letter at a time, with each intermediate step being a valid English word. Heuristic search algorithms like A* can be used to efficiently solve this problem. Here's how you can approach it:\n", + "\n", + "**Problem Statement:** Word Ladder Problem\n", + "\n", + "Given a start word, an end word, and a list of valid English words, find the shortest transformation sequence from the start word to the end word. Each transformation step involves changing one letter of the current word to create a new valid word. The sequence must consist of valid words, and each intermediate step must be one letter different from the previous word. If no such sequence exists, return an empty sequence.\n", + "\n", + "**Input Format:**\n", + "\n", + "Two strings, startWord and endWord, representing the start and end words.\n", + "\n", + "A list of strings, wordList, representing valid English words.\n", + "\n", + "The input words and words in the word list consist of lowercase English letters only.\n", + "\n", + "It is guaranteed that startWord and endWord are distinct and exist in wordList.\n", + "\n", + "\n", + "**Output Format:**\n", + "\n", + "A list of strings representing the shortest transformation sequence from startWord to endWord. If no valid sequence exists, return an empty list.\n", + "\n", + "Sample Input and Output:\n", + "\n", + "Input:\n", + "\n", + "startWord = \"hit\"\n", + "\n", + "endWord = \"cog\"\n", + "\n", + "wordList = [\"hot\", \"dot\", \"dog\", \"lot\", \"log\", \"cog\"]\n", + "\n", + "Output:\n", + "[\"hit\", \"hot\", \"dot\", \"dog\", \"cog\"]\n", + "\n", + "Input:\n", + "\n", + "startWord = \"red\"\n", + "\n", + "endWord = \"tax\"\n", + "\n", + "wordList = [\"ted\", \"tex\", \"red\", \"tax\", \"tad\", \"den\", \"rex\", \"pee\"]\n", + "\n", + "Output:\n", + "[\"red\", \"ted\", \"tad\", \"tax\"]\n", + "\n", + "**Constraints:**\n", + "\n", + "The length of startWord, endWord, and words in wordList is between 1 and 100.\n", + "All words consist of lowercase English letters only.\n", + "There exists a valid transformation sequence from startWord to endWord.\n", + "\n", + "reflection\n", + "\n", + "he example was accurately conveying the concept of the Word Ladder Problem and the need for finding a shortest transformation sequence between two words. The problem involves complex graph traversal and heuristic search algorithms like A*. Ensuring that the problem remained accessible and solvable within reasonable time limits while providing a clear path from the start word to the end word was crucial.\n", + "\n", + "Designing this problem in the realm of algorithms highlighted several key considerations:\n", + "\n", + "Input Validation: Ensuring that the input words and word list are well-formed and that they adhere to the specified constraints was essential.\n", + "\n", + "Algorithmic Complexity: The problem involves graph traversal and searching for the shortest path, which requires an understanding of graph theory and heuristic search algorithms.\n", + "\n", + "Correctness and Efficiency: Designing the problem in a way that encourages participants to find an efficient solution while ensuring correctness is vital.\n", + "\n", + "Realistic Test Cases: Creating meaningful test cases that capture different scenarios and edge cases in word transformation added depth to the problem.\n", + "\n", + "Overall, this problem design experience reinforced the importance of precision, clarity, and a strong understanding of algorithmic concepts when creating problems related to graph theory and heuristic search. It also emphasized the need for well-defined input-output specifications to guide participants effectively in solving the problem.\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ewNJrrzN_3F_", + "outputId": "7baa778a-72f1-4700-98e5-58ad4207d5d7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[['hit', 'hot', 'dot', 'dog', 'cog']]\n" + ] + } + ], + "source": [ + "from collections import defaultdict, deque\n", + "\n", + "def findLadders(beginWord, endWord, wordList):\n", + " # Create a set of valid words for faster lookup\n", + " wordSet = set(wordList)\n", + "\n", + " # Handle the case where the endWord is not in the wordList\n", + " if endWord not in wordSet:\n", + " return []\n", + "\n", + " # Create a dictionary to store neighbors of words\n", + " neighbors = defaultdict(list)\n", + " for word in wordList:\n", + " for i in range(len(word)):\n", + " pattern = word[:i] + '*' + word[i+1:]\n", + " neighbors[pattern].append(word)\n", + "\n", + " # Initialize the queue for BFS\n", + " queue = deque([(beginWord, [beginWord])])\n", + " visited = set()\n", + " result = []\n", + " found = False\n", + "\n", + " while queue:\n", + " current, path = queue.popleft()\n", + " visited.add(current)\n", + "\n", + " for i in range(len(current)):\n", + " pattern = current[:i] + '*' + current[i+1:]\n", + " for neighbor in neighbors[pattern]:\n", + " if neighbor == endWord:\n", + " found = True\n", + " result.append(path + [neighbor])\n", + " if neighbor not in visited:\n", + " queue.append((neighbor, path + [neighbor]))\n", + "\n", + " if found:\n", + " break\n", + "\n", + " return result\n", + "\n", + "# Example usage:\n", + "startWord = \"hit\"\n", + "endWord = \"cog\"\n", + "wordList = [\"hot\", \"dot\", \"dog\", \"lot\", \"log\", \"cog\"]\n", + "result = findLadders(startWord, endWord, wordList)\n", + "print(result) # Output: [['hit', 'hot', 'dot', 'dog', 'cog']]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dgXLbRAOP4_7" + }, + "source": [ + "***Problem 8:***\n", + "\n", + "\n", + "Here are two problems on the stable marriage problem.\n", + "\n", + "(a) Show the execution of the Gale-Shapley algorithm on an input with 3 men and 3\n", + "women having the following preferences:\n", + "\n", + "m1 : w2 > w1 > w3\n", + "\n", + "m2 : w2 > w1 > w3\n", + "\n", + "m3 : w1 > w2 > w3\n", + "\n", + "w1 : m2 > m1 > m3\n", + "\n", + "w2 : m3 > m1 > m2\n", + "\n", + "w3 : m3 > m2 > m1\n", + "\n", + "Let us suppose that whenever your algorithm has choice of “free” men to pick for\n", + "making a proposal, it picks the man with lowest index.\n", + "\n", + "Solution:\n", + "\n", + "Here is the execution of the algorithm shown as a sequence of proposals\n", + "by men and responses by women.\n", + "\n", + "(a) m1 proposes to w2; w2 is free and accepts\n", + "\n", + "(b) m2 proposes to w2; w2 prefers current partner m1 and rejects\n", + "\n", + "(c) m2 proposes to w1; w1 is free and accepts\n", + "\n", + "(d) m3 proposes to w1; w1 prefers current partner m2 and rejects\n", + "\n", + "(e) m3 proposes to w2; w2 accepts m3 and releases m1\n", + "\n", + "(f) m1 proposes to w1; w1 prefers current partner m2 and rejects\n", + "\n", + "(g) m1 proposes to w3; w3 is free and accepts\n", + "\n", + "The resulting marriage is {(m1, w3),(m2, w1),(m3, w2)}.\n", + "\n", + "reflection\n", + "\n", + "One challenge faced in ensuring the problem maintained the spirit of the example was conveying the step-by-step execution of the Gale-Shapley algorithm in a clear and concise manner. It was important to capture the essence of the algorithm, including the preference ordering, proposals, rejections, and acceptances, while avoiding unnecessary complexity.\n", + "\n", + "Designing this problem example in the realm of algorithms highlighted the following aspects:\n", + "\n", + "Clarity and Precision: The problem statement should provide a clear and precise description of the algorithm's execution to help participants understand the algorithm's mechanics.\n", + "\n", + "Realistic Test Cases: Creating meaningful test cases that reflect different preferences and scenarios is important to test participants' understanding of the algorithm.\n", + "\n", + "Algorithmic Concept: This problem example emphasized the importance of representing and explaining algorithmic concepts effectively.\n", + "\n", + "Overall, this experience reinforced the need for clarity, precision, and well-structured examples when creating problems related to algorithms and algorithmic processes. It also underscored the importance of presenting algorithms step by step to enhance understanding and provide a solid foundation for problem-solving.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "13x1sNc1QX3j" + }, + "source": [ + "(b) Consider the stable roommate problem in which we are given n individuals (for even\n", + "n) and each individual has preferences over the remaining n − 1 individuals. (So\n", + "in this problem, the individuals are not divided into two groups, as in the stable\n", + "marriage problem.) Unlike the stable marriage problem, there are instances of the\n", + "stable roommate problem for which no solution exists. Consider the following example\n", + "with 4 individuals A, B, C, and D with the following preferences:\n", + "\n", + "A : B > C > D,\n", + "\n", + "B : C > A > D,\n", + "\n", + "C : A > B > D,\n", + "\n", + "D : A > B > C.\n", + "\n", + "Prove that for this input, there is no solution.\n", + "\n", + "Solution:\n", + "There are three matchings to consider: {(A, B),(C, D)}, {(A, C),(B, D)},\n", + "and {(A, D),(B, C)}. For each of these matchings, there is an unstable pair. Below,\n", + "I identify the unstable pair for each matching and provide an explanation for the\n", + "instability.\n", + "5\n", + "\n", + "{(A, B),(C, D)}: (B, C) is unstable because B prefers C to A and C prefers B to D.\n", + "\n", + "{(A, C),(B, D)}: (A, B) is unstable because A prefers B to C and B prefers A to D.\n", + "\n", + "{(A, D),(B, C)}: (A, C) is unstable because C prefers A to B and A prefers C to D.\n", + "\n", + "Since every possible matching has an instability, there is no solution to this instance\n", + "of the stable roommate problem.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kG15Ebw7RlFA" + }, + "source": [ + "Decide whether you think the following statement is true or false. If it is true, give a short explanation. If it is false, give a counterexample.\n", + "Consider an alternative to the Propose and Reject algorithm (with no rejections), where women take turns choosing the best available husband from the remaining unchosen men. On day 1, the oldest woman chooses her most preferred man, and marries him. On day k, the k-th eldest woman chooses her most preferred choice from the remaining unmarried men, and marries him. No matter what the preferences are, this process always results in a stable matching.\n", + "\n", + "Solution:\n", + "\n", + "The statement is FALSE\n", + "\n", + "Consider the set of men M = {1,2} and women W = {A,B} with the following preferences.\n", + "\n", + "![Screenshot 2023-09-24 at 6.23.33 PM.png](data:image/png;base64,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)\n", + "\n", + "Running the alternative Propose and Reject algorithm on this set yields the pairings: (A,1),(B,2). However, we can see that Man 1 prefers Woman B and vice versa, forming a rogue pair. Therefore, the pairing is not stable. We found a counterexample, so the statement is FALSE.\n", + "\n", + "\n", + "\n", + "reflection\n", + "\n", + "It required carefully designing the preferences of men and women to create a situation where the alternative Propose and Reject algorithm did not result in a stable matching. This involved considering not just the immediate pairings but also potential rogue pairs.\n", + "\n", + "Designing this problem example in the realm of algorithms highlighted the following aspects:\n", + "\n", + "Clarity and Precision: The problem statement should be clear and well-structured to convey the concept effectively.\n", + "\n", + "Counterexample Design: Designing a counterexample that effectively disproves a statement is not always straightforward and may require careful consideration of preferences and potential conflicts.\n", + "\n", + "Algorithmic Understanding: This problem example emphasized the need for a deep understanding of algorithms, in this case, the Propose and Reject algorithm and its alternatives, to design meaningful counterexamples.\n", + "\n", + "Overall, this experience reinforced the importance of providing clear and concise problem statements and the value of well-designed counterexamples to illustrate concepts and test understanding in the realm of algorithms. It also highlighted the need to consider both the direct and potential implications of algorithmic processes when creating problem scenarios.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fkzvZ_C9SvpW" + }, + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3.9.6 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.9.6" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Submissions/VinayKumar_Gudooru_002747385/Assignment1_VinayKumar_Gudooru_002747385.README b/Submissions/VinayKumar_Gudooru_002747385/Assignment1_VinayKumar_Gudooru_002747385.README new file mode 100644 index 0000000..f1fe742 --- /dev/null +++ b/Submissions/VinayKumar_Gudooru_002747385/Assignment1_VinayKumar_Gudooru_002747385.README @@ -0,0 +1,11 @@ +Name: Vinay Kumar Gudooru +NUID: 002747385 + +

Assignment 1

+
+
+

The topics covered in this assignment are Time Complexity and Gale-Shapley Algorithm taught by professor in first 2 lectures. We were sample question sets with solutions and references for better understanding of the problem.

+
+

Our task was to go through all of them and understand the logic behind it and its use cases. Keep that in mind, we had to create 10 questions of similar manner ensuring the essence and structure of it.

+
+

I have framed 10 non-trivial question that aligns with the essence and structure of the sample problem on the above mentioned topics and provided solutions and required justification for the same.

\ No newline at end of file diff --git a/Submissions/VinayKumar_Gudooru_002747385/Assignment1_VinayKumar_Gudooru_002747385.ipynb b/Submissions/VinayKumar_Gudooru_002747385/Assignment1_VinayKumar_Gudooru_002747385.ipynb new file mode 100644 index 0000000..d735d26 --- /dev/null +++ b/Submissions/VinayKumar_Gudooru_002747385/Assignment1_VinayKumar_Gudooru_002747385.ipynb @@ -0,0 +1,10435 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "feedd154-8f7d-4760-9156-fcae138e26a9", + "metadata": { + "tags": [] + }, + "source": [ + "# Assignment 1" + ] + }, + { + "cell_type": "markdown", + "id": "f4cb5758-2958-42b4-8ec8-6ffea61a0634", + "metadata": {}, + "source": [ + "## Problem 1 (10 Points)\n", + "\n", + "Arrange the following functions in increasing order of growth:\n", + "\n", + "1. $n!$\n", + "2. $2^n$$√(n^3)$\n", + "3. $10n log n$\n", + "4. $2^n$\n", + "5. $n log n$\n", + "6. $3n^2 + 2n$\n", + "7. $n^3 log n$\n", + "8. $5n^3$\n", + "9. $1.1^n$\n", + "10. $n^2 + 1000n$" + ] + }, + { + "cell_type": "markdown", + "id": "9f669a7f-c501-4a0b-bf04-0995bd50da2f", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "1. $n^2 + 1000n = Θ(n^2)$ - Quadratic growth.\n", + "2. $2^n = Θ(2^n$) - Exponential growth.\n", + "3. $5n^3 = Θ(n^3$) - Cubic growth.\n", + "4. $√(n^3) = Θ(n^(3/2))$ - Between quadratic and cubic growth.\n", + "5. $n log n = Θ(n log n)$ - Growth slightly faster than linear.\n", + "6. $3n^2 + 2n = Θ(n^2)$ - Quadratic growth.\n", + "7. $10n log n = Θ(n log n)$ - Growth slightly faster than n log n.\n", + "8. $n^3 log n = Θ(n^3 log n)$ - Growth between cubic and polynomial with higher log factor.\n", + "9. $1.1^n = Θ(1.1^n)$ - Exponential growth, but slower than 2^n.\n", + "10. $n! = Θ(n!)$ - Super-exponential growth.\n", + "\n", + "##### Justification\n", + "\n", + "1. Functions 1 and 6 have quadratic growth, but function 1 has a smaller leading coefficient, so it grows more slowly.\n", + "2. Function 2 exhibits exponential growth, which is faster than any polynomial growth.\n", + "3. Function 3 has cubic growth, which is faster than quadratic growth.\n", + "4. Function 4 has growth between quadratic and cubic due to the square root.\n", + "5. Function 5 grows slightly faster than linear but slower than n log n.\n", + "6. Function 7 grows slightly faster than n log n but slower than n^2.\n", + "7. Function 8 grows between cubic and polynomial with a logarithmic factor.\n", + "8. Function 9 is an exponential growth, but it's slower than 2^n.\n", + "9. Function 10, n!, has super-exponential growth, which is the fastest among these functions.\n", + "10. This arrangement represents the functions in increasing order of their growth rates." + ] + }, + { + "cell_type": "markdown", + "id": "6f99ccb6-fe46-4d6f-8e49-eff15e9b5ee4", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "This exercise on arranging functions in increasing order of growth provides valuable insights into the fundamental concepts of algorithmic complexity and growth rates. Here are some key takeaways from this exercise:\n", + "\n", + "1. Understanding Growth Rates: This exercise underscores the importance of recognizing and comparing growth rates. It's essential for computer scientists and engineers to assess how different algorithms or functions scale with input size. This understanding helps in choosing the most efficient algorithms or data structures for solving specific problems.\n", + "\n", + "2. Big O Notation: The notation used in this exercise (e.g., Θ, O) is part of Big O notation, which is a standard way to describe the upper bounds on the growth rates of functions. Big O notation simplifies the process of comparing and analyzing the efficiency of algorithms.\n", + "\n", + "3. Polynomial vs. Exponential Growth: The distinction between polynomial (e.g., n^2, n^3) and exponential (e.g., 2^n, 1.1^n) growth is critical. Polynomial growth signifies that the function's runtime increases at a manageable rate as input size grows. In contrast, exponential growth implies rapidly increasing resource requirements, making exponential algorithms often impractical for large inputs.\n", + "\n", + "4. Logarithmic and Square Root Growth: Functions with logarithmic (e.g., n log n) and square root (e.g., √(n^3)) growth rates fall between linear and polynomial/exponential growth. These functions represent efficient algorithms in many cases.\n", + "\n", + "5. Factorial Growth: The factorial function (n!) represents super-exponential growth and is one of the slowest-growing functions considered here. This emphasizes the importance of avoiding algorithms with factorial time complexity whenever possible.\n", + "\n", + "6. Practical Implications: Recognizing growth rates is not just theoretical; it has real-world implications. When designing software systems or algorithms, it's crucial to consider how input size will affect performance. Choosing the right algorithm with a suitable growth rate is often the key to achieving efficient and scalable solutions.\n", + "\n", + "7. Constant Factors Matter: In this exercise, we observed that constant factors (e.g., 1.1 in 1.1^n) can significantly impact growth rates. It's essential to account for these factors when analyzing algorithms in practice." + ] + }, + { + "cell_type": "markdown", + "id": "5569a241-9ba5-471a-9f7b-036e9700797a", + "metadata": { + "tags": [] + }, + "source": [ + "## Problem 2 (10 Points)\n", + "\n", + "You are given two functions, f(n)=n and g(n)=$n^2$, where n is a positive integer. Your task is to analyze and compare the growth rates of these functions.\n", + "For each of the following statements, determine whether it is true or false and provide a proof or a counterexample:\n", + "\n", + "Statement 1: \"f(n) = O(g(n))\"\n", + "\n", + "Statement 2: \"g(n) = Ω(f(n))\"\n", + "\n", + "Statement 3: \"f(n) = Θ(g(n))\"\n", + "\n", + "Statement 4: \"0 <= f(n) <= c1 * g(n) for some c1 > 0 and all n > n0\"\n", + "\n", + "Statement 5: \"0 <= (1/c1) * f(n) <= g(n)\"\n", + "\n", + "**Input:** The input consists of the two functions, f(n) and g(n), represented as mathematical expressions. You can assume that the expressions are valid and describe functions of a single positive integer variable n.\n", + "\n", + "**Output:** For each of the five statements, output \"True\" if the statement is true, and \"False\" if the statement is false. Additionally, if the statement is false, provide a counterexample that demonstrates its falseness.\n" + ] + }, + { + "cell_type": "markdown", + "id": "230e7fdc-4468-4a21-afa0-d59dcaf9905f", + "metadata": { + "tags": [] + }, + "source": [ + "## Solution\n", + "\n", + "**Statement 1: $f(n) = O(g(n))$**\n", + "To prove this statement true, we need to show that f(n) is an upper bound for g(n). This means that there exists a constant c and a value n0 such that for all n > n0, f(n) <= c * g(n).\n", + "If we can find suitable values for c and n0, then the statement is true; otherwise, it's false.\n", + "Proof/Counterexample: For example, if f(n) = n and g(n) = n^2:\n", + "We can choose c = 1 and n0 = 1. For all n > 1, we have n <= 1 * n^2, which is true.\n", + "Therefore, Statement 1 is true for this example.\n", + "\n", + "\n", + "**Statement 2: $g(n) = Ω(f(n))$**\n", + "To prove this statement true, we need to show that g(n) is a lower bound for f(n). This means that there exists a constant c and a value n0 such that for all n > n0, g(n) >= c * f(n).\n", + "If we can find suitable values for c and n0, then the statement is true; otherwise, it's false.\n", + "Proof/Counterexample: Using the same functions as in Statement 1 (f(n) = n and g(n) = n^2):\n", + "We can choose c = 1 and n0 = 1. For all n > 1, we have n^2 >= 1 * n, which is true.\n", + "Therefore, Statement 2 is true for this example.\n", + "\n", + "\n", + "**Statement 3: $f(n) = Θ(g(n))$**\n", + "To prove this statement true, we need to show that f(n) and g(n) have the same growth rate. This means both Statement 1 and Statement 2 must be true.\n", + "In our example with f(n) = n and g(n) = n^2, Statement 1 is true, but Statement 2 is also true. Therefore, Statement 3 is false for this example because f(n) and g(n) do not have the same growth rate.\n", + "\n", + "\n", + "**Statement 4: $0 <= f(n) <= c1 * g(n) for some c1 > 0 and all n > n0$**\n", + "This statement is essentially the definition of O(g(n)). If f(n) is O(g(n)), then it means there exist c1 and n0 such that f(n) is upper-bounded by c1 * g(n) for all n > n0.\n", + "Therefore, Statement 4 is true if Statement 1 is true, as it is essentially restating the definition of big O notation.\n", + "\n", + "\n", + "**Statement 5: $0 <= (1/c1) * f(n) <= g(n)$**\n", + "This statement is essentially the definition of Ω(f(n)). If g(n) is Ω(f(n)), then it means there exist c1 and n0 such that f(n) is lower-bounded by (1/c1) * g(n) for all n > n0.\n", + "Statement 5 is true if Statement 2 is true, as it is essentially restating the definition of big Omega notation.\n", + "\n", + "\n", + "In summary, Statement 1 and Statement 2 are true for the example with f(n) = n and g(n) = n^2. Statement 3 is false because the functions do not have the same growth rate. Statement 4 is true because it follows the definition of big O notation, and Statement 5 is true because it follows the definition of big Omega notation" + ] + }, + { + "cell_type": "markdown", + "id": "53171530-194e-4120-98b3-fb4624ae0a18", + "metadata": {}, + "source": [ + "#### Reflection: \n", + "\n", + "Utilizing ChatGPT for this task was incredibly helpful. It assisted in crafting well-structured solutions, breaking down each statement logically, and clarifying the underlying mathematical concepts and relationships between the functions.\n", + "\n", + "One of the challenges I encountered was ensuring that the problem maintained the essence of the example. Striking the right balance between simplicity and clarity, while still challenging the problem-solving abilities of the reader, required careful consideration.\n", + "\n", + "This exercise underscored the importance of precision in problem design within the realm of algorithms. Effective problem design should not only test the reader's knowledge but also encourage critical thinking and the practical application of mathematical concepts. It also highlighted the significance of providing clear definitions and context for mathematical notations like big O and big Omega to enhance the overall problem-solving experience." + ] + }, + { + "cell_type": "markdown", + "id": "a1a75140-a9b1-46c2-83a7-3597aba3f6e1", + "metadata": {}, + "source": [ + "## Problem 3 (10 Points)\n", + "\n", + "In a university, there are n students and n scholarship programs available. Each student has a ranked list of scholarship programs they are interested in, and each scholarship program has a ranked list of students they wish to award scholarships to. The goal is to allocate scholarships to students in a way that maximizes the students' preferences and ensures that no student or scholarship program would prefer each other over their current assignments.\n", + "\n", + "Your task is to implement the Gale-Shapley algorithm to find a stable allocation of scholarships to students based on their preferences.\n", + "\n", + "**Input:**\n", + "\n", + "Lists of ranked preferences for n students and n scholarship programs. Each list contains the names or identifiers of their preferred scholarships or students, ranked from most preferred to least preferred.\n", + "\n", + "**Output:**\n", + "\n", + "A stable allocation of scholarships to students that respects their preferences and ensures that no unstable assignments exist.\n", + "Example:\n", + "\n", + "Suppose there are 3 students (S1, S2, S3) and 3 scholarship programs (P1, P2, P3), with their ranked preferences as follows:\n", + "\n", + "**Student Preferences:**\n", + "\n", + " - S1: P2, P1, P3\n", + " - S2: P1, P2, P3\n", + " - S3: P1, P3, P2\n", + "\n", + "**Scholarship Program Preferences:**\n", + "\n", + " - P1: S2, S1, S3\n", + " - P2: S3, S2, S1\n", + " - P3: S1, S3, S2\n", + "\n", + "Using the Gale-Shapley algorithm, find a stable allocation of scholarships to students that respects their preferences." + ] + }, + { + "cell_type": "markdown", + "id": "e98f2bbd-78f9-4c98-af52-b1a9a1dba186", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "The Gale-Shapley algorithm for scholarship allocation works as follows:\n", + "\n", + "1. Initialize all students and scholarship programs as unassigned.\n", + "\n", + "2. While there exists an unassigned student S:\n", + " - Let S's highest-ranked scholarship program who has not yet been assigned to any student be P.\n", + " - If P is unassigned, assign P to S.\n", + " - If P is currently assigned to a different student S', then P will compare their suitors S and S' and choose the one they prefer.\n", + " - If P prefers S' to S, nothing happens.\n", + " - If P prefers S to S', P becomes assigned to S, and S' becomes unassigned.\n", + "3. The algorithm terminates when all students are assigned to scholarship programs.\n", + "\n", + "The solution will provide a stable allocation of scholarships to students." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "b7bf661d-9651-4481-966b-f70d336bc052", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Student S1 is assigned to Scholarship P3\n", + "Student S2 is assigned to Scholarship P2\n", + "Student S3 is assigned to Scholarship P4\n", + "Student S4 is assigned to Scholarship P5\n", + "Student S5 is assigned to Scholarship P1\n" + ] + } + ], + "source": [ + "# Number of students and scholarships\n", + "n = 5\n", + "\n", + "# Manually assigned preferences for students and scholarships\n", + "student_preferences = {\n", + " 'S1': ['P3', 'P4', 'P2', 'P1', 'P5'],\n", + " 'S2': ['P2', 'P4', 'P1', 'P3', 'P5'],\n", + " 'S3': ['P4', 'P3', 'P5', 'P1', 'P2'],\n", + " 'S4': ['P5', 'P1', 'P2', 'P4', 'P3'],\n", + " 'S5': ['P1', 'P2', 'P3', 'P4', 'P5']\n", + "}\n", + "\n", + "scholarship_preferences = {\n", + " 'P1': ['S4', 'S1', 'S2', 'S3', 'S5'],\n", + " 'P2': ['S1', 'S2', 'S4', 'S3', 'S5'],\n", + " 'P3': ['S4', 'S2', 'S5', 'S3', 'S1'],\n", + " 'P4': ['S2', 'S1', 'S3', 'S4', 'S5'],\n", + " 'P5': ['S1', 'S2', 'S3', 'S4', 'S5']\n", + "}\n", + "\n", + "# Initialize all students and scholarships as unassigned\n", + "students = {f'S{i}': None for i in range(1, n+1)}\n", + "scholarships = {f'P{i}': None for i in range(1, n+1)}\n", + "\n", + "# Gale-Shapley algorithm for scholarship allocation\n", + "while None in students.values():\n", + " for student in students:\n", + " if students[student] is None:\n", + " preferred_scholarship = student_preferences[student].pop(0)\n", + " if scholarships[preferred_scholarship] is None:\n", + " students[student] = preferred_scholarship\n", + " scholarships[preferred_scholarship] = student\n", + " else:\n", + " current_student = scholarships[preferred_scholarship]\n", + " if scholarship_preferences[preferred_scholarship].index(student) < scholarship_preferences[preferred_scholarship].index(current_student):\n", + " students[student] = preferred_scholarship\n", + " students[current_student] = None\n", + " scholarships[preferred_scholarship] = student\n", + "\n", + "# Print the stable allocation\n", + "for student, scholarship in students.items():\n", + " print(f'Student {student} is assigned to Scholarship {scholarship}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "281b9dd4-2f4a-496e-b219-cb3da43646d2", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "The implementation follows the Gale-Shapley algorithm's structure, initializing students and scholarship programs, and then iteratively assigning scholarships to students based on their preferences until a stable allocation is achieved.\n", + "\n", + "Challenges in maintaining the spirit of the example revolved around creating a clear and concise problem statement while maintaining the complexity of the Gale-Shapley algorithm. Ensuring that the input and output were well-defined and representative of the real-world scholarship allocation problem was essential.\n", + "\n", + "Through this exercise, I gained a deeper understanding of how to present algorithmic problems that are both illustrative and practical. It highlighted the importance of clearly defining the problem, providing step-by-step solutions, and offering well-structured input and output examples to enhance comprehension and problem-solving skills. Additionally, it reinforced the value of algorithmic thinking in solving real-world allocation problems effectively." + ] + }, + { + "cell_type": "markdown", + "id": "ef6a0faa-d09f-4023-8ebb-f04b9dc9579b", + "metadata": {}, + "source": [ + "## Problem 4 (10 Points)\n", + "\n", + "What will happen if 2 students or 2 scholarship programs have exactly same preference. Will Gale-Shepley algorithm still be able to acheive stable matches. If yes, please justify, how? If no, what are the constraints to Gale-Shapley algorithm." + ] + }, + { + "cell_type": "markdown", + "id": "2c6ee38d-c2f1-425b-b7b0-e6d61e0cae6c", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "The algorithm's stability and fairness properties are maintained even when preferences are similar. In this scenario, when a scholarship program proposes to students, it will propose to the student it encounters first in its preference list. However, since both students have identical preferences, the scholarship program's choice between the two students will depend on the order in which it iterates through the list of students.\n", + "\n", + "The final assignment may vary depending on this order. One student will be assigned to the scholarship program, and the other will remain unassigned. This situation illustrates the non-deterministic nature of the algorithm when preferences are identical.\n", + "\n", + "Here's a problem statement involving 10 students and 10 scholarships where two students have exactly the same preference. \n", + "\n", + "**Example:**\n", + "\n", + "In a prestigious university, there are 10 students (S1 to S10) and 10 scholarship programs (P1 to P10). Each student has submitted their preferences for the scholarship programs, and two students, S3 and S7, have submitted identical preference lists. The goal is to allocate scholarships to students based on their preferences while ensuring that no student or scholarship program would prefer each other over their current assignments.\n", + "\n", + "Your task is to implement the Gale-Shapley algorithm to find a stable allocation of scholarships to students considering the given preferences.\n", + "\n", + "The preferences for students and scholarships are as follows:\n", + "\n", + "Student Preferences:\n", + "\n", + " - S1: P5, P1, P7, P6, P10, P9, P4, P2, P3, P8\n", + " - S2: P4, P2, P3, P1, P9, P8, P7, P6, P10, P5\n", + " - S3: P2, P3, P1, P7, P6, P5, P9, P4, P8, P10 (Same as S7)\n", + " - S4: P3, P9, P2, P1, P6, P8, P10, P7, P5, P4\n", + " - S5: P8, P4, P6, P5, P9, P1, P7, P3, P10, P2\n", + " - S6: P10, P7, P3, P9, P1, P4, P8, P2, P6, P5\n", + " - S7: P2, P3, P1, P7, P6, P5, P9, P4, P8, P10 (Same as S3)\n", + " - S8: P6, P8, P10, P2, P3, P9, P1, P4, P5, P7\n", + " - S9: P7, P6, P9, P10, P8, P3, P4, P5, P1, P2\n", + " - S10: P1, P5, P8, P4, P2, P10, P7, P6, P9, P3\n", + " \n", + " Scholarship Program Preferences:\n", + "\n", + " - P1: S5, S9, S4, S2, S10, S6, S8, S7, S1, S3\n", + " - P2: S8, S10, S7, S3, S6, S4, S2, S5, S9, S1\n", + " - P3: S9, S10, S1, S3, S5, S7, S2, S4, S8, S6\n", + " - P4: S4, S8, S2, S9, S7, S10, S1, S5, S3, S6\n", + " - P5: S6, S10, S3, S2, S9, S4, S8, S7, S5, S1\n", + " - P6: S5, S2, S9, S7, S1, S6, S4, S3, S10, S8\n", + " - P7: S3, S1, S6, S2, S4, S7, S8, S9, S5, S10\n", + " - P8: S5, S6, S2, S1, S10, S9, S7, S4, S3, S8\n", + " - P9: S4, S6, S10, S2, S9, S3, S8, S5, S1, S7\n", + " - P10: S1, S9, S8, S3, S4, S7, S2, S10, S6, S5" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "098fc811-0994-4fb8-a278-b901707b6ab0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Student S1 is assigned to Scholarship P5\n", + "Student S2 is assigned to Scholarship P4\n", + "Student S3 is assigned to Scholarship P3\n", + "Student S4 is assigned to Scholarship P9\n", + "Student S5 is assigned to Scholarship P8\n", + "Student S6 is assigned to Scholarship P10\n", + "Student S7 is assigned to Scholarship P2\n", + "Student S8 is assigned to Scholarship P6\n", + "Student S9 is assigned to Scholarship P7\n", + "Student S10 is assigned to Scholarship P1\n" + ] + } + ], + "source": [ + "# Manually assigned preferences for students and scholarships\n", + "# Student Preferences\n", + "student_preferences1 = {\n", + " 'S1': ['P5', 'P1', 'P7', 'P6', 'P10', 'P9', 'P4', 'P2', 'P3', 'P8'],\n", + " 'S2': ['P4', 'P2', 'P3', 'P1', 'P9', 'P8', 'P7', 'P6', 'P10', 'P5'],\n", + " 'S3': ['P2', 'P3', 'P1', 'P7', 'P6', 'P5', 'P9', 'P4', 'P8', 'P10'], # Same as S7\n", + " 'S4': ['P3', 'P9', 'P2', 'P1', 'P6', 'P8', 'P10', 'P7', 'P5', 'P4'],\n", + " 'S5': ['P8', 'P4', 'P6', 'P5', 'P9', 'P1', 'P7', 'P3', 'P10', 'P2'],\n", + " 'S6': ['P10', 'P7', 'P3', 'P9', 'P1', 'P4', 'P8', 'P2', 'P6', 'P5'],\n", + " 'S7': ['P2', 'P3', 'P1', 'P7', 'P6', 'P5', 'P9', 'P4', 'P8', 'P10'], # Same as S3\n", + " 'S8': ['P6', 'P8', 'P10', 'P2', 'P3', 'P9', 'P1', 'P4', 'P5', 'P7'],\n", + " 'S9': ['P7', 'P6', 'P9', 'P10', 'P8', 'P3', 'P4', 'P5', 'P1', 'P2'],\n", + " 'S10': ['P1', 'P5', 'P8', 'P4', 'P2', 'P10', 'P7', 'P6', 'P9', 'P3']\n", + "}\n", + "\n", + "# Scholarship Program Preferences\n", + "scholarship_preferences1 = {\n", + " 'P1': ['S5', 'S9', 'S4', 'S2', 'S10', 'S6', 'S8', 'S7', 'S1', 'S3'],\n", + " 'P2': ['S8', 'S10', 'S7', 'S3', 'S6', 'S4', 'S2', 'S5', 'S9', 'S1'],\n", + " 'P3': ['S9', 'S10', 'S1', 'S3', 'S5', 'S7', 'S2', 'S4', 'S8', 'S6'],\n", + " 'P4': ['S4', 'S8', 'S2', 'S9', 'S7', 'S10', 'S1', 'S5', 'S3', 'S6'],\n", + " 'P5': ['S6', 'S10', 'S3', 'S2', 'S9', 'S4', 'S8', 'S7', 'S5', 'S1'],\n", + " 'P6': ['S5', 'S2', 'S9', 'S7', 'S1', 'S6', 'S4', 'S3', 'S10', 'S8'],\n", + " 'P7': ['S3', 'S1', 'S6', 'S2', 'S4', 'S7', 'S8', 'S9', 'S5', 'S10'],\n", + " 'P8': ['S5', 'S6', 'S2', 'S1', 'S10', 'S9', 'S7', 'S4', 'S3', 'S8'],\n", + " 'P9': ['S4', 'S6', 'S10', 'S2', 'S9', 'S3', 'S8', 'S5', 'S1', 'S7'],\n", + " 'P10': ['S1', 'S9', 'S8', 'S3', 'S4', 'S7', 'S2', 'S10', 'S6', 'S5']\n", + "}\n", + "\n", + "# Initialize all students and scholarships as unassigned\n", + "students1 = {f'S{i}': None for i in range(1, 11)}\n", + "scholarships1 = {f'P{i}': None for i in range(1, 11)}\n", + "\n", + "# Gale-Shapley algorithm for scholarship allocation\n", + "while None in students1.values():\n", + " for student in students1:\n", + " if students1[student] is None:\n", + " preferred_scholarship = student_preferences1[student].pop(0)\n", + " if scholarships1[preferred_scholarship] is None:\n", + " students1[student] = preferred_scholarship\n", + " scholarships1[preferred_scholarship] = student\n", + " else:\n", + " current_student = scholarships1[preferred_scholarship]\n", + " if scholarship_preferences1[preferred_scholarship].index(student) < scholarship_preferences1[preferred_scholarship].index(current_student):\n", + " students1[student] = preferred_scholarship\n", + " students1[current_student] = None\n", + " scholarships1[preferred_scholarship] = student\n", + "\n", + "# Print the stable allocation\n", + "for student, scholarship in students1.items():\n", + " print(f'Student {student} is assigned to Scholarship {scholarship}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "f55484a8-5c2d-4a36-9b8e-71a081bff3df", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "Taking the earlier problem forward with curiousness on how the algorithm will behave in similar preferences, this problem is a thoughtful reflection on the Gale-Shapley algorithm's behavior when students or scholarship programs have identical preferences.\n", + "\n", + "The solution illustrates that the Gale-Shapley algorithm can still achieve stable matches in such cases. When multiple students or scholarship programs have the same preferences, the order in which the algorithm iterates through the list can lead to different assignments. This demonstrates the non-deterministic nature of the algorithm when preferences are identical.\n", + "\n", + "This problem showcases the flexibility of the Gale-Shapley algorithm. It adapts to varying preferences and still ensures that the resulting matches are stable and optimal from the perspective of the proposing party.\n", + "\n", + "Reflecting on this problem, it's evident that the Gale-Shapley algorithm is robust and capable of handling scenarios where preferences might not be unique. It highlights the algorithm's fairness and its ability to find stable solutions despite variations in input data.\n", + "\n", + "In the realm of algorithm design, this problem emphasizes the importance of considering real-world scenarios where preferences might not always be distinct. It teaches us that even in situations where preferences are seemingly identical, a well-designed algorithm can still lead to equitable and stable outcomes." + ] + }, + { + "cell_type": "markdown", + "id": "58f9746b-b4f5-4f90-8caa-f2304b1ee6e7", + "metadata": {}, + "source": [ + "## Problem 5 (10 Points)\n", + "\n", + "What improvements or optimizations can be made to the stable matching algorithm to enhance its efficiency or scalability for larger datasets while still ensuring stable matchings? Provide an example for implementation of one of the optimization techniques." + ] + }, + { + "cell_type": "markdown", + "id": "5c442f79-5fae-4e79-ab50-08169e445984", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "The stable matching algorithm, also known as the Gale-Shapley algorithm, is an efficient algorithm for finding stable matchings in bipartite graphs. However, there are still some improvements and optimizations that can be made to enhance its efficiency or scalability for larger datasets:\n", + "\n", + "**Parallelization:** Implementing the algorithm in a parallel or distributed manner can significantly speed up the process for large datasets. By dividing the work among multiple processors or machines, you can achieve better scalability.\n", + "\n", + "**Early Termination:** In many cases, stable matchings can be found well before all iterations are completed. Implement early termination conditions to stop the algorithm once a stable matching is reached, instead of running it to completion. This can save computation time.\n", + "\n", + "**Randomization:** Introduce randomization into the algorithm. For example, randomize the order in which proposers or acceptors make proposals. Randomized algorithms can improve efficiency in practice while still ensuring stable matchings.\n", + "\n", + "**Heuristic Initialization:** Start with a good initial matching that is likely to be close to a stable matching. This can reduce the number of iterations needed to reach a stable matching. Various heuristics can be used to generate such initial matchings.\n", + "\n", + "**Incremental Updates:** If your dataset changes over time or you have to compute many stable matchings with only small changes between them, consider using incremental update techniques to avoid recomputing the entire matching from scratch.\n", + "\n", + "**Memory Efficiency:** Optimize memory usage, especially for large datasets. You can consider using data structures like adjacency lists instead of matrices to store preferences.\n", + "\n", + "**Caching:** Cache intermediate results or state of the algorithm to avoid redundant computations when backtracking or exploring different possibilities. This can be especially useful in scenarios where preferences change slightly.\n", + "\n", + "**Multithreading:** Utilize multithreading to take advantage of modern multicore processors. You can parallelize the computation of proposals and acceptances within a single round.\n", + "\n", + "**Data Partitioning:** If your dataset is too large to fit in memory, partition it into smaller chunks and process them separately. This can be useful for distributed implementations as well.\n", + "\n", + "**Algorithmic Variants:** Explore alternative algorithms for stable matching, such as the \"Top Trading Cycles\" algorithm, which may perform better in certain scenarios or with certain preferences.\n", + "\n", + "**Algorithmic Parameter Tuning:** Experiment with different parameter settings and configurations to find the most efficient setup for your specific dataset and requirements.\n", + "\n", + "**Optimization Libraries:** Consider using specialized optimization libraries or frameworks that offer efficient implementations of stable matching algorithms, which may be highly optimized for large datasets.\n", + "\n", + "**Approximation Algorithms:** In cases where finding an exact stable matching is computationally infeasible for large datasets, consider using approximation algorithms that provide near-optimal solutions with lower computational requirements.\n", + "\n", + "**Distribution and Load Balancing:** If deploying on a distributed system, ensure proper load balancing and distribution of data and computation to maximize parallelism and efficiency.\n", + "\n", + "The choice of optimization strategy should depend on the specific characteristics of your dataset and the computational resources available. Experimentation and profiling are often necessary to determine the most effective approach for a given problem." + ] + }, + { + "cell_type": "markdown", + "id": "fbbf5262-2263-4138-b6a5-dfa60869040c", + "metadata": {}, + "source": [ + "Let's implement one of the optimizations mentioned earlier: \"Parallelization.\" We'll use Python's `concurrent.futures` module to parallelize the preference evaluation step. This optimization can potentially speed up the stable matching algorithm for large datasets by allowing multiple student proposals to companies to be evaluated concurrently.\n", + "\n", + "Here's the modified code with parallelization:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "800c4ebd-c9e6-48c7-b993-3def005f1b7e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "S1 is matched with Company C\n", + "S3 is matched with Company A\n", + "S2 is matched with Company B\n" + ] + } + ], + "source": [ + "import concurrent.futures\n", + "\n", + "def stable_matching(companies, students):\n", + " # Initialize an empty matching for students and companies\n", + " matching = {}\n", + " \n", + " # Define the preferences of companies and students\n", + " company_preferences = {\n", + " \"Company A\": [\"S1\", \"S2\", \"S3\"],\n", + " \"Company B\": [\"S2\", \"S1\", \"S3\"],\n", + " \"Company C\": [\"S2\", \"S1\", \"S3\"]\n", + " }\n", + " \n", + " student_preferences = {\n", + " \"S1\": [\"Company C\", \"Company B\", \"Company A\"],\n", + " \"S2\": [\"Company B\", \"Company C\"],\n", + " \"S3\": [\"Company A\"]\n", + " }\n", + " \n", + " # Keep track of students who are not yet matched\n", + " unmatched_students = set(students)\n", + " \n", + " # Function to evaluate student proposals to a company\n", + " def evaluate_proposals(student, student_choices, company):\n", + " nonlocal matching\n", + " nonlocal unmatched_students\n", + " \n", + " for company in student_choices:\n", + " if company not in matching:\n", + " # Company is unmatched, so match the student with the company\n", + " matching[company] = student\n", + " break\n", + " else:\n", + " current_match = matching[company]\n", + " # Check if the student is preferred over the current match\n", + " if company_preferences[company].index(student) < company_preferences[company].index(current_match):\n", + " # Student is preferred, so unmatch the current match and match the student\n", + " matching[company] = student\n", + " unmatched_students.add(current_match)\n", + " break\n", + " \n", + " with concurrent.futures.ThreadPoolExecutor() as executor:\n", + " # Evaluate student proposals concurrently\n", + " futures = {executor.submit(evaluate_proposals, student, student_preferences[student], None): student for student in unmatched_students}\n", + " concurrent.futures.wait(futures)\n", + " \n", + " return matching\n", + "\n", + "# Example usage\n", + "companies = [\"Company A\", \"Company B\", \"Company C\"]\n", + "students = [\"S1\", \"S2\", \"S3\"]\n", + "\n", + "matching = stable_matching(companies, students)\n", + "\n", + "# Print the stable matching\n", + "for company, student in matching.items():\n", + " print(f\"{student} is matched with {company}\")" + ] + }, + { + "cell_type": "markdown", + "id": "917dadb1-6450-47e1-b5bb-8c485c099984", + "metadata": {}, + "source": [ + "In this modified code, we use a `ThreadPoolExecutor` to submit the evaluation of student proposals to companies concurrently. This allows multiple students to propose to different companies at the same time, potentially speeding up the algorithm for larger datasets." + ] + }, + { + "cell_type": "markdown", + "id": "24cb448f-f72a-4acb-bcff-0609a624bda6", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "I came up with this question by wondering the real-world application of the Gale-Shapley Algorithm especially the hospitals-resident example that professor spoke in the lecture. I used google, medium, chatGPT to understand the optimizations that can be used to ensure stable matches when operated at large scale data sets. Summarized all the information gathered from the internet. For the second part of implementation, ChatGPT helped me with it.\n", + "\n", + "In conclusion, optimizing the stable matching algorithm for larger datasets involves a combination of parallelization, early termination, randomization, and other techniques tailored to the specific problem characteristics. It's essential to choose the most suitable optimization strategy based on the dataset and available computational resources, ensuring that stable matchings are achieved efficiently. This problem highlights the ongoing research and development efforts to make stable matching algorithms practical for real-world scenarios." + ] + }, + { + "cell_type": "markdown", + "id": "f37b2688-e798-492a-9ffb-f19e7b0e3dba", + "metadata": {}, + "source": [ + "## Problem 6 (10 Points)\n", + "\n", + "What is the time complexity of finding the Fibonacci sequence using a recursive algorithm? Can you suggest an optimized approach to improve the time complexity?" + ] + }, + { + "cell_type": "markdown", + "id": "29ecd3ff-4596-4849-92b7-2eca40f672a0", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "The time complexity of finding the Fibonacci sequence using a simple recursive algorithm is exponential, O(2^n). This is because the algorithm repeatedly recalculates Fibonacci numbers, resulting in an exponential number of recursive calls. " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "366ccdf6-984c-4f3c-8ad8-0d698fb1e16c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def fibonacci_recursive(n):\n", + " if n <= 0:\n", + " return 0\n", + " elif n == 1:\n", + " return 1\n", + " else:\n", + " return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "af081f16-32cb-48f4-b4d0-e980bb3adf87", + "metadata": { + "tags": [] + }, + "source": [ + "An optimized approach is to use dynamic programming or memoization, which reduces the time complexity to O(n) by storing previously computed Fibonacci numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "88ccec78-9fbd-4d3c-bc3f-af379a3d7fb9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def fibonacci_memoization(n, memo={}):\n", + " if n <= 0:\n", + " return 0\n", + " elif n == 1:\n", + " return 1\n", + " elif n in memo:\n", + " return memo[n]\n", + " else:\n", + " memo[n] = fibonacci_memoization(n - 1, memo) + fibonacci_memoization(n - 2, memo)\n", + " return memo[n]\n" + ] + }, + { + "cell_type": "markdown", + "id": "266dac6e-9e7d-4844-911b-35151438f51f", + "metadata": {}, + "source": [ + "In this optimized version, memo is a dictionary that stores previously computed Fibonacci numbers. When a Fibonacci number is requested, the function first checks if it's in the memo dictionary. If it's already computed, it returns the stored value; otherwise, it calculates the value recursively and stores it in the memo dictionary for future use.\n", + "\n", + "The time complexity of this optimized memoization approach is O(n), as it computes each Fibonacci number once and stores the result for reuse. This is a significant improvement over the exponential time complexity of the naive recursive approach." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "70e06a35-1cb9-4267-ad8b-757c88eecec1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fibonacci Numbers (Recursive):\n", + "F(0) = 0\n", + "F(1) = 1\n", + "F(2) = 1\n", + "F(3) = 2\n", + "F(4) = 3\n", + "F(5) = 5\n", + "F(6) = 8\n", + "F(7) = 13\n", + "F(8) = 21\n", + "F(9) = 34\n", + "F(10) = 55\n", + "F(11) = 89\n", + "F(12) = 144\n", + "F(13) = 233\n", + "F(14) = 377\n", + "F(15) = 610\n", + "F(16) = 987\n", + "F(17) = 1597\n", + "F(18) = 2584\n", + "F(19) = 4181\n", + "Processing Time: 0.0017337799072265625 seconds\n", + "\n", + "Fibonacci Numbers (Memoization):\n", + "F(0) = 0\n", + "F(1) = 1\n", + "F(2) = 1\n", + "F(3) = 2\n", + "F(4) = 3\n", + "F(5) = 5\n", + "F(6) = 8\n", + "F(7) = 13\n", + "F(8) = 21\n", + "F(9) = 34\n", + "F(10) = 55\n", + "F(11) = 89\n", + "F(12) = 144\n", + "F(13) = 233\n", + "F(14) = 377\n", + "F(15) = 610\n", + "F(16) = 987\n", + "F(17) = 1597\n", + "F(18) = 2584\n", + "F(19) = 4181\n", + "Processing Time: 7.009506225585938e-05 seconds\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "# Calculate and print the first 20 Fibonacci numbers using both methods\n", + "n = 20\n", + "print(\"Fibonacci Numbers (Recursive):\")\n", + "start_time = time.time()\n", + "for i in range(n):\n", + " result = fibonacci_recursive(i)\n", + " print(f\"F({i}) = {result}\")\n", + "end_time = time.time()\n", + "print(f\"Processing Time: {end_time - start_time} seconds\\n\")\n", + "\n", + "print(\"Fibonacci Numbers (Memoization):\")\n", + "start_time = time.time()\n", + "memo = {}\n", + "for i in range(n):\n", + " result = fibonacci_memoization(i, memo)\n", + " print(f\"F({i}) = {result}\")\n", + "end_time = time.time()\n", + "print(f\"Processing Time: {end_time - start_time} seconds\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "febfcba4-a372-4a87-8b03-b6d2f6e362cd", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "Idea for this question originated from my DSEM assignements wherein we have re-write code for Fibonacci sequence code in different ways - recursive, generative and iterative. The problem focues on the time complexity of a recursive Fibonacci algorithm and its optimization through memoization underscores the importance of algorithmic efficiency. It highlights that simple recursive approaches can quickly lead to exponential time complexities, making them impractical for large inputs. The memoization technique provides a powerful strategy for mitigating this issue, reducing the time complexity to linear, and showcases how thoughtful algorithm design can significantly improve computational efficiency." + ] + }, + { + "cell_type": "markdown", + "id": "50196d20-2bcf-4c65-a34b-bee65a8d92ef", + "metadata": {}, + "source": [ + "## Problem 7 (10 points)\n", + "\n", + "Compare the time complexities of two algorithms: one with a runtime of $n^2 + 2n$ and another with a runtime of $3n log2(n))$. Which algorithm is more efficient in terms of asymptotic time complexity? Determine the crossover point." + ] + }, + { + "cell_type": "markdown", + "id": "5a56873a-721c-41c5-86a5-a5a9ca46052a", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "We have two algorithms with different time complexities:\n", + "\n", + "Algorithm A: T(n) = n^2 + 2n\n", + "\n", + "Algorithm B: T(n) = 3n log2(n)\n", + "\n", + "We need to compare these algorithms in terms of asymptotic time complexity and find the crossover point where one algorithm becomes more efficient than the other.\n", + "\n", + "1. **Comparing Time Complexities:**\n", + "\n", + " We are given the time complexities of Algorithm A and Algorithm B.\n", + " - Algorithm A has a time complexity of n^2 + 2n.\n", + " - Algorithm B has a time complexity of 3n log2(n).\n", + " To compare the two algorithms, we want to determine which one grows faster as the input size (n) increases. In Big O notation, we are interested in the dominant term that contributes most significantly to the growth rate.\n", + "\n", + " - For Algorithm A (n^2 + 2n), the dominant term is n^2 because it grows faster than 2n as n becomes large.\n", + " - For Algorithm B (3n log2(n)), the dominant term is 3n log2(n) because it grows faster than 3n as n becomes large.\n", + " \n", + " Therefore, Algorithm B (3n log2(n)) has a better (i.e., smaller) time complexity in terms of asymptotic analysis because it grows more slowly than Algorithm A (n^2 + 2n) as the input size increases.\n", + "\n", + "2. **Finding the Crossover Point:**\n", + "\n", + " To determine the crossover point, we set the two time complexities equal to each other:\n", + " n^2 + 2n = 3n log2(n)\n", + "\n", + " The goal is to find the value of n where these two functions intersect or become equal." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "e15998b3-aa82-408c-8fe8-c81aef693fb5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plotting graph for crossover point\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define the functions for Algorithm A and Algorithm B\n", + "def algorithm_a(n):\n", + " return n**2 + 2*n\n", + "\n", + "def algorithm_b(n):\n", + " return 3*n*np.log2(n)\n", + "\n", + "# Create an array of values for n\n", + "n_values = np.arange(1, 10) # Adjust the range as needed\n", + "\n", + "# Calculate the corresponding function values\n", + "a_values = algorithm_a(n_values)\n", + "b_values = algorithm_b(n_values)\n", + "\n", + "# Plot the two functions\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(n_values, a_values, label='Algorithm A (n^2 + 2n)')\n", + "plt.plot(n_values, b_values, label='Algorithm B (3n log2(n))')\n", + "\n", + "# Add labels and legend\n", + "plt.xlabel('n')\n", + "plt.ylabel('Time Complexity')\n", + "plt.legend()\n", + "\n", + "# Find the crossover point (where the two functions intersect)\n", + "crossover_point = np.argwhere(np.diff(np.sign(a_values - b_values)))[0][0]\n", + "plt.plot(n_values[crossover_point], a_values[crossover_point], 'ro') # Mark the crossover point\n", + "plt.annotate(f'Crossover Point ({n_values[crossover_point]}, {a_values[crossover_point]:.2f})', \n", + " (n_values[crossover_point], a_values[crossover_point]), \n", + " textcoords=\"offset points\", xytext=(10,10), ha='center')\n", + "\n", + "# Show the plot\n", + "plt.grid()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "bc328b55-2fc5-4817-97ce-cae255420fe6", + "metadata": {}, + "source": [ + "By observation, we can find that the crossover point occurs at n ≈ 15. This means that for input sizes less than 15 (e.g., n = 1, 2, ..., 15), Algorithm A is faster, and for input sizes greater than 15, Algorithm B is faster.\n", + "\n", + "So, in summary, Algorithm B (3n log2(n)) is more efficient in terms of asymptotic time complexity, and the crossover point is approximately n ≈ 15.48, where Algorithm B becomes more efficient than Algorithm A as n increases." + ] + }, + { + "cell_type": "markdown", + "id": "dabf1078-b734-467f-b466-bc199c3c3c73", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "Problem was a reference from the sample question set given to us. In addressing Problem, ChatGPT played a crucial role in calculating and explaining the time complexities of the given algorithms, as well as plotting the graph to visualize the crossover point. The tool's mathematical capabilities and code generation features facilitated the analysis and comparison of the algorithms. However, ensuring the problem's spirit was maintained involved translating mathematical expressions into code and generating a clear graphical representation, which presented a challenge in terms of accuracy and clarity. This task highlighted the importance of precise problem design when translating mathematical concepts into code and visualizations, emphasizing the need for effective communication between mathematical notation and algorithmic implementation." + ] + }, + { + "cell_type": "markdown", + "id": "78b57615-cf24-4ef3-81b7-460e1c5026a5", + "metadata": {}, + "source": [ + "## Problem 8 (10 Points)\n", + "\n", + "Consider two algorithms, Algorithm A and Algorithm B, each with their respective time complexities as functions of the input size n:\n", + "\n", + "Algorithm A requires $n^2$ seconds.\n", + "Algorithm B requires $2^n$ seconds.\n", + "\n", + "Which algorithm grows asymptotically faster as n gets large, and what is the crossover value of n, if it exists?" + ] + }, + { + "cell_type": "markdown", + "id": "b1717937-79c8-48f6-9e91-ec4c887a9817", + "metadata": {}, + "source": [ + "## Solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "1f14a593-9fcc-48dd-96bf-4e6296869f1c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Algorithm B (2^n) grows asymptotically faster than Algorithm A (n^2), and the crossover point is at n = 1.\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Define the functions for Algorithm A and Algorithm B\n", + "def algorithm_A(n):\n", + " return n**2\n", + "\n", + "def algorithm_B(n):\n", + " return 2**n\n", + "\n", + "# Create an array of n values\n", + "n_values = np.arange(1, 20)\n", + "\n", + "# Calculate the corresponding time complexities for both algorithms\n", + "time_complexity_A = [algorithm_A(n) for n in n_values]\n", + "time_complexity_B = [algorithm_B(n) for n in n_values]\n", + "\n", + "# Plot the time complexities\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(n_values, time_complexity_A, label='Algorithm A (n^2)')\n", + "plt.plot(n_values, time_complexity_B, label='Algorithm B (2^n)')\n", + "plt.xlabel('Input Size (n)')\n", + "plt.ylabel('Time Complexity (T(n))')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "\n", + "# Find the crossover point (if it exists)\n", + "crossover_point = None\n", + "for n in n_values:\n", + " if algorithm_A(n) < algorithm_B(n):\n", + " crossover_point = n\n", + " break\n", + "\n", + "if crossover_point is not None:\n", + " plt.axvline(x=crossover_point, color='red', linestyle='--', label=f'Crossover Point (n={crossover_point})')\n", + "\n", + "plt.title('Comparison of Time Complexities')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Print the result\n", + "if crossover_point is not None:\n", + " print(f\"Algorithm B (2^n) grows asymptotically faster than Algorithm A (n^2), and the crossover point is at n = {crossover_point}.\")\n", + "else:\n", + " print(\"There is no crossover point; Algorithm B (2^n) always grows faster than Algorithm A (n^2).\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "eef9bac0-88bf-4f11-b1c7-dea2ea10f817", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "In tackling Problem 8, ChatGPT played a pivotal role in both computing and presenting the time complexities of Algorithm A and Algorithm B. The tool's mathematical capabilities enabled the formulation of these complexities and the generation of a graphical representation to compare them effectively. However, the primary challenge was to determine the crossover point, if it existed, which required iterating through a range of values. This task underscored the significance of understanding and analyzing asymptotic behavior in algorithms and highlighted the utility of graphical representations for conveying complex mathematical concepts. It also reinforced the importance of considering algorithmic efficiency in choosing between different algorithms for large input sizes." + ] + }, + { + "cell_type": "markdown", + "id": "9afef839-0825-4d50-810f-3920b1609980", + "metadata": {}, + "source": [ + "## Problem 9 (10 Points)\n", + "\n", + "You are a manager at a video game development studio, and you are competing with another studio to release the most successful video game during the holiday season. Each studio has a team of game developers who are skilled in different aspects of game development, such as programming, art design, and sound production. Each developer has a unique set of skills, and their combined skills contribute to the success of the game.\n", + "\n", + "Your goal is to assign your developers to various roles in the game development process to maximize the game's success, as measured by game ratings. Each developer has a skill rating for each role they can take on, and higher ratings lead to better results in that role. You and the competing studio each have a strategy for assigning developers to roles. Can you find a stable pair of strategies, or show that it's not always possible?" + ] + }, + { + "cell_type": "markdown", + "id": "913984d2-7b12-4ee1-8f33-90cb58ecf545", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "In this scenario, it is not always possible to find a stable pair of strategies. Let's consider an example:\n", + "\n", + "Studio X has three developers: Alice, Bob, and Carol.\n", + "Studio Y also has three developers: Dave, Eve, and Frank.\n", + "There are three roles in game development: programming, art design, and sound production.\n", + "Here are the skill ratings for each developer in each role:\n", + "\n", + "Studio X:\n", + "\n", + " - Alice: Programming (5), Art Design (3), Sound Production (2)\n", + " - Bob: Programming (4), Art Design (3), Sound Production (4)\n", + " - Carol: Programming (2), Art Design (4), Sound Production (5)\n", + "\n", + "Studio Y:\n", + "\n", + " - Dave: Programming (3), Art Design (5), Sound Production (2)\n", + " - Eve: Programming (5), Art Design (4), Sound Production (3)\n", + " - Frank: Programming (4), Art Design (2), Sound Production (4)\n", + "\n", + "\n", + "Each studio can choose a strategy for assigning developers to roles. Let's say Studio X chooses the strategy of assigning Alice to Programming, Bob to Art Design, and Carol to Sound Production. Studio Y can respond with the strategy of assigning Dave to Programming, Eve to Art Design, and Frank to Sound Production.\n", + "\n", + "In this scenario, both studios have a balanced set of developers for their respective roles. If Studio X tries to change its strategy, say by moving Bob to Programming and Carol to Art Design, Studio Y can respond by assigning Dave to Art Design, Eve to Sound Production, and Frank to Programming. In this way, Studio Y can always counter any strategy chosen by Studio X, and vice versa.\n", + "\n", + "Therefore, there is no stable pair of strategies, as both studios can adjust their strategies to compete effectively in the game development competition." + ] + }, + { + "cell_type": "markdown", + "id": "2160f49e-56e8-4ee1-acd0-84b3e76931f6", + "metadata": {}, + "source": [ + "#### Reflection: \n", + "\n", + "The problem discussed in Problem 9 sheds light on the applicability of the Gale-Shapley algorithm and its limitations in dynamic, competitive settings. While Gale-Shapley excels at ensuring stable matches in scenarios with fixed preferences, it may not hold when entities can adapt their strategies in response to each other's choices. This underscores the importance of strategic thinking and adaptability in real-world competitive environments and highlights that stability is not always guaranteed when strategies are dynamic.\n", + "\n", + "In summary, while Gale-Shapley remains a valuable algorithm for specific matching problems, its effectiveness can be challenged in scenarios where strategies are subject to change, emphasizing the need to consider the algorithm's limitations in practical applications." + ] + }, + { + "cell_type": "markdown", + "id": "810e0dde-9cce-449b-a5c5-a4d816b00892", + "metadata": {}, + "source": [ + "## Problem 10 (10 Points)\n", + "\n", + "\n", + "### Part A\n", + "\n", + "Imagine you are the coordinator for an internship program at a university. There are eight companies (Company A to Company H) offering internships, and there are eight students (Student 1 to Student 8) looking for internships. Each company has its preferences for the students, and each student has their preferences for the companies." + ] + }, + { + "cell_type": "markdown", + "id": "c4538a8e-3703-4717-a36f-3966b5106f53", + "metadata": {}, + "source": [ + "Companies' Preferences:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "15216523-c32c-4407-a8a5-d02676d1f4b1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "company_preferences = {\n", + " 'Company A': ['Student 1', 'Student 2', 'Student 3', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company B': ['Student 2', 'Student 3', 'Student 1', 'Student 4', 'Student 5', 'Student 6', 'Student 8', 'Student 7'],\n", + " 'Company C': ['Student 3', 'Student 1', 'Student 2', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company D': ['Student 1', 'Student 4', 'Student 2', 'Student 5', 'Student 3', 'Student 7', 'Student 6', 'Student 8'],\n", + " 'Company E': ['Student 2', 'Student 3', 'Student 1', 'Student 4', 'Student 5', 'Student 6', 'Student 8', 'Student 7'],\n", + " 'Company F': ['Student 8', 'Student 7', 'Student 6', 'Student 5', 'Student 4', 'Student 3', 'Student 2', 'Student 1'],\n", + " 'Company G': ['Student 1', 'Student 2', 'Student 3', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company H': ['Student 2', 'Student 1', 'Student 4', 'Student 3', 'Student 6', 'Student 5', 'Student 8', 'Student 7'],\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "id": "9b4ccb90-779f-4d40-ab4f-8169f5398a7d", + "metadata": { + "tags": [] + }, + "source": [ + "Students' Preferences:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9ec75edf-7aea-436b-86f8-19994423a3d9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "student_preferences = {\n", + " 'Student 1': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company G', 'Company H', 'Company F'],\n", + " 'Student 2': ['Company A', 'Company B', 'Company C', 'Company E', 'Company D', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 3': ['Company A', 'Company C', 'Company B', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 4': ['Company B', 'Company D', 'Company A', 'Company C', 'Company E', 'Company G', 'Company H', 'Company F'],\n", + " 'Student 5': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 6': ['Company F', 'Company G', 'Company H', 'Company E', 'Company D', 'Company C', 'Company B', 'Company A'],\n", + " 'Student 7': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 8': ['Company B', 'Company A', 'Company D', 'Company C', 'Company F', 'Company E', 'Company H', 'Company G'],\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "6bf2e7dc-8f37-4256-b482-40284b3d9701", + "metadata": {}, + "source": [ + "Your task is to implement the Gale-Shapley algorithm to match students with companies in a way that maximizes overall satisfaction. Once the matching is complete, print the final assignments of students to companies." + ] + }, + { + "cell_type": "markdown", + "id": "c4fcf298-70b3-4794-ae05-ecdfce22038c", + "metadata": {}, + "source": [ + "### Part B\n", + "\n", + "Use a loop to shuffle the preference lists for each team 1000 times. Calculate the percentage of stable playoff matches. See the function random.shuffle(x[, random])\n", + "https://docs.python.org/2/library/random.html" + ] + }, + { + "cell_type": "markdown", + "id": "4a93958b-b7da-4cac-8ffa-7fe950894d9a", + "metadata": {}, + "source": [ + "## Solution:\n", + "\n", + "### Part A" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e07c103c-9542-45e2-b671-c0eb4a5d5b9e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company H\n" + ] + } + ], + "source": [ + "def gale_shapley(company_preferences, student_preferences):\n", + " unmatched_students = list(student_preferences.keys())\n", + " student_to_company = {}\n", + " \n", + " while unmatched_students:\n", + " student = unmatched_students.pop(0)\n", + " company_preferences_for_student = student_preferences[student]\n", + " \n", + " for company in company_preferences_for_student:\n", + " current_student = student_to_company.get(company)\n", + " \n", + " if current_student is None:\n", + " # Company is unassigned, assign the student to the company\n", + " student_to_company[company] = student\n", + " break\n", + " else:\n", + " # Check the preferences of the company\n", + " current_student_index = company_preferences[company].index(current_student)\n", + " new_student_index = company_preferences[company].index(student)\n", + " \n", + " if new_student_index < current_student_index:\n", + " # New student is preferred, unassign the current student\n", + " student_to_company[company] = student\n", + " unmatched_students.append(current_student)\n", + " break\n", + " \n", + " return student_to_company\n", + "\n", + "# Company preferences and student preferences as defined in the problem\n", + "company_preferences = {\n", + " 'Company A': ['Student 1', 'Student 2', 'Student 3', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company B': ['Student 2', 'Student 3', 'Student 1', 'Student 4', 'Student 5', 'Student 6', 'Student 8', 'Student 7'],\n", + " 'Company C': ['Student 3', 'Student 1', 'Student 2', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company D': ['Student 1', 'Student 4', 'Student 2', 'Student 5', 'Student 3', 'Student 7', 'Student 6', 'Student 8'],\n", + " 'Company E': ['Student 2', 'Student 3', 'Student 1', 'Student 4', 'Student 5', 'Student 6', 'Student 8', 'Student 7'],\n", + " 'Company F': ['Student 8', 'Student 7', 'Student 6', 'Student 5', 'Student 4', 'Student 3', 'Student 2', 'Student 1'],\n", + " 'Company G': ['Student 1', 'Student 2', 'Student 3', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company H': ['Student 2', 'Student 1', 'Student 4', 'Student 3', 'Student 6', 'Student 5', 'Student 8', 'Student 7'],\n", + "}\n", + "\n", + "student_preferences = {\n", + " 'Student 1': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company G', 'Company H', 'Company F'],\n", + " 'Student 2': ['Company A', 'Company B', 'Company C', 'Company E', 'Company D', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 3': ['Company A', 'Company C', 'Company B', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 4': ['Company B', 'Company D', 'Company A', 'Company C', 'Company E', 'Company G', 'Company H', 'Company F'],\n", + " 'Student 5': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 6': ['Company F', 'Company G', 'Company H', 'Company E', 'Company D', 'Company C', 'Company B', 'Company A'],\n", + " 'Student 7': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 8': ['Company B', 'Company A', 'Company D', 'Company C', 'Company F', 'Company E', 'Company H', 'Company G'],\n", + "}\n", + "\n", + "# Run the Gale-Shapley algorithm\n", + "result = gale_shapley(company_preferences, student_preferences)\n", + "\n", + "# Print the final assignments of students to companies\n", + "for company, student in result.items():\n", + " print(f\"{student} is assigned to {company}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "c537d1f8-a15a-4e0a-b0ae-a4bd5354e6f0", + "metadata": {}, + "source": [ + "### Part B" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "a90b9b43-8126-4f8b-9795-d38e03de554d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Match 1: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Match 2: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Match 3: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Match 4: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Match 5: Stable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Match 6: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Match 7: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Match 8: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company A\n", + "Match 9: Unstable\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Match 10: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Match 11: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Match 12: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Match 13: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Match 14: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Match 15: Unstable\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Match 16: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Match 17: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Match 18: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Match 19: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Match 20: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Match 21: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Match 22: Stable\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Match 23: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Match 24: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Match 25: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Match 26: Unstable\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Match 27: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Match 28: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Match 29: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Match 30: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Match 31: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Match 32: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Match 33: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Match 34: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Match 35: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Match 36: Unstable\n", + "Student 4 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Match 37: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Match 38: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Match 39: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Match 40: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Match 41: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Match 42: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Match 43: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Match 44: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Match 45: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Match 46: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company G\n", + "Match 47: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Match 48: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Match 49: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Match 50: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Match 51: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Match 52: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Match 53: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Match 54: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Match 55: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Match 56: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Match 57: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Match 58: Unstable\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Match 59: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Match 60: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Match 61: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Match 62: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Match 63: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Match 64: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Match 65: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Match 66: Unstable\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Match 67: Stable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Match 68: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Match 69: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Match 70: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Match 71: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Match 72: Unstable\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Match 73: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Match 74: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Match 75: Unstable\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Match 76: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Match 77: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Match 78: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Match 79: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Match 80: Stable\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Match 81: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Match 82: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Match 83: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Match 84: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Match 85: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Match 86: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Match 87: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Match 88: Unstable\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Match 89: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Match 90: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Match 91: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Match 92: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Match 93: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Match 94: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Match 95: Unstable\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Match 96: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Match 97: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Match 98: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Match 99: Stable\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Match 100: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Match 101: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Match 102: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Match 103: Unstable\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Match 104: Unstable\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Match 105: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Match 106: Unstable\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Match 107: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Match 108: Stable\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Match 109: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Match 110: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Match 111: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Match 112: Unstable\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Match 113: Unstable\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Match 114: Stable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Match 115: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Match 116: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Match 117: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Match 118: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Match 119: Stable\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Match 120: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Match 121: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Match 122: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Match 123: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Match 124: Stable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Match 125: Unstable\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Match 126: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Match 127: Stable\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Match 128: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Match 129: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Match 130: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Match 131: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Match 132: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Match 133: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Match 134: Unstable\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Match 135: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Match 136: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Match 137: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Match 138: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Match 139: Unstable\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Match 140: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Match 141: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Match 142: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Match 143: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Match 144: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Match 145: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Match 146: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Match 147: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Match 148: Unstable\n", + "Student 2 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company C\n", + "Match 149: Unstable\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Match 150: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Match 151: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Match 152: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Match 153: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Match 154: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Match 155: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Match 156: Unstable\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Match 157: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Match 158: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Match 159: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Match 160: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Match 161: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company C\n", + "Match 162: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Match 163: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Match 164: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Match 165: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Match 166: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Match 167: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Match 168: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Match 169: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Match 170: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Match 171: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Match 172: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Match 173: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Match 174: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Match 175: Stable\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Match 176: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Match 177: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Match 178: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Match 179: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Match 180: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Match 181: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Match 182: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Match 183: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Match 184: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Match 185: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Match 186: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Match 187: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Match 188: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Match 189: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Match 190: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Match 191: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Match 192: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Match 193: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Match 194: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Match 195: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Match 196: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Match 197: Stable\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Match 198: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Match 199: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Match 200: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Match 201: Unstable\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Match 202: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Match 203: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Match 204: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Match 205: Unstable\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Match 206: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Match 207: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Match 208: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Match 209: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Match 210: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Match 211: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Match 212: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Match 213: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company C\n", + "Match 214: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Match 215: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Match 216: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Match 217: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Match 218: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Match 219: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Match 220: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Match 221: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Match 222: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 1 is assigned to Company A\n", + "Match 223: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Match 224: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Match 225: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Match 226: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Match 227: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Match 228: Stable\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Match 229: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Match 230: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Match 231: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Match 232: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Match 233: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Match 234: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Match 235: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Match 236: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Match 237: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Match 238: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Match 239: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Match 240: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Match 241: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Match 242: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Match 243: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Match 244: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Match 245: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Match 246: Stable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Match 247: Unstable\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Match 248: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Match 249: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Match 250: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Match 251: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Match 252: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Match 253: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Match 254: Stable\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Match 255: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Match 256: Unstable\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Match 257: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Match 258: Unstable\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Match 259: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Match 260: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Match 261: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Match 262: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Match 263: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Match 264: Stable\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Match 265: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Match 266: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Match 267: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Match 268: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Match 269: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Match 270: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Match 271: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Match 272: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Match 273: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Match 274: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Match 275: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Match 276: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Match 277: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Match 278: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Match 279: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Match 280: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Match 281: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Match 282: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Match 283: Stable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Match 284: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Match 285: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Match 286: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Match 287: Unstable\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Match 288: Stable\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Match 289: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Match 290: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Match 291: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Match 292: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Match 293: Stable\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Match 294: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Match 295: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Match 296: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Match 297: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Match 298: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Match 299: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Match 300: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Match 301: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Match 302: Unstable\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Match 303: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Match 304: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Match 305: Unstable\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Match 306: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Match 307: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Match 308: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Match 309: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Match 310: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Match 311: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Match 312: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Match 313: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Match 314: Stable\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Match 315: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Match 316: Stable\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Match 317: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Match 318: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Match 319: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Match 320: Stable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Match 321: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Match 322: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Match 323: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Match 324: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Match 325: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Match 326: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Match 327: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Match 328: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Match 329: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Match 330: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Match 331: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Match 332: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Match 333: Stable\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Match 334: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Match 335: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Match 336: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Match 337: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Match 338: Unstable\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Match 339: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Match 340: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Match 341: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Match 342: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Match 343: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Match 344: Stable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Match 345: Stable\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Match 346: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Match 347: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Match 348: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Match 349: Unstable\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Match 350: Unstable\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Match 351: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Match 352: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Match 353: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Match 354: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Match 355: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Match 356: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Match 357: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Match 358: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Match 359: Unstable\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Match 360: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Match 361: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Match 362: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Match 363: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Match 364: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Match 365: Unstable\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Match 366: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Match 367: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Match 368: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Match 369: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Match 370: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Match 371: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Match 372: Stable\n", + "Student 1 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Match 373: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Match 374: Unstable\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Match 375: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Match 376: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Match 377: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Match 378: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Match 379: Unstable\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Match 380: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Match 381: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Match 382: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Match 383: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Match 384: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Match 385: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Match 386: Stable\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Match 387: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Match 388: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Match 389: Unstable\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Match 390: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Match 391: Stable\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Match 392: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Match 393: Unstable\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Match 394: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Match 395: Stable\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Match 396: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Match 397: Unstable\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Match 398: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Match 399: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Match 400: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Match 401: Stable\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Match 402: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Match 403: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Match 404: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Match 405: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Match 406: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Match 407: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Match 408: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Match 409: Unstable\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company E\n", + "Match 410: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Match 411: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Match 412: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Match 413: Stable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Match 414: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Match 415: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Match 416: Unstable\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Match 417: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Match 418: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Match 419: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Match 420: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Match 421: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Match 422: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Match 423: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Match 424: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Match 425: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Match 426: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Match 427: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Match 428: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Match 429: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Match 430: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Match 431: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Match 432: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Match 433: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Match 434: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Match 435: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Match 436: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Match 437: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Match 438: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Match 439: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Match 440: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Match 441: Stable\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Match 442: Unstable\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Match 443: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Match 444: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Match 445: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Match 446: Stable\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Match 447: Stable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Match 448: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Match 449: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Match 450: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Match 451: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Match 452: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Match 453: Unstable\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Match 454: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Match 455: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Match 456: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Match 457: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Match 458: Stable\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Match 459: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Match 460: Unstable\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Match 461: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Match 462: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Match 463: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Match 464: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Match 465: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Match 466: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Match 467: Stable\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Match 468: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Match 469: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Match 470: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Match 471: Unstable\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Match 472: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Match 473: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Match 474: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Match 475: Unstable\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Match 476: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Match 477: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Match 478: Unstable\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Match 479: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Match 480: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Match 481: Unstable\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Match 482: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Match 483: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Match 484: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Match 485: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Match 486: Stable\n", + "Student 7 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Match 487: Stable\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Match 488: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Match 489: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Match 490: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Match 491: Unstable\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Match 492: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Match 493: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Match 494: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Match 495: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Match 496: Stable\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Match 497: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Match 498: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Match 499: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Match 500: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Match 501: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Match 502: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Match 503: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Match 504: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Match 505: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Match 506: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Match 507: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Match 508: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Match 509: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Match 510: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Match 511: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Match 512: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Match 513: Stable\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Match 514: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Match 515: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Match 516: Unstable\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Match 517: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Match 518: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Match 519: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Match 520: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Match 521: Stable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Match 522: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Match 523: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Match 524: Unstable\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Match 525: Unstable\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Match 526: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Match 527: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Match 528: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Match 529: Unstable\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Match 530: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Match 531: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Match 532: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Match 533: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Match 534: Unstable\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Match 535: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Match 536: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Match 537: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Match 538: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Match 539: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Match 540: Stable\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Match 541: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Match 542: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Match 543: Unstable\n", + "Student 7 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Match 544: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Match 545: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Match 546: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Match 547: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Match 548: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Match 549: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Match 550: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Match 551: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Match 552: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Match 553: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Match 554: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Match 555: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Match 556: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Match 557: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Match 558: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Match 559: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Match 560: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Match 561: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Match 562: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Match 563: Unstable\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Match 564: Unstable\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Match 565: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Match 566: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Match 567: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Match 568: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Match 569: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Match 570: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Match 571: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Match 572: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Match 573: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Match 574: Stable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Match 575: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Match 576: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Match 577: Stable\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Match 578: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Match 579: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Match 580: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Match 581: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Match 582: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Match 583: Unstable\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Match 584: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Match 585: Stable\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Match 586: Unstable\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Match 587: Stable\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Match 588: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Match 589: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Match 590: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Match 591: Unstable\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Match 592: Stable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Match 593: Unstable\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Match 594: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Match 595: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Match 596: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Match 597: Unstable\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Match 598: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Match 599: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Match 600: Unstable\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Match 601: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Match 602: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Match 603: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Match 604: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Match 605: Stable\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Match 606: Unstable\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Match 607: Unstable\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Match 608: Stable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Match 609: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Match 610: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Match 611: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Match 612: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Match 613: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company C\n", + "Match 614: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Match 615: Unstable\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Match 616: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Match 617: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Match 618: Stable\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Match 619: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Match 620: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Match 621: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Match 622: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Match 623: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Match 624: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Match 625: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Match 626: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Match 627: Stable\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Match 628: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Match 629: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Match 630: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Match 631: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Match 632: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company G\n", + "Match 633: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Match 634: Stable\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Match 635: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Match 636: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Match 637: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Match 638: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Match 639: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Match 640: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Match 641: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Match 642: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Match 643: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Match 644: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Match 645: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Match 646: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Match 647: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company H\n", + "Match 648: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Match 649: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Match 650: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Match 651: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Match 652: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Match 653: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Match 654: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Match 655: Stable\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Match 656: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Match 657: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Match 658: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Match 659: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Match 660: Unstable\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Match 661: Stable\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Match 662: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Match 663: Stable\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Match 664: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Match 665: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Match 666: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Match 667: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Match 668: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Match 669: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Match 670: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Match 671: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Match 672: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Match 673: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Match 674: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Match 675: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Match 676: Unstable\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Match 677: Unstable\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Match 678: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Match 679: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Match 680: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Match 681: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Match 682: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Match 683: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Match 684: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Match 685: Unstable\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Match 686: Unstable\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Match 687: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Match 688: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Match 689: Stable\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Match 690: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Match 691: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company C\n", + "Match 692: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Match 693: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Match 694: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Match 695: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Match 696: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Match 697: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Match 698: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Match 699: Stable\n", + "Student 4 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Match 700: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Match 701: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Match 702: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Match 703: Unstable\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Match 704: Stable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Match 705: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Match 706: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Match 707: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Match 708: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Match 709: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Match 710: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Match 711: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Match 712: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Match 713: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Match 714: Unstable\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Match 715: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Match 716: Stable\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Match 717: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Match 718: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Match 719: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Match 720: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Match 721: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Match 722: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Match 723: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Match 724: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Match 725: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Match 726: Stable\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Match 727: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Match 728: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Match 729: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Match 730: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Match 731: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Match 732: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Match 733: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Match 734: Unstable\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Match 735: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Match 736: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Match 737: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Match 738: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Match 739: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Match 740: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Match 741: Unstable\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Match 742: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Match 743: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Match 744: Unstable\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Match 745: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Match 746: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Match 747: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Match 748: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Match 749: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Match 750: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Match 751: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Match 752: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Match 753: Stable\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company E\n", + "Match 754: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Match 755: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Match 756: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Match 757: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Match 758: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Match 759: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Match 760: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Match 761: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 1 is assigned to Company C\n", + "Match 762: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Match 763: Stable\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Match 764: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Match 765: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Match 766: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Match 767: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Match 768: Unstable\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Match 769: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Match 770: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Match 771: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Match 772: Unstable\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Match 773: Unstable\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Match 774: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Match 775: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Match 776: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Match 777: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Match 778: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Match 779: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Match 780: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Match 781: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Match 782: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Match 783: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Match 784: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Match 785: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Match 786: Stable\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 1 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Match 787: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Match 788: Unstable\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Match 789: Stable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Match 790: Unstable\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Match 791: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Match 792: Unstable\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Match 793: Unstable\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Match 794: Stable\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Match 795: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Match 796: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Match 797: Unstable\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Match 798: Unstable\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Match 799: Unstable\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Match 800: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Match 801: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Match 802: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Match 803: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Match 804: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Match 805: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company G\n", + "Match 806: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company A\n", + "Match 807: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Match 808: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Match 809: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Match 810: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Match 811: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Match 812: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Match 813: Stable\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Match 814: Unstable\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Match 815: Unstable\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Match 816: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Match 817: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Match 818: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Match 819: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Match 820: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Match 821: Unstable\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Match 822: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Match 823: Unstable\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Match 824: Unstable\n", + "Student 5 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Match 825: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Match 826: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Match 827: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Match 828: Unstable\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company F\n", + "Match 829: Unstable\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Match 830: Unstable\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Match 831: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Match 832: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Match 833: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Match 834: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Match 835: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Match 836: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Match 837: Unstable\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Match 838: Unstable\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Match 839: Unstable\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Match 840: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company H\n", + "Match 841: Stable\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Match 842: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company F\n", + "Match 843: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Match 844: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Match 845: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Match 846: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Match 847: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Match 848: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Match 849: Unstable\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company H\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Match 850: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Match 851: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Match 852: Unstable\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Match 853: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Match 854: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Match 855: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company C\n", + "Match 856: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company A\n", + "Match 857: Stable\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company C\n", + "Match 858: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Match 859: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Match 860: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Match 861: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Match 862: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 4 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Match 863: Stable\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Match 864: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Match 865: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 1 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Match 866: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Match 867: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Match 868: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Match 869: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Match 870: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Match 871: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Match 872: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Match 873: Unstable\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Match 874: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company C\n", + "Match 875: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Match 876: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Match 877: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company A\n", + "Match 878: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 3 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Match 879: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Match 880: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Match 881: Stable\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Match 882: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company F\n", + "Match 883: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company B\n", + "Match 884: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Match 885: Unstable\n", + "Student 3 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Match 886: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 8 is assigned to Company B\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Match 887: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Match 888: Unstable\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Match 889: Unstable\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Match 890: Stable\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company G\n", + "Match 891: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Match 892: Unstable\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Match 893: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company A\n", + "Student 8 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Match 894: Unstable\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company B\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company H\n", + "Student 1 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Match 895: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Match 896: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Match 897: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Match 898: Stable\n", + "Student 4 is assigned to Company C\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Student 3 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Match 899: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Match 900: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Match 901: Unstable\n", + "Student 3 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Match 902: Unstable\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company B\n", + "Student 5 is assigned to Company G\n", + "Student 1 is assigned to Company H\n", + "Match 903: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company B\n", + "Student 1 is assigned to Company D\n", + "Match 904: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Match 905: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Match 906: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Match 907: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Match 908: Unstable\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Match 909: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Match 910: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Match 911: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Match 912: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Match 913: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 8 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Match 914: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company H\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 1 is assigned to Company G\n", + "Match 915: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Student 2 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Match 916: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Match 917: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Match 918: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Match 919: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Match 920: Unstable\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company G\n", + "Student 6 is assigned to Company A\n", + "Student 4 is assigned to Company D\n", + "Match 921: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Match 922: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Match 923: Unstable\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 5 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Match 924: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Match 925: Unstable\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 4 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Student 1 is assigned to Company G\n", + "Match 926: Unstable\n", + "Student 7 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company D\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company A\n", + "Match 927: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Match 928: Unstable\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Match 929: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Student 6 is assigned to Company D\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company A\n", + "Match 930: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 8 is assigned to Company C\n", + "Student 5 is assigned to Company F\n", + "Match 931: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company E\n", + "Match 932: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company G\n", + "Match 933: Unstable\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 4 is assigned to Company F\n", + "Student 1 is assigned to Company G\n", + "Match 934: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Match 935: Stable\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 1 is assigned to Company E\n", + "Match 936: Stable\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 1 is assigned to Company H\n", + "Match 937: Unstable\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 3 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 1 is assigned to Company A\n", + "Student 7 is assigned to Company F\n", + "Match 938: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Match 939: Unstable\n", + "Student 1 is assigned to Company A\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Match 940: Unstable\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company B\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Match 941: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 4 is assigned to Company H\n", + "Match 942: Unstable\n", + "Student 4 is assigned to Company A\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 5 is assigned to Company D\n", + "Match 943: Unstable\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Match 944: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 5 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Match 945: Unstable\n", + "Student 6 is assigned to Company H\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company D\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company C\n", + "Student 3 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Match 946: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company A\n", + "Match 947: Unstable\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 1 is assigned to Company D\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company B\n", + "Match 948: Unstable\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 6 is assigned to Company C\n", + "Match 949: Unstable\n", + "Student 3 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Match 950: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company C\n", + "Student 1 is assigned to Company B\n", + "Match 951: Unstable\n", + "Student 2 is assigned to Company C\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Match 952: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Match 953: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 3 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company E\n", + "Match 954: Unstable\n", + "Student 1 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Match 955: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 8 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Match 956: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Match 957: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company H\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 3 is assigned to Company C\n", + "Match 958: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 3 is assigned to Company H\n", + "Match 959: Unstable\n", + "Student 5 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 3 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Match 960: Unstable\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company D\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company H\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Match 961: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 2 is assigned to Company A\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company C\n", + "Match 962: Unstable\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company F\n", + "Student 4 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 3 is assigned to Company E\n", + "Match 963: Unstable\n", + "Student 6 is assigned to Company A\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company C\n", + "Student 4 is assigned to Company E\n", + "Student 7 is assigned to Company D\n", + "Match 964: Unstable\n", + "Student 6 is assigned to Company F\n", + "Student 1 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company H\n", + "Match 965: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company B\n", + "Student 7 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 1 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company F\n", + "Match 966: Unstable\n", + "Student 1 is assigned to Company B\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company C\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 8 is assigned to Company F\n", + "Match 967: Unstable\n", + "Student 5 is assigned to Company H\n", + "Student 2 is assigned to Company G\n", + "Student 7 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company C\n", + "Student 3 is assigned to Company F\n", + "Match 968: Unstable\n", + "Student 6 is assigned to Company D\n", + "Student 3 is assigned to Company H\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Match 969: Unstable\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 5 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Match 970: Unstable\n", + "Student 2 is assigned to Company A\n", + "Student 6 is assigned to Company D\n", + "Student 4 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 8 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Match 971: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 6 is assigned to Company G\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 4 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Match 972: Unstable\n", + "Student 2 is assigned to Company F\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Match 973: Stable\n", + "Student 3 is assigned to Company A\n", + "Student 6 is assigned to Company B\n", + "Student 4 is assigned to Company F\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company H\n", + "Student 2 is assigned to Company D\n", + "Student 5 is assigned to Company C\n", + "Match 974: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Match 975: Unstable\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 7 is assigned to Company G\n", + "Student 8 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 1 is assigned to Company F\n", + "Match 976: Stable\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company G\n", + "Student 7 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Match 977: Unstable\n", + "Student 7 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Student 6 is assigned to Company D\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company F\n", + "Student 5 is assigned to Company B\n", + "Match 978: Unstable\n", + "Student 8 is assigned to Company H\n", + "Student 2 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 7 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company B\n", + "Student 6 is assigned to Company F\n", + "Match 979: Stable\n", + "Student 5 is assigned to Company C\n", + "Student 3 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Student 4 is assigned to Company E\n", + "Student 6 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Student 2 is assigned to Company G\n", + "Match 980: Unstable\n", + "Student 1 is assigned to Company D\n", + "Student 7 is assigned to Company A\n", + "Student 3 is assigned to Company E\n", + "Student 4 is assigned to Company F\n", + "Student 5 is assigned to Company G\n", + "Student 6 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 2 is assigned to Company H\n", + "Match 981: Unstable\n", + "Student 5 is assigned to Company C\n", + "Student 8 is assigned to Company E\n", + "Student 1 is assigned to Company G\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company B\n", + "Student 2 is assigned to Company H\n", + "Student 6 is assigned to Company A\n", + "Match 982: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company E\n", + "Student 3 is assigned to Company B\n", + "Student 5 is assigned to Company H\n", + "Student 6 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 8 is assigned to Company D\n", + "Student 7 is assigned to Company C\n", + "Match 983: Unstable\n", + "Student 1 is assigned to Company F\n", + "Student 2 is assigned to Company B\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 6 is assigned to Company A\n", + "Student 7 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 3 is assigned to Company E\n", + "Match 984: Unstable\n", + "Student 5 is assigned to Company H\n", + "Student 7 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 4 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 8 is assigned to Company D\n", + "Student 2 is assigned to Company B\n", + "Student 1 is assigned to Company E\n", + "Match 985: Stable\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company A\n", + "Student 3 is assigned to Company F\n", + "Student 4 is assigned to Company G\n", + "Student 2 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company H\n", + "Match 986: Unstable\n", + "Student 5 is assigned to Company B\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company E\n", + "Student 2 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company C\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company H\n", + "Match 987: Unstable\n", + "Student 4 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 7 is assigned to Company B\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company C\n", + "Match 988: Unstable\n", + "Student 4 is assigned to Company C\n", + "Student 2 is assigned to Company G\n", + "Student 8 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company F\n", + "Student 7 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 3 is assigned to Company A\n", + "Match 989: Unstable\n", + "Student 2 is assigned to Company E\n", + "Student 8 is assigned to Company H\n", + "Student 4 is assigned to Company D\n", + "Student 7 is assigned to Company G\n", + "Student 5 is assigned to Company A\n", + "Student 6 is assigned to Company C\n", + "Student 3 is assigned to Company B\n", + "Student 1 is assigned to Company F\n", + "Match 990: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company H\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company C\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company F\n", + "Student 1 is assigned to Company D\n", + "Match 991: Unstable\n", + "Student 3 is assigned to Company D\n", + "Student 2 is assigned to Company F\n", + "Student 1 is assigned to Company E\n", + "Student 5 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company G\n", + "Student 8 is assigned to Company A\n", + "Student 7 is assigned to Company C\n", + "Match 992: Unstable\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company H\n", + "Student 8 is assigned to Company C\n", + "Student 4 is assigned to Company F\n", + "Student 7 is assigned to Company A\n", + "Student 1 is assigned to Company B\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company D\n", + "Match 993: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 6 is assigned to Company E\n", + "Student 2 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Student 5 is assigned to Company F\n", + "Student 7 is assigned to Company G\n", + "Student 3 is assigned to Company H\n", + "Student 8 is assigned to Company D\n", + "Match 994: Unstable\n", + "Student 4 is assigned to Company H\n", + "Student 6 is assigned to Company F\n", + "Student 3 is assigned to Company G\n", + "Student 5 is assigned to Company D\n", + "Student 1 is assigned to Company B\n", + "Student 7 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Student 8 is assigned to Company A\n", + "Match 995: Unstable\n", + "Student 2 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company F\n", + "Student 6 is assigned to Company D\n", + "Student 7 is assigned to Company B\n", + "Student 8 is assigned to Company C\n", + "Student 1 is assigned to Company H\n", + "Match 996: Unstable\n", + "Student 1 is assigned to Company G\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 4 is assigned to Company A\n", + "Student 7 is assigned to Company B\n", + "Student 3 is assigned to Company D\n", + "Student 5 is assigned to Company E\n", + "Student 2 is assigned to Company C\n", + "Match 997: Unstable\n", + "Student 2 is assigned to Company D\n", + "Student 4 is assigned to Company G\n", + "Student 5 is assigned to Company E\n", + "Student 6 is assigned to Company B\n", + "Student 7 is assigned to Company F\n", + "Student 8 is assigned to Company H\n", + "Student 1 is assigned to Company A\n", + "Student 3 is assigned to Company C\n", + "Match 998: Unstable\n", + "Student 5 is assigned to Company D\n", + "Student 8 is assigned to Company G\n", + "Student 3 is assigned to Company A\n", + "Student 4 is assigned to Company B\n", + "Student 2 is assigned to Company F\n", + "Student 6 is assigned to Company H\n", + "Student 7 is assigned to Company E\n", + "Student 1 is assigned to Company C\n", + "Match 999: Unstable\n", + "Student 7 is assigned to Company B\n", + "Student 6 is assigned to Company H\n", + "Student 5 is assigned to Company A\n", + "Student 4 is assigned to Company G\n", + "Student 1 is assigned to Company F\n", + "Student 8 is assigned to Company E\n", + "Student 3 is assigned to Company C\n", + "Student 2 is assigned to Company D\n", + "Match 1000: Unstable\n", + "Student 1 is assigned to Company C\n", + "Student 5 is assigned to Company D\n", + "Student 3 is assigned to Company A\n", + "Student 8 is assigned to Company F\n", + "Student 6 is assigned to Company G\n", + "Student 2 is assigned to Company E\n", + "Student 4 is assigned to Company H\n", + "Student 7 is assigned to Company B\n", + "Percentage of stable matches: 7.8%\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "def gale_shapley(company_preferences, student_preferences):\n", + " unmatched_students = list(student_preferences.keys())\n", + " student_to_company = {}\n", + " \n", + " while unmatched_students:\n", + " student = unmatched_students.pop(0)\n", + " company_preferences_for_student = student_preferences[student]\n", + " \n", + " for company in company_preferences_for_student:\n", + " current_student = student_to_company.get(company)\n", + " \n", + " if current_student is None:\n", + " # Company is unassigned, assign the student to the company\n", + " student_to_company[company] = student\n", + " break\n", + " else:\n", + " # Check the preferences of the company\n", + " current_student_index = company_preferences[company].index(current_student)\n", + " new_student_index = company_preferences[company].index(student)\n", + " \n", + " if new_student_index < current_student_index:\n", + " # New student is preferred, unassign the current student\n", + " student_to_company[company] = student\n", + " unmatched_students.append(current_student)\n", + " break\n", + " \n", + " return student_to_company\n", + "\n", + "def shuffle_preferences(preferences):\n", + " for _ in range(1000):\n", + " for team in preferences:\n", + " random.shuffle(preferences[team])\n", + "\n", + "def calculate_percentage_stable_matches(company_preferences, student_preferences):\n", + " num_stable_matches = 0\n", + " total_matches = 1000 # Number of times preferences are shuffled\n", + " \n", + " for iteration in range(total_matches):\n", + " shuffled_student_preferences = student_preferences.copy()\n", + " shuffled_company_preferences = company_preferences.copy()\n", + " \n", + " shuffle_preferences(shuffled_student_preferences)\n", + " shuffle_preferences(shuffled_company_preferences)\n", + " \n", + " result = gale_shapley(shuffled_company_preferences, shuffled_student_preferences)\n", + " \n", + " # Check if the result is stable\n", + " is_stable_match = is_stable(result, shuffled_company_preferences, shuffled_student_preferences)\n", + " \n", + " # Print the current match along with the label\n", + " print(f\"Match {iteration + 1}:\", \"Stable\" if is_stable_match else \"Unstable\")\n", + " for company, student in result.items():\n", + " print(f\"{student} is assigned to {company}\")\n", + " \n", + " if is_stable_match:\n", + " num_stable_matches += 1\n", + " \n", + " percentage_stable_matches = (num_stable_matches / total_matches) * 100\n", + " return percentage_stable_matches\n", + "\n", + "def is_stable(matching, company_preferences, student_preferences):\n", + " for company, student in matching.items():\n", + " company_pref = company_preferences[company]\n", + " student_pref = student_preferences[student]\n", + " \n", + " company_index = company_pref.index(student)\n", + " for other_student in company_pref[:company_index]:\n", + " other_student_pref = student_preferences[other_student]\n", + " other_student_index = other_student_pref.index(company)\n", + " \n", + " if other_student_index < company_index:\n", + " return False\n", + " \n", + " return True\n", + "\n", + "# Company preferences and student preferences as defined in the problem\n", + "company_preferences = {\n", + " 'Company A': ['Student 1', 'Student 2', 'Student 3', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company B': ['Student 2', 'Student 3', 'Student 1', 'Student 4', 'Student 5', 'Student 6', 'Student 8', 'Student 7'],\n", + " 'Company C': ['Student 3', 'Student 1', 'Student 2', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company D': ['Student 1', 'Student 4', 'Student 2', 'Student 5', 'Student 3', 'Student 7', 'Student 6', 'Student 8'],\n", + " 'Company E': ['Student 2', 'Student 3', 'Student 1', 'Student 4', 'Student 5', 'Student 6', 'Student 8', 'Student 7'],\n", + " 'Company F': ['Student 8', 'Student 7', 'Student 6', 'Student 5', 'Student 4', 'Student 3', 'Student 2', 'Student 1'],\n", + " 'Company G': ['Student 1', 'Student 2', 'Student 3', 'Student 4', 'Student 5', 'Student 6', 'Student 7', 'Student 8'],\n", + " 'Company H': ['Student 2', 'Student 1', 'Student 4', 'Student 3', 'Student 6', 'Student 5', 'Student 8', 'Student 7'],\n", + "}\n", + "\n", + "student_preferences = {\n", + " 'Student 1': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company G', 'Company H', 'Company F'],\n", + " 'Student 2': ['Company A', 'Company B', 'Company C', 'Company E', 'Company D', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 3': ['Company A', 'Company C', 'Company B', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 4': ['Company B', 'Company D', 'Company A', 'Company C', 'Company E', 'Company G', 'Company H', 'Company F'],\n", + " 'Student 5': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 6': ['Company F', 'Company G', 'Company H', 'Company E', 'Company D', 'Company C', 'Company B', 'Company A'],\n", + " 'Student 7': ['Company A', 'Company B', 'Company C', 'Company D', 'Company E', 'Company F', 'Company G', 'Company H'],\n", + " 'Student 8': ['Company B', 'Company A', 'Company D', 'Company C', 'Company F', 'Company E', 'Company H', 'Company G'],\n", + "}\n", + "\n", + "# Calculate the percentage of stable matches\n", + "percentage_stable = calculate_percentage_stable_matches(company_preferences, student_preferences)\n", + "print(f\"Percentage of stable matches: {percentage_stable}%\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "344b035d-de8f-42e4-bee3-be3e1fa571bc", + "metadata": {}, + "source": [ + "#### Reflection:\n", + "\n", + "This problem inspired by the Gale-Shapley matching algorithm problem mentioned in the sample question set. Challenges included maintaining the problem's spirit while introducing novel elements and ensuring the code executed efficiently for 1000 match iterations. This experience underscored the importance of balancing familiarity and innovation in problem design, while reinforcing the significance of algorithmic stability and preference matching in real-world scenarios. Used ChatGPT for helping out with code to test." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_A.ipynb b/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_A.ipynb new file mode 100644 index 0000000..e2c116d --- /dev/null +++ b/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_A.ipynb @@ -0,0 +1,166 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 48, + "id": "8c3d063e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Engagements:\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Eastern_1 dumped Western_5 for Western_2\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_5\n", + "\n", + "Couples:\n", + " Eastern_1 is matched to Western_2,\n", + " Eastern_2 is matched to Western_3,\n", + " Eastern_3 is matched to Western_6,\n", + " Eastern_4 is matched to Western_7,\n", + " Eastern_5 is matched to Western_5,\n", + " Eastern_6 is matched to Western_8,\n", + " Eastern_7 is matched to Western_4,\n", + " Eastern_8 is matched to Western_1\n", + "\n", + "Engagement stability check PASSED\n" + ] + } + ], + "source": [ + "import copy\n", + "\n", + "WesternTeam = {\n", + " 'Western_1': ['Eastern_8', 'Eastern_7', 'Eastern_6', 'Eastern_5', 'Eastern_4', 'Eastern_3', 'Eastern_2', 'Eastern_1'],\n", + " 'Western_2': ['Eastern_2', 'Eastern_4', 'Eastern_3', 'Eastern_8', 'Eastern_1', 'Eastern_5', 'Eastern_7', 'Eastern_6'],\n", + " 'Western_3': ['Eastern_2', 'Eastern_8', 'Eastern_1', 'Eastern_7', 'Eastern_6', 'Eastern_5', 'Eastern_4', 'Eastern_3'],\n", + " 'Western_4': ['Eastern_3', 'Eastern_6', 'Eastern_1', 'Eastern_8', 'Eastern_7', 'Eastern_2', 'Eastern_5', 'Eastern_4'],\n", + " 'Western_5': ['Eastern_1', 'Eastern_3', 'Eastern_5', 'Eastern_7', 'Eastern_2', 'Eastern_4', 'Eastern_6', 'Eastern_8'],\n", + " 'Western_6': ['Eastern_7', 'Eastern_6', 'Eastern_8', 'Eastern_4', 'Eastern_3', 'Eastern_1', 'Eastern_5', 'Eastern_2'],\n", + " 'Western_7': ['Eastern_4', 'Eastern_5', 'Eastern_2', 'Eastern_3', 'Eastern_6', 'Eastern_7', 'Eastern_8', 'Eastern_1'],\n", + " 'Western_8': ['Eastern_6', 'Eastern_8', 'Eastern_4', 'Eastern_1', 'Eastern_5', 'Eastern_2', 'Eastern_3', 'Eastern_7']\n", + "}\n", + "\n", + "EasternTeam = {\n", + " 'Eastern_1': ['Western_8', 'Western_3', 'Western_1', 'Western_2', 'Western_6', 'Western_7', 'Western_5', 'Western_4'],\n", + " 'Eastern_2': ['Western_3', 'Western_2', 'Western_1', 'Western_4', 'Western_5', 'Western_6', 'Western_7', 'Western_8'],\n", + " 'Eastern_3': ['Western_1', 'Western_6', 'Western_5', 'Western_4', 'Western_3', 'Western_2', 'Western_7', 'Western_8'],\n", + " 'Eastern_4': ['Western_7', 'Western_4', 'Western_6', 'Western_2', 'Western_8', 'Western_5', 'Western_3', 'Western_1'],\n", + " 'Eastern_5': ['Western_6', 'Western_7', 'Western_4', 'Western_3', 'Western_2', 'Western_8', 'Western_1', 'Western_5'],\n", + " 'Eastern_6': ['Western_1', 'Western_5', 'Western_8', 'Western_4', 'Western_7', 'Western_3', 'Western_2', 'Western_6'],\n", + " 'Eastern_7': ['Western_4', 'Western_2', 'Western_6', 'Western_3', 'Western_1', 'Western_5', 'Western_7', 'Western_8'],\n", + " 'Eastern_8': ['Western_1', 'Western_5', 'Western_7', 'Western_2', 'Western_3', 'Western_6', 'Western_8', 'Western_4']\n", + "}\n", + "\n", + "Western = sorted(WesternTeam.keys())\n", + "Eastern = sorted(EasternTeam.keys())\n", + "\n", + "\n", + "def check(matched):\n", + " inversematched = dict((v,k) for k,v in matched.items())#\n", + " for E,W in matched.items():\n", + " Elikes = EasternTeam[E]\n", + " Elikesbetter = Elikes[:Elikes.index(W)]\n", + " Wlikes = WesternTeam[W]\n", + " Wlikesbetter =Wlikes[:Wlikes.index(E)]\n", + " for Wes in Elikesbetter:\n", + " Western_East = inversematched[Wes] \n", + " Weslikes = WesternTeam[Wes] \n", + " if Weslikes.index(Western_East) > Weslikes.index(E):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (E, Wes,W, Western_East))\n", + " return False\n", + " for Eas in Wlikesbetter:\n", + " Eastern_Wes = matched[Eas]\n", + " Easlikes = EasternTeam[Eas]\n", + " if Easlikes.index(Eastern_Wes) > Easlikes.index(W):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (W, Eas, E, Eastern_Wes))\n", + " return False\n", + " return True\n", + "\n", + "def matchmaker():\n", + " Westernfree = Western[:]\n", + " matched = {}\n", + " WesternTeam2 = copy.deepcopy(WesternTeam)\n", + " EasternTeam2 = copy.deepcopy(EasternTeam)\n", + " while Westernfree:\n", + " Wes = Westernfree.pop(0)\n", + " Westernlist = WesternTeam2[Wes]\n", + " Eas = Westernlist.pop(0)\n", + " competitor = matched.get(Eas)\n", + " if not competitor:\n", + " # E's free\n", + " matched[Eas] = Wes\n", + " print(\" %s and %s\" % (Wes, Eas))\n", + " else:\n", + " Easternlist = EasternTeam2[Eas]\n", + " if Easternlist.index(competitor) > Easternlist.index(Wes):\n", + " matched[Eas] = Wes\n", + " print(\" %s dumped %s for %s\" % (Eas, competitor, Wes))\n", + " if WesternTeam2[competitor]:\n", + " \n", + " Westernfree.append(competitor)\n", + " else:\n", + " if Westernlist:\n", + " Westernfree.append(Wes)\n", + " return matched\n", + "\n", + "\n", + "print('\\nMatch:')\n", + "matched = matchmaker()\n", + "\n", + "print('\\nPairs:')\n", + "print(' ' + ',\\n '.join('%s is matched to %s' % couple\n", + " for couple in sorted(matched.items())))\n", + "print()\n", + "print('Match stability check PASSED'\n", + " if check(matched) else 'Match stability check FAILED')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45f51927", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_B.ipynb b/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_B.ipynb new file mode 100644 index 0000000..71e6e97 --- /dev/null +++ b/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_B.ipynb @@ -0,0 +1,13139 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "id": "077e835a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Eastern_6 dumped Western_7 for Western_4\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Western_6 and Eastern_2\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Eastern_2 dumped Western_8 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Eastern_1 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_6\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_4\n", + " Eastern_4 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_7\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_6 and Eastern_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_6\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Eastern_6 dumped Western_7 for Western_3\n", + " Western_6 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_2\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_5 and Eastern_2\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Eastern_2 dumped Western_5 for Western_2\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_2\n", + " Eastern_5 dumped Western_5 for Western_3\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_5 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_5 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_6 and Eastern_2\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Western_8 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_7 and Eastern_2\n", + " Eastern_2 dumped Western_7 for Western_8\n", + " Western_5 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_2\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Eastern_7 dumped Western_7 for Western_1\n", + " Western_4 and Eastern_1\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_2\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_8 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Eastern_7 dumped Western_7 for Western_3\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_2\n", + " Eastern_3 dumped Western_1 for Western_4\n", + " Western_7 and Eastern_4\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Western_2 and Eastern_2\n", + " Western_7 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_7\n", + " Eastern_8 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_2\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Eastern_5 dumped Western_6 for Western_5\n", + " Western_4 and Eastern_1\n", + " Eastern_2 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_7\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Eastern_4 dumped Western_4 for Western_1\n", + " Western_2 and Eastern_5\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Eastern_6 dumped Western_6 for Western_1\n", + " Western_8 and Eastern_3\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_5\n", + " Eastern_3 dumped Western_6 for Western_3\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_6\n", + " Eastern_4 dumped Western_3 for Western_2\n", + " Western_7 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_6 dumped Western_8 for Western_1\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Eastern_2 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_4\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_1\n", + " Eastern_4 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_8 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_4\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Eastern_4 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_3\n", + " Eastern_1 dumped Western_8 for Western_1\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_1\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_7 dumped Western_4 for Western_2\n", + " Eastern_1 dumped Western_6 for Western_4\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Eastern_5 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_5 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_2\n", + " Eastern_5 dumped Western_8 for Western_7\n", + " Western_4 and Eastern_4\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_6\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_1 and Eastern_8\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Western_7 and Eastern_7\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_6\n", + " Western_1 and Eastern_1\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Western_8 and Eastern_2\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_3\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Western_6 and Eastern_4\n", + " Eastern_4 dumped Western_6 for Western_4\n", + " Western_8 and Eastern_1\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_8\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_1\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Western_2 and Eastern_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_2\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Eastern_7 dumped Western_4 for Western_1\n", + " Eastern_4 dumped Western_5 for Western_4\n", + " Eastern_6 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_2\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_5\n", + " Western_1 and Eastern_2\n", + " Eastern_5 dumped Western_8 for Western_7\n", + " Eastern_4 dumped Western_3 for Western_8\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_8\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Eastern_2 dumped Western_8 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_6\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Eastern_3 dumped Western_7 for Western_4\n", + " Western_2 and Eastern_8\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_2 dumped Western_5 for Western_2\n", + " Eastern_6 dumped Western_7 for Western_5\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_5 dumped Western_6 for Western_2\n", + " Western_1 and Eastern_6\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_5\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_3\n", + " Eastern_3 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Western_4 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_2\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Eastern_2 dumped Western_8 for Western_6\n", + " Western_4 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Eastern_5 dumped Western_8 for Western_2\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_2\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Eastern_3 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Eastern_7 dumped Western_7 for Western_3\n", + " Western_6 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Eastern_8 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_1\n", + " Eastern_6 dumped Western_6 for Western_5\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Eastern_4 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Eastern_4 dumped Western_7 for Western_3\n", + " Western_1 and Eastern_5\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_3\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_2\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_3\n", + " Western_7 and Eastern_2\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_4\n", + " Eastern_6 dumped Western_8 for Western_1\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_3\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Eastern_5 dumped Western_4 for Western_2\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Western_1 and Eastern_8\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_1 and Eastern_4\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Eastern_8 dumped Western_8 for Western_2\n", + " Western_4 and Eastern_3\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_4\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Western_1 and Eastern_6\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Eastern_4 dumped Western_5 for Western_3\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Eastern_4 dumped Western_3 for Western_1\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Eastern_2 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Eastern_8 dumped Western_4 for Western_2\n", + " Eastern_1 dumped Western_5 for Western_4\n", + " Eastern_3 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Eastern_1 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_1 and Eastern_5\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Eastern_3 dumped Western_6 for Western_2\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_7\n", + " Eastern_2 dumped Western_6 for Western_1\n", + " Western_3 and Eastern_6\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Eastern_4 dumped Western_6 for Western_3\n", + " Western_8 and Eastern_3\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Western_7 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_4 dumped Western_7 for Western_8\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_8\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_6\n", + " Eastern_7 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_4\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_4 dumped Western_6 for Western_3\n", + " Western_4 and Eastern_5\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_4 for Western_3\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_1 dumped Western_8 for Western_2\n", + " Western_8 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_6\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_5\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_3\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_1 dumped Western_6 for Western_5\n", + " Western_3 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Eastern_3 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_2\n", + " Eastern_7 dumped Western_7 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_7 and Eastern_1\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_1 and Eastern_3\n", + " Eastern_7 dumped Western_7 for Western_3\n", + " Western_5 and Eastern_2\n", + " Western_8 and Eastern_5\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_1\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_4\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Western_4 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_6\n", + " Eastern_7 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_4\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_3\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Eastern_2 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_8\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Eastern_4 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Eastern_3 dumped Western_7 for Western_4\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_8\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_7 for Western_8\n", + " Western_1 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Eastern_5 dumped Western_5 for Western_2\n", + " Eastern_1 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_3 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_4\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Western_5 and Eastern_7\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_7 and Eastern_2\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Western_4 and Eastern_4\n", + " Eastern_6 dumped Western_8 for Western_6\n", + " Western_1 and Eastern_3\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_8\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Eastern_8 dumped Western_8 for Western_2\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Western_2 and Eastern_2\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Eastern_3 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_6\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_5\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_4\n", + " Eastern_5 dumped Western_2 for Western_8\n", + " Western_1 and Eastern_3\n", + " Western_7 and Eastern_1\n", + " Eastern_8 dumped Western_5 for Western_2\n", + " Eastern_5 dumped Western_8 for Western_5\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_4 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_8 and Eastern_4\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Eastern_3 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_8\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Eastern_4 dumped Western_7 for Western_5\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_8 for Western_3\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Western_2 and Eastern_1\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_8\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_7\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_6\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_7\n", + " Western_1 and Eastern_5\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Eastern_7 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_3\n", + " Eastern_3 dumped Western_8 for Western_1\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_5\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Western_7 and Eastern_1\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_7\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Eastern_5 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_8 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_8 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_7 and Eastern_5\n", + " Eastern_1 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_6\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_4\n", + " Western_6 and Eastern_4\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_8 for Western_7\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_1\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_3\n", + " Eastern_5 dumped Western_6 for Western_2\n", + " Eastern_3 dumped Western_8 for Western_4\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_5 for Western_4\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_8 dumped Western_3 for Western_1\n", + " Western_5 and Eastern_3\n", + " Eastern_4 dumped Western_8 for Western_6\n", + " Eastern_3 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_6 for Western_5\n", + " Western_2 and Eastern_6\n", + " Western_8 and Eastern_4\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_1\n", + " Eastern_7 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_6\n", + " Eastern_3 dumped Western_7 for Western_5\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Western_6 and Eastern_5\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_7\n", + " Western_1 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_8 and Eastern_7\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_4\n", + " Eastern_8 dumped Western_8 for Western_7\n", + " Western_2 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_6\n", + " Western_8 and Eastern_8\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_2 dumped Western_5 for Western_4\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_1 and Eastern_6\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_6\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_3\n", + " Western_4 and Eastern_8\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Western_8 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_6\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_1 dumped Western_8 for Western_1\n", + " Western_7 and Eastern_2\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_5\n", + " Eastern_2 dumped Western_7 for Western_8\n", + " Eastern_3 dumped Western_5 for Western_7\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_7\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_2\n", + " Western_1 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_8 and Eastern_1\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_7 and Eastern_4\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_5 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Eastern_6 dumped Western_7 for Western_4\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_3\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Western_7 and Eastern_2\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Western_6 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Eastern_3 dumped Western_8 for Western_1\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Western_3 and Eastern_1\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_7\n", + " Western_8 and Eastern_1\n", + " Western_1 and Eastern_8\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_7\n", + " Western_7 and Eastern_8\n", + " Eastern_6 dumped Western_4 for Western_2\n", + " Western_5 and Eastern_5\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_8\n", + " Eastern_7 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_7\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_3 for Western_8\n", + " Eastern_3 dumped Western_7 for Western_5\n", + " Western_3 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Eastern_4 dumped Western_8 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_1\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Eastern_1 dumped Western_6 for Western_5\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_7\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Eastern_6 dumped Western_6 for Western_5\n", + " Eastern_1 dumped Western_7 for Western_4\n", + " Western_6 and Eastern_4\n", + " Eastern_8 dumped Western_8 for Western_7\n", + " Eastern_4 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Eastern_8 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_7\n", + " Eastern_2 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Eastern_6 dumped Western_7 for Western_3\n", + " Western_1 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_1\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_2\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_7 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_4\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Eastern_1 dumped Western_8 for Western_2\n", + " Western_3 and Eastern_3\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_1 and Eastern_3\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_3\n", + " Western_2 and Eastern_5\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_1 and Eastern_2\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_3 and Eastern_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_2\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Eastern_1 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_2\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_2\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Eastern_4 dumped Western_7 for Western_6\n", + " Eastern_8 dumped Western_8 for Western_7\n", + " Eastern_3 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_6\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Eastern_6 dumped Western_7 for Western_4\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_1\n", + " Eastern_1 dumped Western_1 for Western_2\n", + " Eastern_5 dumped Western_7 for Western_1\n", + " Eastern_7 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_3\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_3\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Western_8 and Eastern_5\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_1 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Eastern_6 dumped Western_6 for Western_2\n", + " Eastern_3 dumped Western_7 for Western_6\n", + " Eastern_5 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Eastern_1 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_4\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Eastern_2 dumped Western_4 for Western_2\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_7\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Eastern_1 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Western_1 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_5\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Eastern_6 dumped Western_8 for Western_7\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Western_1 and Eastern_2\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_3\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_4\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Western_2 and Eastern_5\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Eastern_7 dumped Western_8 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_2 dumped Western_7 for Western_8\n", + " Western_1 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Eastern_5 dumped Western_6 for Western_2\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_2\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Western_4 and Eastern_6\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_4\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_5\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_6\n", + " Eastern_7 dumped Western_6 for Western_3\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_8 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Western_7 and Eastern_8\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Eastern_7 dumped Western_4 for Western_8\n", + " Eastern_2 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_4\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Eastern_3 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_6\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_2 and Eastern_6\n", + " Western_1 and Eastern_2\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_3\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_1 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_1\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Eastern_5 dumped Western_6 for Western_5\n", + " Western_3 and Eastern_3\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_4\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_2\n", + " Eastern_5 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_8 and Eastern_5\n", + " Western_6 and Eastern_7\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_3\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Eastern_7 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_1 and Eastern_6\n", + " Eastern_8 dumped Western_8 for Western_6\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Eastern_4 dumped Western_3 for Western_8\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_3\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Western_1 and Eastern_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Western_7 and Eastern_1\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Western_1 and Eastern_7\n", + " Eastern_1 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Eastern_4 dumped Western_5 for Western_3\n", + " Western_7 and Eastern_8\n", + " Eastern_1 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Western_7 and Eastern_3\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_5 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_7 for Western_2\n", + " Western_1 and Eastern_1\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_4\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_5\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Eastern_8 dumped Western_7 for Western_5\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Eastern_8 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_3 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Eastern_1 dumped Western_8 for Western_1\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_2 and Eastern_7\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_4\n", + " Eastern_7 dumped Western_4 for Western_2\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_5 dumped Western_7 for Western_3\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Eastern_4 dumped Western_8 for Western_1\n", + " Western_3 and Eastern_5\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_6\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Eastern_1 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_3\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Eastern_4 dumped Western_4 for Western_1\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Eastern_7 dumped Western_6 for Western_2\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Western_4 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_1 dumped Western_6 for Western_5\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Eastern_8 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_3\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_4\n", + " Eastern_7 dumped Western_8 for Western_2\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Eastern_4 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_6\n", + " Western_1 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_1 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Eastern_2 dumped Western_6 for Western_3\n", + " Eastern_7 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_4\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Eastern_1 dumped Western_2 for Western_1\n", + " Eastern_3 dumped Western_6 for Western_2\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Eastern_8 dumped Western_7 for Western_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_3 and Eastern_1\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Eastern_3 dumped Western_5 for Western_2\n", + " Eastern_6 dumped Western_6 for Western_5\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Eastern_4 dumped Western_4 for Western_3\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_1\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_7 dumped Western_5 for Western_3\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Western_5 and Eastern_5\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_1\n", + " Eastern_6 dumped Western_7 for Western_5\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_6 and Eastern_2\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_8\n", + " Eastern_5 dumped Western_7 for Western_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_1\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_8\n", + " Eastern_6 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_8\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_3\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_3\n", + " Eastern_3 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_1\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_7\n", + " Eastern_4 dumped Western_6 for Western_5\n", + " Western_3 and Eastern_1\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_1 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Eastern_7 dumped Western_8 for Western_3\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Eastern_4 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_3\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Eastern_4 dumped Western_8 for Western_3\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_2\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Western_4 and Eastern_4\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_5 for Western_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_1\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Western_2 and Eastern_8\n", + " Eastern_7 dumped Western_8 for Western_3\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_5\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_4\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_2\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_1\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_6\n", + " Eastern_1 dumped Western_8 for Western_3\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Eastern_8 dumped Western_6 for Western_1\n", + " Eastern_5 dumped Western_7 for Western_3\n", + " Western_6 and Eastern_4\n", + " Eastern_6 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Eastern_2 dumped Western_5 for Western_3\n", + " Western_7 and Eastern_4\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_1\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_3\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Western_3 and Eastern_5\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_4\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Western_6 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_2\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Eastern_1 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_4 for Western_7\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_2\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_7\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Eastern_1 dumped Western_3 for Western_1\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_6 and Eastern_8\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_1\n", + " Eastern_8 dumped Western_7 for Western_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_8 for Western_1\n", + " Eastern_5 dumped Western_2 for Western_8\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Eastern_8 dumped Western_7 for Western_3\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_8\n", + " Western_8 and Eastern_4\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_2\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Eastern_6 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_8\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_1\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Eastern_3 dumped Western_6 for Western_3\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_4\n", + " Eastern_3 dumped Western_6 for Western_1\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_8 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_6\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Western_4 and Eastern_4\n", + " Western_7 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Eastern_4 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Western_1 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Western_8 and Eastern_1\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_5\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_7\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Eastern_5 dumped Western_8 for Western_6\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_5 and Eastern_8\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Western_4 and Eastern_4\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Western_3 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Western_6 and Eastern_5\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Western_3 and Eastern_4\n", + " Eastern_8 dumped Western_7 for Western_1\n", + " Western_4 and Eastern_2\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Western_2 and Eastern_7\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Western_5 and Eastern_1\n", + " Eastern_6 dumped Western_1 for Western_7\n", + " Eastern_6 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_2\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_1\n", + " Eastern_3 dumped Western_6 for Western_3\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Eastern_2 dumped Western_8 for Western_7\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Eastern_2 dumped Western_7 for Western_5\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Eastern_1 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_8 and Eastern_3\n", + " Western_1 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Eastern_8 dumped Western_3 for Western_1\n", + " Eastern_4 dumped Western_7 for Western_3\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_1\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Western_4 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_5 dumped Western_5 for Western_4\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_8\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_7 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_2\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_7 for Western_4\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Eastern_4 dumped Western_8 for Western_1\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Eastern_6 dumped Western_5 for Western_3\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_1 and Eastern_7\n", + " Eastern_3 dumped Western_4 for Western_6\n", + " Western_5 and Eastern_5\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_2\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_5 for Western_2\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Western_5 and Eastern_1\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_4\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_3 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_4 dumped Western_5 for Western_4\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_1\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_6\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_3\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_3 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_5\n", + " Eastern_6 dumped Western_8 for Western_2\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Western_5 and Eastern_1\n", + " Western_8 and Eastern_8\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_5\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_5\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Eastern_8 dumped Western_7 for Western_3\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_6\n", + " Eastern_3 dumped Western_6 for Western_3\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_2 and Eastern_2\n", + " Eastern_6 dumped Western_4 for Western_1\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_4\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_1 for Western_4\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_1\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Western_7 and Eastern_2\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Western_1 and Eastern_1\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Western_2 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Eastern_7 dumped Western_8 for Western_1\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_8\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Eastern_4 dumped Western_3 for Western_2\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_3 and Eastern_5\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Western_5 and Eastern_1\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Western_7 and Eastern_3\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_3\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Western_4 and Eastern_1\n", + " Eastern_4 dumped Western_5 for Western_1\n", + " Western_8 and Eastern_6\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_4 dumped Western_5 for Western_4\n", + " Eastern_5 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_2\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Western_7 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Eastern_4 dumped Western_7 for Western_8\n", + " Western_3 and Eastern_6\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_7\n", + " Western_5 and Eastern_3\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_1\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_3\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_1 dumped Western_5 for Western_2\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_5 and Eastern_4\n", + " Western_1 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_3\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_2\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_8\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_1 and Eastern_7\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Western_1 and Eastern_1\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Eastern_2 dumped Western_7 for Western_3\n", + " Western_5 and Eastern_4\n", + " Eastern_5 dumped Western_8 for Western_7\n", + " Eastern_7 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_8 and Eastern_5\n", + " Eastern_1 dumped Western_7 for Western_4\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_4 dumped Western_5 for Western_1\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Eastern_4 dumped Western_7 for Western_3\n", + " Eastern_5 dumped Western_5 for Western_1\n", + " Eastern_6 dumped Western_6 for Western_5\n", + " Western_7 and Eastern_8\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_3\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_8 and Eastern_1\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_1\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_6\n", + " Eastern_7 dumped Western_8 for Western_2\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Eastern_3 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_8\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Eastern_6 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Eastern_5 dumped Western_8 for Western_1\n", + " Western_5 and Eastern_7\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_8\n", + " Eastern_5 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_6\n", + " Western_7 and Eastern_8\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Western_1 and Eastern_5\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_5\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Eastern_8 dumped Western_6 for Western_1\n", + " Eastern_1 dumped Western_7 for Western_6\n", + " Eastern_3 dumped Western_8 for Western_7\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Western_5 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Western_5 and Eastern_3\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Eastern_3 dumped Western_5 for Western_3\n", + " Western_8 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Western_5 and Eastern_6\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_1\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_2\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_3\n", + " Western_2 and Eastern_6\n", + " Eastern_2 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_3\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_6\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_3 and Eastern_1\n", + " Western_1 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_3\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_1\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_7 and Eastern_6\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_8\n", + " Eastern_8 dumped Western_6 for Western_2\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Eastern_3 dumped Western_8 for Western_6\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_6\n", + " Eastern_1 dumped Western_5 for Western_2\n", + " Eastern_5 dumped Western_3 for Western_1\n", + " Eastern_4 dumped Western_4 for Western_3\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Eastern_8 dumped Western_5 for Western_1\n", + " Eastern_6 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Western_1 and Eastern_6\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_3\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Eastern_4 dumped Western_6 for Western_4\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_1\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_3 dumped Western_8 for Western_4\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_1 dumped Western_7 for Western_2\n", + " Western_1 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_4\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_3 and Eastern_8\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Eastern_7 dumped Western_8 for Western_7\n", + " Western_4 and Eastern_8\n", + " Western_8 and Eastern_1\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Eastern_7 dumped Western_7 for Western_1\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Western_5 and Eastern_5\n", + " Eastern_4 dumped Western_4 for Western_7\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Western_6 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_7 for Western_6\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_7 and Eastern_2\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_5\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_2\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_8\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_1 and Eastern_6\n", + " Eastern_2 dumped Western_7 for Western_3\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_4\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_1\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Eastern_2 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Western_1 and Eastern_5\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_3\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_8\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Western_1 and Eastern_5\n", + " Eastern_3 dumped Western_7 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_7\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Eastern_3 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Western_8 and Eastern_3\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_3 dumped Western_8 for Western_1\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_3\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_6\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_5\n", + " Eastern_6 dumped Western_8 for Western_7\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_1 and Eastern_1\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_4\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_5 for Western_3\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_8 for Western_5\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_5 dumped Western_5 for Western_2\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_1 and Eastern_4\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_3 and Eastern_8\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_2 and Eastern_8\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_1\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_7 for Western_4\n", + " Eastern_6 dumped Western_3 for Western_5\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_3 and Eastern_8\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_8\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_2\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_8\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Western_2 and Eastern_3\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Eastern_1 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_5\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_5 and Eastern_4\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Eastern_5 dumped Western_6 for Western_5\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_1 and Eastern_5\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Eastern_7 dumped Western_6 for Western_3\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Eastern_8 dumped Western_2 for Western_1\n", + " Eastern_5 dumped Western_8 for Western_2\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_8\n", + " Eastern_6 dumped Western_4 for Western_3\n", + " Western_5 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_7 for Western_4\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_3\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_1 and Eastern_3\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_3\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_4 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_5\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_4\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_1 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Western_7 and Eastern_6\n", + " Eastern_1 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Eastern_3 dumped Western_7 for Western_3\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Eastern_5 dumped Western_6 for Western_2\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_5 and Eastern_6\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_8 and Eastern_5\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Eastern_7 dumped Western_6 for Western_3\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_8 and Eastern_3\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Eastern_7 dumped Western_4 for Western_3\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_4 and Eastern_6\n", + " Western_1 and Eastern_5\n", + " Western_8 and Eastern_2\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Eastern_6 dumped Western_5 for Western_8\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_4 and Eastern_8\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_1\n", + " Western_8 and Eastern_8\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Eastern_2 dumped Western_8 for Western_4\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_1 dumped Western_7 for Western_3\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_8\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Western_4 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_8 dumped Western_8 for Western_3\n", + " Western_5 and Eastern_4\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_4\n", + " Western_5 and Eastern_6\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_5\n", + " Eastern_4 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_3 for Western_1\n", + " Eastern_4 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_7\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_4\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Western_7 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Eastern_1 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_8\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Eastern_8 dumped Western_5 for Western_2\n", + " Eastern_4 dumped Western_3 for Western_8\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Eastern_4 dumped Western_4 for Western_2\n", + " Eastern_2 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Western_4 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Western_1 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Eastern_5 dumped Western_5 for Western_2\n", + " Eastern_6 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_2 and Eastern_5\n", + " Eastern_3 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_7 and Eastern_8\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_4 and Eastern_4\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Eastern_1 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_8 for Western_2\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_7 dumped Western_5 for Western_3\n", + " Western_1 and Eastern_5\n", + " Eastern_1 dumped Western_7 for Western_4\n", + " Western_5 and Eastern_6\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_7\n", + " Eastern_3 dumped Western_5 for Western_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Eastern_4 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_8 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Eastern_4 dumped Western_7 for Western_2\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Western_1 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Western_8 and Eastern_4\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_7 and Eastern_3\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_5\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Eastern_5 dumped Western_5 for Western_8\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Western_5 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Eastern_6 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_8\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Eastern_7 dumped Western_6 for Western_1\n", + " Western_2 and Eastern_3\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Western_7 and Eastern_2\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_3\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Western_6 and Eastern_5\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Eastern_1 dumped Western_4 for Western_1\n", + " Western_2 and Eastern_6\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_4\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Western_1 and Eastern_4\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_1\n", + " Eastern_8 dumped Western_7 for Western_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Eastern_3 dumped Western_8 for Western_5\n", + " Eastern_1 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_4\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_4\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_1 dumped Western_8 for Western_3\n", + " Western_7 and Eastern_6\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_8\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_6\n", + " Western_1 and Eastern_1\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Eastern_5 dumped Western_6 for Western_2\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_5 for Western_1\n", + " Eastern_1 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_8\n", + " Eastern_6 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Eastern_6 dumped Western_7 for Western_6\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Eastern_4 dumped Western_3 for Western_1\n", + " Eastern_5 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_5 dumped Western_8 for Western_5\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_2\n", + " Eastern_5 dumped Western_5 for Western_1\n", + " Eastern_1 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_6\n", + " Eastern_2 dumped Western_8 for Western_5\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_4 for Western_2\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_8\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Eastern_4 dumped Western_7 for Western_2\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Eastern_2 dumped Western_8 for Western_5\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Western_7 and Eastern_2\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_8 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_7\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_2\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_8\n", + " Eastern_8 dumped Western_8 for Western_1\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_2\n", + " Eastern_5 dumped Western_6 for Western_5\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_3\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_1\n", + " Western_2 and Eastern_6\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_8\n", + " Western_1 and Eastern_7\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Eastern_2 dumped Western_5 for Western_3\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Eastern_8 dumped Western_4 for Western_2\n", + " Eastern_5 dumped Western_5 for Western_4\n", + " Eastern_4 dumped Western_7 for Western_5\n", + " Eastern_6 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_7\n", + " Eastern_5 dumped Western_6 for Western_5\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_5\n", + " Eastern_6 dumped Western_7 for Western_5\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_1\n", + " Western_7 and Eastern_2\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Eastern_2 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_4\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_2 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_2\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Eastern_8 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_1\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_5 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_2 and Eastern_1\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_2\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_6 dumped Western_5 for Western_3\n", + " Eastern_4 dumped Western_6 for Western_5\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_3 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_8\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Eastern_2 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_7\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_4\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_4 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_8 and Eastern_4\n", + " Eastern_4 dumped Western_8 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_7\n", + " Western_6 and Eastern_4\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Eastern_5 dumped Western_5 for Western_3\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Eastern_2 dumped Western_6 for Western_1\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Eastern_5 dumped Western_8 for Western_7\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_3\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Western_7 and Eastern_8\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_5 and Eastern_1\n", + " Western_1 and Eastern_4\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Western_2 and Eastern_1\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Western_3 and Eastern_4\n", + " Eastern_8 dumped Western_5 for Western_2\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_3\n", + " Eastern_1 dumped Western_5 for Western_4\n", + " Western_8 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_6 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_1\n", + " Eastern_6 dumped Western_5 for Western_8\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Eastern_3 dumped Western_6 for Western_2\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_2\n", + " Western_8 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_4\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_6\n", + " Eastern_1 dumped Western_7 for Western_1\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Eastern_6 dumped Western_5 for Western_8\n", + " Eastern_4 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Western_2 and Eastern_6\n", + " Western_5 and Eastern_1\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_8 and Eastern_3\n", + " Eastern_4 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_8 and Eastern_5\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_7 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_2 for Western_8\n", + " Western_7 and Eastern_7\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Eastern_5 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_1\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_3 for Western_1\n", + " Eastern_7 dumped Western_6 for Western_3\n", + " Eastern_6 dumped Western_7 for Western_6\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_2\n", + " Western_8 and Eastern_3\n", + " Eastern_3 dumped Western_8 for Western_4\n", + " Western_6 and Eastern_2\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Western_8 and Eastern_4\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Eastern_4 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Western_3 and Eastern_4\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Western_5 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Eastern_4 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_5 for Western_4\n", + " Western_8 and Eastern_7\n", + " Western_5 and Eastern_3\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_7 for Western_4\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Western_6 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_6 dumped Western_5 for Western_2\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_7 and Eastern_7\n", + " Eastern_3 dumped Western_8 for Western_5\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_7 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Eastern_5 dumped Western_8 for Western_5\n", + " Eastern_5 dumped Western_5 for Western_2\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Eastern_2 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_8 dumped Western_5 for Western_1\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_8 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_4\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_8\n", + " Eastern_6 dumped Western_4 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Eastern_6 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_7\n", + " Western_1 and Eastern_8\n", + " Eastern_3 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_2\n", + " Western_8 and Eastern_8\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_7\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_8 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_1\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_2 dumped Western_4 for Western_3\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_1 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_8 for Western_3\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Eastern_6 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_8\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_7 and Eastern_1\n", + " Eastern_2 dumped Western_4 for Western_2\n", + " Eastern_8 dumped Western_8 for Western_4\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Western_3 and Eastern_5\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_2 for Western_8\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Western_2 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_3\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_2\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_8\n", + " Eastern_2 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_6 for Western_2\n", + " Western_5 and Eastern_4\n", + " Eastern_8 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_1\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_4\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Western_2 and Eastern_8\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_1 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_3\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Eastern_1 dumped Western_8 for Western_3\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_4 and Eastern_8\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Eastern_7 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_2\n", + " Eastern_6 dumped Western_5 for Western_4\n", + " Eastern_2 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Eastern_2 dumped Western_5 for Western_1\n", + " Western_7 and Eastern_1\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_4 for Western_7\n", + " Eastern_4 dumped Western_7 for Western_6\n", + " Western_4 and Eastern_1\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_7\n", + " Eastern_1 dumped Western_4 for Western_1\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_4\n", + " Eastern_4 dumped Western_6 for Western_4\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_5 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Eastern_6 dumped Western_8 for Western_2\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_5\n", + " Eastern_7 dumped Western_1 for Western_8\n", + " Western_5 and Eastern_3\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_7\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_4\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_8\n", + " Western_7 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Western_3 and Eastern_2\n", + " Western_8 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Eastern_4 dumped Western_4 for Western_1\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Western_6 and Eastern_3\n", + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_7\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_8\n", + " Eastern_4 dumped Western_3 for Western_1\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Eastern_6 dumped Western_8 for Western_2\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Western_8 and Eastern_5\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_6\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_8\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_3\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Eastern_1 dumped Western_3 for Western_1\n", + " Eastern_7 dumped Western_6 for Western_2\n", + " Western_7 and Eastern_5\n", + " Eastern_4 dumped Western_8 for Western_3\n", + " Western_6 and Eastern_6\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_8\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Western_7 and Eastern_1\n", + " Western_1 and Eastern_5\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_4 for Western_8\n", + " Western_3 and Eastern_5\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_4\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_6 and Eastern_1\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_8 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_6\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Western_3 and Eastern_5\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Eastern_4 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Western_4 and Eastern_1\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_6\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_4\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_4 and Eastern_2\n", + " Eastern_4 dumped Western_7 for Western_6\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_1\n", + " Western_4 and Eastern_1\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_4\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Eastern_7 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_5 and Eastern_1\n", + " Western_8 and Eastern_4\n", + " Eastern_4 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_3 and Eastern_6\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_5\n", + " Eastern_6 dumped Western_6 for Western_2\n", + " Western_3 and Eastern_4\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_4 and Eastern_5\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_8 dumped Western_5 for Western_2\n", + " Western_6 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Eastern_3 dumped Western_6 for Western_1\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_2\n", + " Eastern_7 dumped Western_2 for Western_8\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_7 for Western_2\n", + " Western_1 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_4\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_4 and Eastern_2\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_4\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Eastern_3 dumped Western_7 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_8\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_2\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_5\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_4\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_3 dumped Western_5 for Western_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Western_1 and Eastern_8\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Eastern_5 dumped Western_5 for Western_2\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Eastern_6 dumped Western_8 for Western_5\n", + " Western_3 and Eastern_7\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Eastern_4 dumped Western_7 for Western_6\n", + " Western_5 and Eastern_3\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Eastern_3 dumped Western_5 for Western_3\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Eastern_8 dumped Western_6 for Western_2\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_4\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Eastern_1 dumped Western_8 for Western_3\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_6 and Eastern_7\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_3\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Western_7 and Eastern_1\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_4\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_6 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Eastern_2 dumped Western_5 for Western_2\n", + " Eastern_6 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_6 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_2\n", + " Western_8 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_8\n", + " Eastern_1 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_8\n", + " Western_1 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Eastern_4 dumped Western_7 for Western_2\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_8 for Western_3\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_7 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_1\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Western_8 and Eastern_7\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Eastern_1 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Eastern_5 dumped Western_5 for Western_1\n", + " Western_4 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Eastern_6 dumped Western_6 for Western_5\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_2\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Eastern_5 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_5 and Eastern_3\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Western_4 and Eastern_2\n", + " Eastern_7 dumped Western_1 for Western_8\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Eastern_3 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_3\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_4\n", + " Eastern_2 dumped Western_7 for Western_3\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Eastern_3 dumped Western_4 for Western_6\n", + " Western_1 and Eastern_4\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Western_6 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_5 and Eastern_1\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_2\n", + " Western_7 and Eastern_5\n", + " Eastern_7 dumped Western_5 for Western_3\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_3\n", + " Western_1 and Eastern_2\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Western_5 and Eastern_4\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_6 and Eastern_3\n", + " Western_5 and Eastern_6\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_7\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_2\n", + " Eastern_2 dumped Western_8 for Western_1\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_4\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_4\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_4 dumped Western_6 for Western_8\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_3 dumped Western_3 for Western_1\n", + " Western_7 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_8 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_6\n", + " Eastern_2 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Western_1 and Eastern_3\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Western_7 and Eastern_8\n", + " Western_6 and Eastern_4\n", + " Eastern_4 dumped Western_6 for Western_5\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_1\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_5\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Eastern_8 dumped Western_7 for Western_4\n", + " Eastern_7 dumped Western_8 for Western_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_2\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_8\n", + " Eastern_8 dumped Western_8 for Western_3\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_2 dumped Western_7 for Western_2\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Eastern_4 dumped Western_8 for Western_1\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_3\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Eastern_6 dumped Western_8 for Western_1\n", + " Eastern_4 dumped Western_3 for Western_8\n", + " Eastern_7 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_4\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_8\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Eastern_8 dumped Western_4 for Western_2\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Eastern_4 dumped Western_6 for Western_8\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Eastern_4 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_4\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Eastern_6 dumped Western_8 for Western_3\n", + " Eastern_5 dumped Western_4 for Western_2\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Eastern_4 dumped Western_7 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Eastern_1 dumped Western_7 for Western_1\n", + " Western_2 and Eastern_2\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_3\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Eastern_5 dumped Western_7 for Western_3\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_6\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Eastern_6 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Eastern_4 dumped Western_4 for Western_7\n", + " Eastern_4 dumped Western_7 for Western_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_5\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Eastern_2 dumped Western_2 for Western_5\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Eastern_5 dumped Western_8 for Western_2\n", + " Western_6 and Eastern_4\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_3 for Western_1\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_1 and Eastern_7\n", + " Western_7 and Eastern_6\n", + " Eastern_7 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_3 for Western_1\n", + " Eastern_4 dumped Western_6 for Western_3\n", + " Eastern_3 dumped Western_4 for Western_6\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Western_3 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Eastern_8 dumped Western_2 for Western_1\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Eastern_2 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_1\n", + " Western_7 and Eastern_8\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_8 for Western_5\n", + " Western_1 and Eastern_1\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_6\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_3\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_4\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Western_6 and Eastern_5\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Eastern_3 dumped Western_1 for Western_4\n", + " Eastern_6 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_4\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Eastern_3 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Eastern_8 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_1\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Eastern_8 dumped Western_6 for Western_5\n", + " Eastern_4 dumped Western_8 for Western_3\n", + " Western_1 and Eastern_6\n", + " Western_8 and Eastern_5\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_6 dumped Western_2 for Western_1\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_4\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_3 and Eastern_5\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_1 and Eastern_1\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Eastern_3 dumped Western_5 for Western_2\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_8\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_1 and Eastern_8\n", + " Western_7 and Eastern_3\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Western_2 and Eastern_6\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_4\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Western_7 and Eastern_8\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Eastern_8 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_7\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Eastern_7 dumped Western_6 for Western_2\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_6\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Eastern_2 dumped Western_6 for Western_3\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_4\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Eastern_4 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_1\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_6\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_3\n", + " Eastern_3 dumped Western_7 for Western_5\n", + " Eastern_6 dumped Western_8 for Western_7\n", + " Eastern_3 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_7 and Eastern_1\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_3\n", + " Eastern_7 dumped Western_4 for Western_3\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Eastern_2 dumped Western_8 for Western_2\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_8\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Eastern_4 dumped Western_8 for Western_3\n", + " Western_8 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Eastern_8 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_2\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_2 dumped Western_5 for Western_2\n", + " Western_6 and Eastern_8\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Eastern_2 dumped Western_2 for Western_1\n", + " Eastern_8 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_2\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_2\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_6\n", + " Eastern_6 dumped Western_8 for Western_1\n", + " Western_3 and Eastern_3\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_6 dumped Western_1 for Western_4\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Eastern_6 dumped Western_5 for Western_8\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Eastern_7 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_8\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_4\n", + " Eastern_8 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_7 and Eastern_6\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_6 dumped Western_7 for Western_6\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Eastern_5 dumped Western_6 for Western_1\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_6 dumped Western_2 for Western_1\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_5\n", + " Western_1 and Eastern_6\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_7\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_6\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Western_8 and Eastern_2\n", + " Eastern_2 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_6\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_7 and Eastern_2\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Eastern_5 dumped Western_6 for Western_1\n", + " Eastern_8 dumped Western_5 for Western_2\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_5\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Eastern_2 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Eastern_6 dumped Western_8 for Western_1\n", + " Eastern_4 dumped Western_7 for Western_8\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_7 and Eastern_8\n", + " Eastern_4 dumped Western_8 for Western_2\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_2\n", + " Eastern_8 dumped Western_6 for Western_1\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_8\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Eastern_4 dumped Western_6 for Western_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Eastern_1 dumped Western_6 for Western_3\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_8\n", + " Western_1 and Eastern_3\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_6\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_5\n", + " Eastern_6 dumped Western_7 for Western_4\n", + " Eastern_3 dumped Western_5 for Western_2\n", + " Western_7 and Eastern_2\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_3\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Western_3 and Eastern_1\n", + " Western_7 and Eastern_2\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_4\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_1\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_8\n", + " Eastern_7 dumped Western_4 for Western_8\n", + " Eastern_3 dumped Western_3 for Western_2\n", + " Western_4 and Eastern_4\n", + " Eastern_2 dumped Western_5 for Western_3\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Eastern_6 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_3 and Eastern_1\n", + " Western_7 and Eastern_3\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Western_5 and Eastern_6\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Western_2 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Western_1 and Eastern_8\n", + " Western_8 and Eastern_5\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Eastern_1 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Eastern_6 dumped Western_7 for Western_6\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Eastern_2 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_8\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Eastern_4 dumped Western_4 for Western_2\n", + " Western_1 and Eastern_3\n", + " Western_8 and Eastern_5\n", + " Eastern_3 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_5\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Eastern_6 dumped Western_7 for Western_5\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_5\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_7 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_2\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_5\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Eastern_5 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_7\n", + " Eastern_1 dumped Western_2 for Western_1\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_4 for Western_3\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_4\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_6 and Eastern_5\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_1 and Eastern_6\n", + " Western_8 and Eastern_5\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_2 and Eastern_4\n", + " Western_1 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_5 dumped Western_5 for Western_3\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_2 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_4\n", + " Eastern_8 dumped Western_7 for Western_6\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Eastern_8 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_2 for Western_4\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Western_6 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Eastern_7 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Eastern_4 dumped Western_6 for Western_8\n", + " Western_1 and Eastern_1\n", + " Western_6 and Eastern_2\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_8 and Eastern_1\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_1\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_4 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_6\n", + " Western_8 and Eastern_4\n", + " Eastern_3 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Western_7 and Eastern_6\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_6\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Eastern_1 dumped Western_5 for Western_3\n", + " Eastern_6 dumped Western_2 for Western_1\n", + " Western_8 and Eastern_5\n", + " Eastern_8 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_4\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Eastern_1 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_1 for Western_7\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_4 and Eastern_1\n", + " Western_1 and Eastern_2\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_1\n", + " Western_8 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Eastern_8 dumped Western_6 for Western_2\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Western_1 and Eastern_1\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Eastern_2 dumped Western_8 for Western_1\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Western_1 and Eastern_3\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_5 and Eastern_6\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Western_7 and Eastern_8\n", + " Eastern_7 dumped Western_2 for Western_8\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_6 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_2\n", + " Eastern_5 dumped Western_8 for Western_1\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_5\n", + " Eastern_7 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_2\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_1\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Eastern_8 dumped Western_4 for Western_2\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_8\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_5 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_6 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_8\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_8\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_6\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Western_2 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Western_6 and Eastern_4\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Eastern_6 dumped Western_8 for Western_2\n", + " Eastern_5 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_1\n", + " Eastern_3 dumped Western_7 for Western_6\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_2\n", + " Western_8 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Eastern_8 dumped Western_8 for Western_4\n", + " Eastern_6 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_7\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Eastern_7 dumped Western_8 for Western_6\n", + " Eastern_1 dumped Western_3 for Western_1\n", + " Eastern_4 dumped Western_7 for Western_8\n", + " Western_3 and Eastern_3\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_7\n", + " Eastern_5 dumped Western_4 for Western_2\n", + " Eastern_8 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_3 and Eastern_8\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_8\n", + " Eastern_6 dumped Western_7 for Western_6\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Western_7 and Eastern_4\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_8\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_8\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_1 and Eastern_6\n", + " Eastern_2 dumped Western_3 for Western_2\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_3\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_3\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Western_2 and Eastern_7\n", + " Eastern_6 dumped Western_4 for Western_1\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Eastern_3 dumped Western_6 for Western_1\n", + " Western_4 and Eastern_8\n", + " Eastern_4 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Eastern_7 dumped Western_6 for Western_5\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_8 for Western_4\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_7\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_1 and Eastern_4\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_8\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_1\n", + " Eastern_3 dumped Western_4 for Western_8\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Western_4 and Eastern_6\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_1\n", + " Eastern_1 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_3 and Eastern_3\n", + " Western_6 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Eastern_5 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_1\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_6\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_7\n", + " Eastern_1 dumped Western_7 for Western_1\n", + " Eastern_7 dumped Western_8 for Western_2\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_3\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Eastern_3 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_1\n", + " Western_8 and Eastern_6\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_8\n", + " Western_6 and Eastern_2\n", + " Eastern_6 dumped Western_5 for Western_4\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Eastern_8 dumped Western_8 for Western_7\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_3\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_2\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Eastern_8 dumped Western_8 for Western_6\n", + " Western_1 and Eastern_1\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_2 and Eastern_1\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Western_6 and Eastern_2\n", + " Eastern_5 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Eastern_8 dumped Western_6 for Western_3\n", + " Western_4 and Eastern_4\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_2 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Western_6 and Eastern_3\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_1 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Eastern_4 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_8\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Western_8 and Eastern_5\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_3\n", + " Eastern_8 dumped Western_7 for Western_2\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Eastern_6 dumped Western_8 for Western_1\n", + " Western_8 and Eastern_8\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Eastern_3 dumped Western_4 for Western_1\n", + " Eastern_8 dumped Western_8 for Western_4\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Eastern_1 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_3\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_5 dumped Western_7 for Western_3\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_5\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_6\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Eastern_6 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_1\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_8\n", + " Eastern_8 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Eastern_8 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_7\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Western_3 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_8 and Eastern_8\n", + " Western_1 and Eastern_3\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_3\n", + " Eastern_3 dumped Western_8 for Western_1\n", + " Eastern_2 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_6 and Eastern_3\n", + " Eastern_2 dumped Western_8 for Western_1\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_4\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_4\n", + " Western_8 and Eastern_3\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Western_3 and Eastern_2\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_6\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_4\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_1\n", + " Eastern_7 dumped Western_6 for Western_1\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_1\n", + " Western_1 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_7\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Eastern_6 dumped Western_8 for Western_1\n", + " Western_5 and Eastern_5\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Western_1 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_6\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_3 and Eastern_7\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Western_2 and Eastern_1\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_3\n", + " Eastern_5 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Western_1 and Eastern_8\n", + " Eastern_4 dumped Western_8 for Western_4\n", + " Western_6 and Eastern_5\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_6\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_7\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Eastern_3 dumped Western_8 for Western_2\n", + " Western_4 and Eastern_8\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_3\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Eastern_6 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Eastern_5 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_3\n", + " Eastern_7 dumped Western_6 for Western_5\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Eastern_8 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_6\n", + " Western_1 and Eastern_7\n", + " Eastern_2 dumped Western_7 for Western_3\n", + " Eastern_6 dumped Western_8 for Western_5\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Eastern_4 dumped Western_2 for Western_7\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_6\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_4\n", + " Eastern_6 dumped Western_6 for Western_1\n", + " Western_4 and Eastern_2\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_3 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_2\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_2 dumped Western_8 for Western_7\n", + " Eastern_5 dumped Western_6 for Western_2\n", + " Western_8 and Eastern_1\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_1 and Eastern_4\n", + " Eastern_6 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_4\n", + " Western_1 and Eastern_8\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Eastern_2 dumped Western_7 for Western_2\n", + " Eastern_8 dumped Western_8 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_8 dumped Western_7 for Western_6\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Western_6 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Western_8 and Eastern_8\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Eastern_5 dumped Western_7 for Western_3\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_6 for Western_1\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Western_6 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_2\n", + " Eastern_4 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_4\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Eastern_8 dumped Western_4 for Western_8\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_4\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_3 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Eastern_3 dumped Western_8 for Western_1\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Western_8 and Eastern_1\n", + " Western_6 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Western_3 and Eastern_6\n", + " Western_6 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Eastern_4 dumped Western_6 for Western_7\n", + " Eastern_3 dumped Western_8 for Western_6\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Eastern_7 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_8\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_8 for Western_2\n", + " Western_3 and Eastern_4\n", + " Eastern_7 dumped Western_4 for Western_1\n", + " Western_8 and Eastern_1\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Eastern_8 dumped Western_6 for Western_3\n", + " Western_1 and Eastern_7\n", + " Western_6 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Eastern_8 dumped Western_8 for Western_7\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Eastern_2 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Western_7 and Eastern_3\n", + " Eastern_7 dumped Western_6 for Western_5\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_3 dumped Western_7 for Western_1\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_1 and Eastern_8\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_3\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Eastern_2 dumped Western_8 for Western_6\n", + " Western_3 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Eastern_1 dumped Western_8 for Western_7\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_3 for Western_1\n", + " Eastern_3 dumped Western_8 for Western_3\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_8\n", + " Eastern_7 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Eastern_6 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_2\n", + " Western_1 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Eastern_2 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_1\n", + " Eastern_8 dumped Western_4 for Western_2\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_1 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Eastern_8 dumped Western_1 for Western_6\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Western_1 and Eastern_4\n", + " Western_8 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_1 and Eastern_1\n", + " Eastern_5 dumped Western_4 for Western_2\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Western_6 and Eastern_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Western_2 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_8 for Western_1\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_1 and Eastern_6\n", + " Eastern_1 dumped Western_5 for Western_3\n", + " Eastern_3 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_1\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Western_8 and Eastern_4\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_7\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Eastern_1 dumped Western_7 for Western_1\n", + " Eastern_7 dumped Western_8 for Western_7\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Eastern_2 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_2\n", + " Eastern_5 dumped Western_4 for Western_8\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_1\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_7\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_8 and Eastern_4\n", + " Eastern_4 dumped Western_8 for Western_1\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Eastern_8 dumped Western_6 for Western_3\n", + " Western_2 and Eastern_3\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_5 and Eastern_1\n", + " Western_8 and Eastern_5\n", + " Eastern_5 dumped Western_8 for Western_4\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_8 and Eastern_7\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Eastern_6 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_8\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_1 and Eastern_2\n", + " Western_4 and Eastern_4\n", + " Eastern_5 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_1\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_3 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Eastern_7 dumped Western_3 for Western_1\n", + " Western_8 and Eastern_3\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_4\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_1 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Eastern_7 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_3 and Eastern_5\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_4\n", + " Eastern_8 dumped Western_1 for Western_6\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Western_2 and Eastern_2\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_6 and Eastern_8\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Eastern_7 dumped Western_1 for Western_5\n", + " Western_2 and Eastern_1\n", + " Western_1 and Eastern_2\n", + " Western_7 and Eastern_3\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_6 and Eastern_8\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_8 dumped Western_6 for Western_2\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Eastern_6 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_2\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_4\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_7 and Eastern_5\n", + " Eastern_4 dumped Western_6 for Western_1\n", + " Eastern_1 dumped Western_4 for Western_6\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Eastern_4 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_8 for Western_1\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Eastern_8 dumped Western_6 for Western_8\n", + " Western_3 and Eastern_4\n", + " Eastern_5 dumped Western_7 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Eastern_1 dumped Western_7 for Western_6\n", + " Western_3 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_8\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_3\n", + " Western_4 and Eastern_2\n", + " Eastern_6 dumped Western_2 for Western_7\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Eastern_8 dumped Western_8 for Western_3\n", + " Eastern_7 dumped Western_2 for Western_8\n", + " Eastern_8 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_6\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Eastern_4 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_3 dumped Western_3 for Western_2\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_4\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_3 and Eastern_3\n", + " Western_6 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Eastern_1 dumped Western_5 for Western_4\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_2\n", + " Eastern_5 dumped Western_7 for Western_2\n", + " Western_1 and Eastern_3\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_8\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_8\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_7 and Eastern_1\n", + " Eastern_3 dumped Western_3 for Western_2\n", + " Eastern_1 dumped Western_7 for Western_3\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Western_7 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Western_3 and Eastern_6\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Eastern_8 dumped Western_5 for Western_1\n", + " Western_8 and Eastern_4\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Eastern_2 dumped Western_4 for Western_3\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Eastern_7 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Eastern_5 dumped Western_5 for Western_3\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Eastern_4 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_8\n", + " Eastern_4 dumped Western_5 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Eastern_2 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Eastern_6 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_5\n", + " Eastern_5 dumped Western_8 for Western_4\n", + " Western_7 and Eastern_4\n", + " Eastern_6 dumped Western_6 for Western_8\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_6\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Eastern_1 dumped Western_3 for Western_2\n", + " Eastern_1 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Eastern_6 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_8\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_3\n", + " Eastern_8 dumped Western_7 for Western_1\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_8 for Western_7\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Eastern_3 dumped Western_7 for Western_3\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_3\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_2\n", + " Western_7 and Eastern_5\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_2\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Eastern_1 dumped Western_7 for Western_5\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_1\n", + " Eastern_4 dumped Western_4 for Western_7\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_7\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Eastern_7 dumped Western_2 for Western_8\n", + " Western_3 and Eastern_3\n", + " Western_7 and Eastern_8\n", + " Eastern_6 dumped Western_4 for Western_2\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_2\n", + " Eastern_2 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_6\n", + " Eastern_8 dumped Western_4 for Western_7\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_3 and Eastern_4\n", + " Eastern_7 dumped Western_5 for Western_4\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_4 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Western_8 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Eastern_1 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Eastern_2 dumped Western_1 for Western_4\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_5\n", + " Western_5 and Eastern_4\n", + " Eastern_4 dumped Western_5 for Western_2\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Western_5 and Eastern_7\n", + " Eastern_1 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_4\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Eastern_4 dumped Western_6 for Western_3\n", + " Western_4 and Eastern_3\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Eastern_3 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Western_1 and Eastern_1\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_4\n", + " Eastern_4 dumped Western_6 for Western_8\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Western_8 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_2\n", + " Western_3 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_6\n", + " Western_1 and Eastern_5\n", + " Eastern_3 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_6\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_1 and Eastern_5\n", + " Western_5 and Eastern_8\n", + " Eastern_2 dumped Western_8 for Western_4\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_2\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_7\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Eastern_5 dumped Western_2 for Western_1\n", + " Eastern_1 dumped Western_4 for Western_2\n", + " Eastern_8 dumped Western_5 for Western_4\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_4 dumped Western_4 for Western_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Eastern_6 dumped Western_6 for Western_1\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Eastern_1 dumped Western_3 for Western_7\n", + " Western_4 and Eastern_6\n", + " Eastern_2 dumped Western_6 for Western_3\n", + " Eastern_1 dumped Western_7 for Western_6\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Eastern_3 dumped Western_8 for Western_4\n", + " Western_3 and Eastern_4\n", + " Western_2 and Eastern_5\n", + " Eastern_1 dumped Western_1 for Western_8\n", + " Eastern_2 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_8\n", + " Western_6 and Eastern_7\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_8 dumped Western_4 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_4\n", + " Eastern_4 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_8 and Eastern_1\n", + " Eastern_8 dumped Western_5 for Western_2\n", + " Western_1 and Eastern_5\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_7 and Eastern_4\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_5\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_6\n", + " Western_5 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_2\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Western_8 and Eastern_5\n", + " Western_7 and Eastern_3\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Eastern_3 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Eastern_4 dumped Western_1 for Western_4\n", + " Eastern_4 dumped Western_4 for Western_2\n", + " Western_1 and Eastern_2\n", + " Eastern_8 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_4\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Eastern_7 dumped Western_4 for Western_8\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Eastern_3 dumped Western_5 for Western_8\n", + " Eastern_1 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Eastern_3 dumped Western_8 for Western_3\n", + " Eastern_8 dumped Western_2 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_6\n", + " Eastern_8 dumped Western_7 for Western_1\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_7 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_1 and Eastern_4\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Eastern_5 dumped Western_8 for Western_1\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_8\n", + " Western_7 and Eastern_4\n", + " Eastern_5 dumped Western_2 for Western_8\n", + " Western_6 and Eastern_6\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_4\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_5 for Western_8\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Western_4 and Eastern_5\n", + " Eastern_4 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_4\n", + " Eastern_4 dumped Western_2 for Western_3\n", + " Eastern_5 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Eastern_7 dumped Western_6 for Western_2\n", + " Eastern_6 dumped Western_5 for Western_1\n", + " Western_8 and Eastern_8\n", + " Western_5 and Eastern_3\n", + " Eastern_8 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_2\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_6\n", + " Eastern_4 dumped Western_7 for Western_1\n", + " Eastern_6 dumped Western_8 for Western_7\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Eastern_7 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_6\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_3\n", + " Eastern_5 dumped Western_2 for Western_4\n", + " Eastern_3 dumped Western_3 for Western_5\n", + " Eastern_1 dumped Western_1 for Western_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_4\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Eastern_3 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_6 and Eastern_8\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Western_8 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Eastern_5 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_4\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_8\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_5 and Eastern_7\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Eastern_5 dumped Western_8 for Western_5\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Eastern_2 dumped Western_7 for Western_8\n", + " Western_3 and Eastern_7\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_7 and Eastern_5\n", + " Eastern_8 dumped Western_1 for Western_6\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Eastern_1 dumped Western_5 for Western_8\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_3\n", + " Eastern_6 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_8\n", + " Western_6 and Eastern_2\n", + " Eastern_8 dumped Western_8 for Western_1\n", + " Eastern_6 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_6\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_2\n", + " Eastern_5 dumped Western_5 for Western_4\n", + " Eastern_2 dumped Western_7 for Western_5\n", + " Eastern_8 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_4\n", + " Eastern_3 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Eastern_6 dumped Western_6 for Western_1\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_5 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_8 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_8 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Eastern_7 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_8\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_7 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_6\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_6\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_2 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_5\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_2 and Eastern_3\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_7 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_4\n", + " Western_2 and Eastern_1\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_4\n", + " Eastern_4 dumped Western_8 for Western_2\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_7 and Eastern_2\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_3\n", + " Western_6 and Eastern_3\n", + " Western_1 and Eastern_1\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_7\n", + " Western_1 and Eastern_3\n", + " Eastern_7 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_4\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_7\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_7 and Eastern_6\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Eastern_3 dumped Western_2 for Western_8\n", + " Eastern_7 dumped Western_7 for Western_4\n", + " Western_2 and Eastern_6\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Eastern_6 dumped Western_7 for Western_6\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Eastern_1 dumped Western_4 for Western_7\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_2\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Western_2 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_5\n", + " Eastern_8 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_3\n", + " Eastern_4 dumped Western_1 for Western_8\n", + " Eastern_5 dumped Western_4 for Western_1\n", + " Western_2 and Eastern_7\n", + " Eastern_3 dumped Western_7 for Western_4\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_7 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_8\n", + " Western_7 and Eastern_3\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_7\n", + " Western_5 and Eastern_6\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Eastern_6 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_8\n", + " Western_7 and Eastern_1\n", + " Western_5 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Western_8 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Eastern_1 dumped Western_8 for Western_4\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Eastern_3 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_1\n", + " Western_7 and Eastern_2\n", + " Western_1 and Eastern_4\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Western_8 and Eastern_7\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Eastern_5 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_2\n", + " Eastern_7 dumped Western_4 for Western_6\n", + " Western_4 and Eastern_3\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_4\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_1 and Eastern_4\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Eastern_8 dumped Western_7 for Western_6\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_7\n", + " Eastern_6 dumped Western_2 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_4 and Eastern_8\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_2\n", + " Eastern_1 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_4 for Western_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_5 for Western_8\n", + " Western_3 and Eastern_3\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Eastern_2 dumped Western_6 for Western_1\n", + " Eastern_7 dumped Western_2 for Western_6\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Eastern_3 dumped Western_3 for Western_1\n", + " Eastern_1 dumped Western_4 for Western_3\n", + " Eastern_8 dumped Western_7 for Western_4\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_1\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Eastern_6 dumped Western_7 for Western_1\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_3\n", + " Eastern_2 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_4\n", + " Western_8 and Eastern_3\n", + " Eastern_1 dumped Western_1 for Western_7\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_4 dumped Western_5 for Western_1\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_6 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_5\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_8 and Eastern_2\n", + " Eastern_2 dumped Western_8 for Western_3\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Eastern_5 dumped Western_1 for Western_7\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_1\n", + " Western_1 and Eastern_7\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_7 and Eastern_1\n", + " Eastern_5 dumped Western_1 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Eastern_3 dumped Western_4 for Western_1\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_2\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Eastern_1 dumped Western_8 for Western_4\n", + " Western_3 and Eastern_8\n", + " Western_8 and Eastern_7\n", + " Western_6 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Eastern_7 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_3\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Eastern_3 dumped Western_6 for Western_1\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_4\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_1\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Eastern_8 dumped Western_3 for Western_4\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Eastern_1 dumped Western_7 for Western_6\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_8 and Eastern_1\n", + " Western_5 and Eastern_8\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_1 and Eastern_6\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Eastern_3 dumped Western_2 for Western_5\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_1\n", + " Western_1 and Eastern_7\n", + " Eastern_7 dumped Western_1 for Western_2\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_6\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_6 and Eastern_4\n", + " Eastern_1 dumped Western_8 for Western_1\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Eastern_4 dumped Western_6 for Western_2\n", + " Western_6 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Eastern_4 dumped Western_3 for Western_8\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_5\n", + " Eastern_1 dumped Western_1 for Western_3\n", + " Eastern_4 dumped Western_8 for Western_1\n", + " Western_5 and Eastern_8\n", + " Eastern_5 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_6\n", + " Western_7 and Eastern_8\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Eastern_3 dumped Western_8 for Western_1\n", + " Eastern_8 dumped Western_7 for Western_3\n", + " Western_7 and Eastern_7\n", + " Eastern_8 dumped Western_3 for Western_8\n", + " Eastern_4 dumped Western_5 for Western_3\n", + " Eastern_1 dumped Western_2 for Western_5\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Western_5 and Eastern_5\n", + " Western_6 and Eastern_1\n", + " Eastern_8 dumped Western_1 for Western_8\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Western_4 and Eastern_7\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Eastern_8 dumped Western_8 for Western_2\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Eastern_7 dumped Western_4 for Western_1\n", + " Eastern_7 dumped Western_1 for Western_3\n", + " Western_1 and Eastern_6\n", + " Western_4 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_2\n", + " Eastern_4 dumped Western_3 for Western_8\n", + " Eastern_6 dumped Western_5 for Western_6\n", + " Western_3 and Eastern_3\n", + " Western_1 and Eastern_8\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_1\n", + " Eastern_2 dumped Western_5 for Western_1\n", + " Eastern_3 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Western_8 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Eastern_1 dumped Western_8 for Western_6\n", + " Western_4 and Eastern_7\n", + " Eastern_3 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_4\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_1\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Western_1 and Eastern_2\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Eastern_8 dumped Western_4 for Western_6\n", + " Eastern_4 dumped Western_3 for Western_2\n", + " Western_4 and Eastern_7\n", + " Western_3 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_5 dumped Western_3 for Western_4\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_6\n", + " Eastern_2 dumped Western_2 for Western_8\n", + " Western_4 and Eastern_1\n", + " Eastern_3 dumped Western_6 for Western_2\n", + " Western_3 and Eastern_8\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_8 and Eastern_4\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_4 dumped Western_8 for Western_2\n", + " Eastern_1 dumped Western_3 for Western_8\n", + " Eastern_2 dumped Western_7 for Western_3\n", + " Western_7 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_5\n", + " Eastern_4 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_4 and Eastern_1\n", + " Eastern_6 dumped Western_3 for Western_8\n", + " Western_5 and Eastern_2\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Eastern_8 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_1\n", + " Eastern_1 dumped Western_7 for Western_8\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Eastern_5 dumped Western_3 for Western_2\n", + " Western_1 and Eastern_7\n", + " Eastern_8 dumped Western_5 for Western_3\n", + " Eastern_5 dumped Western_2 for Western_5\n", + " Eastern_4 dumped Western_6 for Western_2\n", + " Eastern_3 dumped Western_7 for Western_6\n", + " Eastern_7 dumped Western_1 for Western_7\n", + " Eastern_4 dumped Western_2 for Western_1\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_6\n", + " Eastern_4 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_1\n", + " Eastern_1 dumped Western_7 for Western_5\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_3\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_4\n", + " Eastern_6 dumped Western_2 for Western_6\n", + " Western_1 and Eastern_7\n", + " Eastern_4 dumped Western_8 for Western_2\n", + " Western_8 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Western_4 and Eastern_4\n", + " Eastern_3 dumped Western_1 for Western_5\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_5 dumped Western_2 for Western_8\n", + " Western_3 and Eastern_8\n", + " Western_1 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_2 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_1\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_1 dumped Western_5 for Western_7\n", + " Eastern_1 dumped Western_7 for Western_4\n", + " Western_3 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Western_8 and Eastern_4\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Eastern_6 dumped Western_2 for Western_5\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_4 dumped Western_6 for Western_8\n", + " Eastern_8 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_3 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_3\n", + " Eastern_3 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_8\n", + " Eastern_1 dumped Western_2 for Western_6\n", + " Western_7 and Eastern_3\n", + " Western_2 and Eastern_4\n", + " Western_8 and Eastern_5\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Eastern_2 dumped Western_4 for Western_3\n", + " Eastern_4 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_7 and Eastern_6\n", + " Western_8 and Eastern_7\n", + " Eastern_6 dumped Western_7 for Western_4\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Eastern_4 dumped Western_3 for Western_7\n", + " Western_3 and Eastern_3\n", + " Western_2 and Eastern_2\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_6\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_8\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_8\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_3\n", + " Western_7 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_2\n", + " Eastern_2 dumped Western_4 for Western_5\n", + " Eastern_2 dumped Western_5 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_4 dumped Western_7 for Western_4\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_5 and Eastern_8\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_5 and Eastern_5\n", + " Eastern_7 dumped Western_3 for Western_1\n", + " Eastern_8 dumped Western_6 for Western_3\n", + " Eastern_5 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_3\n", + " Eastern_7 dumped Western_1 for Western_5\n", + " Western_6 and Eastern_5\n", + " Eastern_6 dumped Western_3 for Western_7\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_2 and Eastern_1\n", + " Eastern_1 dumped Western_2 for Western_1\n", + " Eastern_5 dumped Western_6 for Western_2\n", + " Eastern_4 dumped Western_8 for Western_6\n", + " Eastern_3 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_5 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_3 for Western_8\n", + " Western_6 and Eastern_6\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Eastern_6 dumped Western_3 for Western_5\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_4\n", + " Eastern_7 dumped Western_6 for Western_3\n", + " Western_6 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Eastern_8 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_2\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_2 and Eastern_4\n", + " Eastern_5 dumped Western_6 for Western_3\n", + " Eastern_4 dumped Western_2 for Western_6\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Eastern_2 dumped Western_8 for Western_4\n", + " Eastern_5 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_5\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_1\n", + " Western_7 and Eastern_4\n", + " Eastern_5 dumped Western_2 for Western_3\n", + " Eastern_7 dumped Western_4 for Western_2\n", + " Eastern_8 dumped Western_6 for Western_4\n", + " Western_6 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Western_2 and Eastern_7\n", + " Western_5 and Eastern_5\n", + " Western_4 and Eastern_6\n", + " Eastern_6 dumped Western_4 for Western_3\n", + " Eastern_5 dumped Western_5 for Western_8\n", + " Eastern_5 dumped Western_8 for Western_4\n", + " Western_5 and Eastern_1\n", + " Eastern_7 dumped Western_2 for Western_8\n", + " Eastern_6 dumped Western_3 for Western_2\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_3\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Eastern_1 dumped Western_4 for Western_5\n", + " Eastern_3 dumped Western_3 for Western_6\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_2\n", + " Western_4 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Eastern_2 dumped Western_1 for Western_8\n", + " Western_1 and Eastern_8\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Eastern_2 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_1\n", + " Western_6 and Eastern_5\n", + " Eastern_3 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_2\n", + " Western_7 and Eastern_6\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_2 and Eastern_4\n", + " Western_6 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_2\n", + " Eastern_3 dumped Western_6 for Western_7\n", + " Eastern_2 dumped Western_8 for Western_6\n", + " Eastern_3 dumped Western_7 for Western_8\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Western_8 and Eastern_4\n", + " Eastern_5 dumped Western_7 for Western_1\n", + " Western_7 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Eastern_6 dumped Western_2 for Western_3\n", + " Eastern_6 dumped Western_3 for Western_4\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Eastern_7 dumped Western_6 for Western_3\n", + " Eastern_2 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_4\n", + " Eastern_3 dumped Western_8 for Western_6\n", + " Eastern_5 dumped Western_2 for Western_8\n", + " Eastern_7 dumped Western_3 for Western_2\n", + " Eastern_2 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Eastern_6 dumped Western_6 for Western_7\n", + " Western_3 and Eastern_8\n", + " Eastern_8 dumped Western_3 for Western_6\n", + " Eastern_4 dumped Western_5 for Western_3\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Eastern_7 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_8\n", + " Eastern_8 dumped Western_7 for Western_8\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_8\n", + " Western_8 and Eastern_7\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Western_4 and Eastern_5\n", + " Western_8 and Eastern_3\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_7\n", + " Eastern_6 dumped Western_1 for Western_8\n", + " Western_2 and Eastern_4\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Western_5 and Eastern_5\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_6\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Eastern_3 dumped Western_4 for Western_2\n", + " Eastern_6 dumped Western_7 for Western_5\n", + " Eastern_4 dumped Western_6 for Western_4\n", + " Western_7 and Eastern_7\n", + " Eastern_7 dumped Western_7 for Western_6\n", + " Eastern_4 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_2\n", + " Eastern_4 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_3\n", + " Eastern_5 dumped Western_4 for Western_7\n", + " Western_5 and Eastern_7\n", + " Western_8 and Eastern_1\n", + " Eastern_7 dumped Western_5 for Western_1\n", + " Eastern_4 dumped Western_3 for Western_4\n", + " Western_5 and Eastern_8\n", + " Western_3 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_4\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_1\n", + " Eastern_3 dumped Western_3 for Western_2\n", + " Western_5 and Eastern_5\n", + " Eastern_4 dumped Western_6 for Western_3\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Eastern_7 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_7\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_5\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Eastern_3 dumped Western_3 for Western_7\n", + " Western_1 and Eastern_1\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Western_4 and Eastern_6\n", + " Western_3 and Eastern_8\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_6\n", + " Eastern_3 dumped Western_5 for Western_8\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_3\n", + " Western_7 and Eastern_7\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_6 and Eastern_5\n", + " Eastern_7 dumped Western_7 for Western_2\n", + " Eastern_2 dumped Western_3 for Western_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_4\n", + " Eastern_1 dumped Western_3 for Western_5\n", + " Eastern_6 dumped Western_1 for Western_6\n", + " Western_7 and Eastern_5\n", + " Western_8 and Eastern_7\n", + " Eastern_6 dumped Western_6 for Western_3\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Eastern_1 dumped Western_5 for Western_1\n", + " Eastern_7 dumped Western_8 for Western_5\n", + " Eastern_8 dumped Western_2 for Western_8\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_5\n", + " Western_6 and Eastern_6\n", + " Western_8 and Eastern_4\n", + " Eastern_6 dumped Western_6 for Western_2\n", + " Eastern_4 dumped Western_8 for Western_7\n", + " Western_6 and Eastern_3\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_7\n", + " Eastern_7 dumped Western_6 for Western_3\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_4\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Eastern_4 dumped Western_3 for Western_6\n", + " Western_7 and Eastern_5\n", + " Eastern_4 dumped Western_6 for Western_2\n", + " Eastern_1 dumped Western_1 for Western_5\n", + " Western_3 and Eastern_6\n", + " Western_8 and Eastern_3\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_7\n", + " Eastern_2 dumped Western_4 for Western_1\n", + " Eastern_5 dumped Western_6 for Western_4\n", + " Eastern_3 dumped Western_8 for Western_6\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_1\n", + " Eastern_4 dumped Western_2 for Western_8\n", + " Eastern_2 dumped Western_1 for Western_2\n", + " Western_5 and Eastern_6\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_6\n", + " Western_4 and Eastern_5\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_8\n", + " Eastern_4 dumped Western_5 for Western_3\n", + " Eastern_7 dumped Western_6 for Western_5\n", + " Eastern_2 dumped Western_1 for Western_6\n", + " Eastern_6 dumped Western_2 for Western_1\n", + " Western_2 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_3\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Western_8 and Eastern_5\n", + " Eastern_2 dumped Western_2 for Western_4\n", + " Western_6 and Eastern_1\n", + " Eastern_1 dumped Western_6 for Western_2\n", + " Western_7 and Eastern_6\n", + " Eastern_7 dumped Western_3 for Western_6\n", + " Western_3 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_8\n", + " Eastern_8 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_7\n", + " Western_6 and Eastern_5\n", + " Western_7 and Eastern_2\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Western_2 and Eastern_6\n", + " Eastern_2 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_4\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Eastern_4 dumped Western_2 for Western_5\n", + " Western_6 and Eastern_6\n", + " Eastern_8 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_1\n", + " Eastern_7 dumped Western_4 for Western_2\n", + " Western_1 and Eastern_2\n", + " Eastern_6 dumped Western_6 for Western_4\n", + " Eastern_8 dumped Western_7 for Western_6\n", + " Eastern_4 dumped Western_5 for Western_7\n", + " Western_5 and Eastern_3\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Eastern_3 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_1\n", + " Western_7 and Eastern_5\n", + " Eastern_1 dumped Western_6 for Western_8\n", + " Eastern_2 dumped Western_3 for Western_1\n", + " Western_6 and Eastern_4\n", + " Eastern_3 dumped Western_2 for Western_3\n", + " Western_2 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Eastern_8 dumped Western_1 for Western_4\n", + " Western_5 and Eastern_2\n", + " Western_8 and Eastern_5\n", + " Eastern_5 dumped Western_8 for Western_1\n", + " Western_6 and Eastern_6\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Western_8 and Eastern_3\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Eastern_7 dumped Western_3 for Western_1\n", + " Eastern_3 dumped Western_8 for Western_3\n", + " Eastern_2 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_3 and Eastern_1\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_5\n", + " Eastern_6 dumped Western_4 for Western_6\n", + " Eastern_5 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Eastern_4 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_6\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_1\n", + " Western_8 and Eastern_2\n", + " Eastern_2 dumped Western_8 for Western_1\n", + " Western_5 and Eastern_8\n", + " Eastern_1 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_3\n", + " Western_8 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Western_2 and Eastern_8\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_5\n", + " Eastern_6 dumped Western_4 for Western_8\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Eastern_5 dumped Western_7 for Western_6\n", + " Western_7 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Eastern_1 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_5\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Western_1 and Eastern_3\n", + " Western_5 and Eastern_8\n", + " Eastern_6 dumped Western_8 for Western_4\n", + " Eastern_8 dumped Western_5 for Western_6\n", + " Western_8 and Eastern_2\n", + " Eastern_6 dumped Western_4 for Western_5\n", + " Western_4 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_3\n", + " Eastern_8 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_5\n", + " Eastern_3 dumped Western_2 for Western_6\n", + " Eastern_8 dumped Western_3 for Western_7\n", + " Western_1 and Eastern_4\n", + " Western_3 and Eastern_2\n", + " Eastern_5 dumped Western_5 for Western_2\n", + " Eastern_1 dumped Western_4 for Western_8\n", + " Western_4 and Eastern_6\n", + " Eastern_3 dumped Western_6 for Western_5\n", + " Eastern_5 dumped Western_2 for Western_6\n", + " Eastern_6 dumped Western_4 for Western_2\n", + " Eastern_2 dumped Western_3 for Western_4\n", + " Western_3 and Eastern_7\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_6\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Western_5 and Eastern_1\n", + " Eastern_3 dumped Western_1 for Western_6\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_7\n", + " Western_8 and Eastern_4\n", + " Eastern_5 dumped Western_3 for Western_1\n", + " Eastern_2 dumped Western_7 for Western_3\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_6\n", + " Western_2 and Eastern_5\n", + " Western_4 and Eastern_1\n", + " Western_5 and Eastern_2\n", + " Eastern_2 dumped Western_5 for Western_7\n", + " Western_6 and Eastern_3\n", + " Western_5 and Eastern_7\n", + " Eastern_7 dumped Western_5 for Western_8\n", + " Eastern_7 dumped Western_8 for Western_3\n", + " Western_5 and Eastern_8\n", + " Eastern_3 dumped Western_6 for Western_8\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Eastern_5 dumped Western_1 for Western_2\n", + " Western_4 and Eastern_8\n", + " Western_5 and Eastern_7\n", + " Western_7 and Eastern_1\n", + " Western_8 and Eastern_3\n", + " Western_3 and Eastern_6\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Eastern_1 dumped Western_7 for Western_4\n", + " Western_6 and Eastern_2\n", + " Eastern_2 dumped Western_6 for Western_7\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_7\n", + " Western_6 and Eastern_8\n", + " Eastern_1 dumped Western_2 for Western_8\n", + " Western_5 and Eastern_6\n", + " Western_7 and Eastern_3\n", + " Eastern_3 dumped Western_7 for Western_2\n", + " Eastern_7 dumped Western_4 for Western_7\n", + " Eastern_6 dumped Western_5 for Western_4\n", + " Eastern_4 dumped Western_1 for Western_5\n", + " Western_1 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_3\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_7\n", + " Western_4 and Eastern_4\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_5\n", + " Eastern_3 dumped Western_1 for Western_7\n", + " Western_1 and Eastern_2\n", + " Eastern_5 dumped Western_6 for Western_8\n", + " Eastern_4 dumped Western_4 for Western_6\n", + " Eastern_5 dumped Western_8 for Western_4\n", + " Western_8 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_2\n", + " Eastern_2 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_6\n", + " Western_5 and Eastern_4\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_3\n", + " Western_2 and Eastern_5\n", + " Eastern_3 dumped Western_8 for Western_1\n", + " Eastern_4 dumped Western_5 for Western_8\n", + " Western_5 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Eastern_1 dumped Western_1 for Western_2\n", + " Western_3 and Eastern_8\n", + " Western_5 and Eastern_6\n", + " Western_6 and Eastern_2\n", + " Eastern_6 dumped Western_5 for Western_7\n", + " Western_8 and Eastern_5\n", + " Western_4 and Eastern_7\n", + " Eastern_7 dumped Western_4 for Western_5\n", + " Eastern_8 dumped Western_3 for Western_1\n", + " Eastern_2 dumped Western_6 for Western_4\n", + " Eastern_1 dumped Western_2 for Western_3\n", + " Eastern_6 dumped Western_7 for Western_2\n", + " Western_7 and Eastern_3\n", + " Western_6 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_2\n", + " Western_3 and Eastern_3\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_4\n", + " Eastern_3 dumped Western_3 for Western_8\n", + " Western_5 and Eastern_7\n", + " Western_4 and Eastern_8\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Eastern_1 dumped Western_1 for Western_2\n", + " Eastern_8 dumped Western_4 for Western_1\n", + " Eastern_1 dumped Western_2 for Western_4\n", + " Eastern_7 dumped Western_5 for Western_2\n", + " Eastern_3 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_6\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_5\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_8\n", + " Western_4 and Eastern_6\n", + " Eastern_8 dumped Western_3 for Western_5\n", + " Western_6 and Eastern_2\n", + " Eastern_8 dumped Western_5 for Western_7\n", + " Eastern_5 dumped Western_1 for Western_8\n", + " Western_3 and Eastern_7\n", + " Eastern_5 dumped Western_8 for Western_5\n", + " Eastern_7 dumped Western_3 for Western_8\n", + " Western_3 and Eastern_4\n", + " Western_1 and Eastern_1\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_7\n", + " Western_2 and Eastern_1\n", + " Western_3 and Eastern_5\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_4\n", + " Eastern_7 dumped Western_1 for Western_8\n", + " Western_6 and Eastern_2\n", + " Eastern_1 dumped Western_2 for Western_7\n", + " Western_1 and Eastern_6\n", + " Eastern_7 dumped Western_8 for Western_2\n", + " Eastern_2 dumped Western_6 for Western_8\n", + " Eastern_5 dumped Western_3 for Western_6\n", + " Eastern_3 dumped Western_4 for Western_3\n", + " Western_4 and Eastern_8\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Eastern_3 dumped Western_4 for Western_7\n", + " Western_8 and Eastern_4\n", + " Western_2 and Eastern_6\n", + " Eastern_1 dumped Western_1 for Western_4\n", + " Western_1 and Eastern_2\n", + " Western_5 and Eastern_5\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Western_2 and Eastern_3\n", + " Western_3 and Eastern_2\n", + " Western_4 and Eastern_6\n", + " Western_6 and Eastern_7\n", + " Western_8 and Eastern_8\n", + " Western_7 and Eastern_5\n", + " Eastern_8 dumped Western_8 for Western_5\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_1\n", + " Eastern_1 dumped Western_1 for Western_3\n", + " Western_4 and Eastern_2\n", + " Western_5 and Eastern_3\n", + " Western_6 and Eastern_8\n", + " Western_7 and Eastern_7\n", + " Western_8 and Eastern_5\n", + " Western_2 and Eastern_6\n", + " Eastern_7 dumped Western_7 for Western_1\n", + " Eastern_5 dumped Western_8 for Western_7\n", + " Western_8 and Eastern_4\n", + "Match stability check PASSED\n", + " Western_1 and Eastern_4\n", + " Western_2 and Eastern_7\n", + " Eastern_7 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_5\n", + " Eastern_5 dumped Western_4 for Western_6\n", + " Western_7 and Eastern_2\n", + " Western_8 and Eastern_3\n", + " Eastern_2 dumped Western_7 for Western_4\n", + " Western_2 and Eastern_6\n", + " Western_7 and Eastern_1\n", + " Western_5 and Eastern_8\n", + "Match stability check PASSED\n", + "Percentage of stable playoff matches after 1000 shuffles: 100.0%\n" + ] + } + ], + "source": [ + "import copy\n", + "import random\n", + "\n", + "WesternTeam = {\n", + " 'Western_1': ['Eastern_8', 'Eastern_7', 'Eastern_6', 'Eastern_5', 'Eastern_4', 'Eastern_3', 'Eastern_2', 'Eastern_1'],\n", + " 'Western_2': ['Eastern_2', 'Eastern_4', 'Eastern_3', 'Eastern_8', 'Eastern_1', 'Eastern_5', 'Eastern_7', 'Eastern_6'],\n", + " 'Western_3': ['Eastern_2', 'Eastern_8', 'Eastern_1', 'Eastern_7', 'Eastern_6', 'Eastern_5', 'Eastern_4', 'Eastern_3'],\n", + " 'Western_4': ['Eastern_3', 'Eastern_6', 'Eastern_1', 'Eastern_8', 'Eastern_7', 'Eastern_2', 'Eastern_5', 'Eastern_4'],\n", + " 'Western_5': ['Eastern_1', 'Eastern_3', 'Eastern_5', 'Eastern_7', 'Eastern_2', 'Eastern_4', 'Eastern_6', 'Eastern_8'],\n", + " 'Western_6': ['Eastern_7', 'Eastern_6', 'Eastern_8', 'Eastern_4', 'Eastern_3', 'Eastern_1', 'Eastern_5', 'Eastern_2'],\n", + " 'Western_7': ['Eastern_4', 'Eastern_5', 'Eastern_2', 'Eastern_3', 'Eastern_6', 'Eastern_7', 'Eastern_8', 'Eastern_1'],\n", + " 'Western_8': ['Eastern_6', 'Eastern_8', 'Eastern_4', 'Eastern_1', 'Eastern_5', 'Eastern_2', 'Eastern_3', 'Eastern_7']\n", + "}\n", + "\n", + "EasternTeam = {\n", + " 'Eastern_1': ['Western_8', 'Western_3', 'Western_1', 'Western_2', 'Western_6', 'Western_7', 'Western_5', 'Western_4'],\n", + " 'Eastern_2': ['Western_3', 'Western_2', 'Western_1', 'Western_4', 'Western_5', 'Western_6', 'Western_7', 'Western_8'],\n", + " 'Eastern_3': ['Western_1', 'Western_6', 'Western_5', 'Western_4', 'Western_3', 'Western_2', 'Western_7', 'Western_8'],\n", + " 'Eastern_4': ['Western_7', 'Western_4', 'Western_6', 'Western_2', 'Western_8', 'Western_5', 'Western_3', 'Western_1'],\n", + " 'Eastern_5': ['Western_6', 'Western_7', 'Western_4', 'Western_3', 'Western_2', 'Western_8', 'Western_1', 'Western_5'],\n", + " 'Eastern_6': ['Western_1', 'Western_5', 'Western_8', 'Western_4', 'Western_7', 'Western_3', 'Western_2', 'Western_6'],\n", + " 'Eastern_7': ['Western_4', 'Western_2', 'Western_6', 'Western_3', 'Western_1', 'Western_5', 'Western_7', 'Western_8'],\n", + " 'Eastern_8': ['Western_1', 'Western_5', 'Western_7', 'Western_2', 'Western_3', 'Western_6', 'Western_8', 'Western_4']\n", + "}\n", + "\n", + "Western = sorted(WesternTeam.keys())\n", + "Eastern = sorted(EasternTeam.keys())\n", + "\n", + "\n", + "def check(matched):\n", + " inversematched = dict((v,k) for k,v in matched.items())#\n", + " for E,W in matched.items():\n", + " Elikes = EasternTeam[E]\n", + " Elikesbetter = Elikes[:Elikes.index(W)]\n", + " Wlikes = WesternTeam[W]\n", + " Wlikesbetter =Wlikes[:Wlikes.index(E)]\n", + " for Wes in Elikesbetter:\n", + " Western_East = inversematched[Wes] \n", + " Weslikes = WesternTeam[Wes] \n", + " if Weslikes.index(Western_East) > Weslikes.index(E):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (E, Wes,W, Western_East))\n", + " return False\n", + " for Eas in Wlikesbetter:\n", + " Eastern_Wes = matched[Eas]\n", + " Easlikes = EasternTeam[Eas]\n", + " if Easlikes.index(Eastern_Wes) > Easlikes.index(W):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (W, Eas, E, Eastern_Wes))\n", + " return False\n", + " return True\n", + "\n", + "def matchmaker():\n", + " Westernfree = Western[:]\n", + " matched = {}\n", + " WesternTeam2 = copy.deepcopy(WesternTeam)\n", + " EasternTeam2 = copy.deepcopy(EasternTeam)\n", + " while Westernfree:\n", + " Wes = Westernfree.pop(0)\n", + " Westernlist = WesternTeam2[Wes]\n", + " Eas = Westernlist.pop(0)\n", + " competitor = matched.get(Eas)\n", + " if not competitor:\n", + " # E's free\n", + " matched[Eas] = Wes\n", + " print(\" %s and %s\" % (Wes, Eas))\n", + " else:\n", + " # The bounder proposes to an matched lass!\n", + " Easternlist = EasternTeam2[Eas]\n", + " if Easternlist.index(competitor) > Easternlist.index(Wes):\n", + " # E prefers new Wes\n", + " matched[Eas] = Wes\n", + " print(\" %s dumped %s for %s\" % (Eas, competitor, Wes))\n", + " if WesternTeam2[competitor]:\n", + " # Ex has more girls to try\n", + " Westernfree.append(competitor)\n", + " else:\n", + " # E is faithful to old competitor\n", + " if Westernlist:\n", + " # Look again\n", + " Westernfree.append(Wes)\n", + " return matched\n", + " \n", + "\n", + "stable_matches = 0\n", + "total_matches = 0\n", + "\n", + "# Shuffle the preference lists 1000 times and check stability\n", + "for _ in range(iterations):\n", + " \n", + " # Shuffle the preference lists for each team\n", + " for team_prefs in WesternTeam.values():\n", + " random.shuffle(team_prefs)\n", + " for team_prefs in EasternTeam.values():\n", + " random.shuffle(team_prefs)\n", + " \n", + " \n", + " # Run the matching algorithm\n", + " matched = matchmaker()\n", + "\n", + " # Check if the match is stable\n", + " if check(matched):\n", + " print('Match stability check PASSED')\n", + " stable_matches += 1\n", + " else:\n", + " print('Match stability check FAILED')\n", + " \n", + " total_matches += 1\n", + "\n", + "percentage_stable = (stable_matches / 1000) * 100\n", + "\n", + "iterations = 1000\n", + "print(f\"Percentage of stable playoff matches after {iterations} shuffles: {percentage_stable}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94216f32", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_E.ipynb b/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_E.ipynb new file mode 100644 index 0000000..6915913 --- /dev/null +++ b/Submissions/Weiyu_Wang_002746483/Assignmen1_Q9_E.ipynb @@ -0,0 +1,424 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "71550457", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Match:\n", + " Western_1 and Eastern_8\n", + " Western_2 and Eastern_2\n", + " Eastern_2 dumped Western_2 for Western_3\n", + " Western_4 and Eastern_3\n", + " Western_5 and Eastern_1\n", + " Western_6 and Eastern_7\n", + " Western_7 and Eastern_4\n", + " Western_8 and Eastern_6\n", + " Eastern_1 dumped Western_5 for Western_2\n", + " Eastern_3 dumped Western_4 for Western_5\n", + " Eastern_7 dumped Western_6 for Western_4\n", + " Eastern_3 dumped Western_5 for Western_6\n", + " Western_5 and Eastern_5\n", + "\n", + "Pairs:\n", + " Eastern_1 is matched to Western_2,\n", + " Eastern_2 is matched to Western_3,\n", + " Eastern_3 is matched to Western_6,\n", + " Eastern_4 is matched to Western_7,\n", + " Eastern_5 is matched to Western_5,\n", + " Eastern_6 is matched to Western_8,\n", + " Eastern_7 is matched to Western_4,\n", + " Eastern_8 is matched to Western_1\n", + "\n", + "Match stability check PASSED\n", + "--- 0.0010006428 seconds ---\n" + ] + } + ], + "source": [ + "import copy\n", + "import time\n", + "start_time = time.time()\n", + "WesternTeam = {\n", + " 'Western_1': ['Eastern_8', 'Eastern_7', 'Eastern_6', 'Eastern_5', 'Eastern_4', 'Eastern_3', 'Eastern_2', 'Eastern_1'],\n", + " 'Western_2': ['Eastern_2', 'Eastern_4', 'Eastern_3', 'Eastern_8', 'Eastern_1', 'Eastern_5', 'Eastern_7', 'Eastern_6'],\n", + " 'Western_3': ['Eastern_2', 'Eastern_8', 'Eastern_1', 'Eastern_7', 'Eastern_6', 'Eastern_5', 'Eastern_4', 'Eastern_3'],\n", + " 'Western_4': ['Eastern_3', 'Eastern_6', 'Eastern_1', 'Eastern_8', 'Eastern_7', 'Eastern_2', 'Eastern_5', 'Eastern_4'],\n", + " 'Western_5': ['Eastern_1', 'Eastern_3', 'Eastern_5', 'Eastern_7', 'Eastern_2', 'Eastern_4', 'Eastern_6', 'Eastern_8'],\n", + " 'Western_6': ['Eastern_7', 'Eastern_6', 'Eastern_8', 'Eastern_4', 'Eastern_3', 'Eastern_1', 'Eastern_5', 'Eastern_2'],\n", + " 'Western_7': ['Eastern_4', 'Eastern_5', 'Eastern_2', 'Eastern_3', 'Eastern_6', 'Eastern_7', 'Eastern_8', 'Eastern_1'],\n", + " 'Western_8': ['Eastern_6', 'Eastern_8', 'Eastern_4', 'Eastern_1', 'Eastern_5', 'Eastern_2', 'Eastern_3', 'Eastern_7']\n", + "}\n", + "\n", + "EasternTeam = {\n", + " 'Eastern_1': ['Western_8', 'Western_3', 'Western_1', 'Western_2', 'Western_6', 'Western_7', 'Western_5', 'Western_4'],\n", + " 'Eastern_2': ['Western_3', 'Western_2', 'Western_1', 'Western_4', 'Western_5', 'Western_6', 'Western_7', 'Western_8'],\n", + " 'Eastern_3': ['Western_1', 'Western_6', 'Western_5', 'Western_4', 'Western_3', 'Western_2', 'Western_7', 'Western_8'],\n", + " 'Eastern_4': ['Western_7', 'Western_4', 'Western_6', 'Western_2', 'Western_8', 'Western_5', 'Western_3', 'Western_1'],\n", + " 'Eastern_5': ['Western_6', 'Western_7', 'Western_4', 'Western_3', 'Western_2', 'Western_8', 'Western_1', 'Western_5'],\n", + " 'Eastern_6': ['Western_1', 'Western_5', 'Western_8', 'Western_4', 'Western_7', 'Western_3', 'Western_2', 'Western_6'],\n", + " 'Eastern_7': ['Western_4', 'Western_2', 'Western_6', 'Western_3', 'Western_1', 'Western_5', 'Western_7', 'Western_8'],\n", + " 'Eastern_8': ['Western_1', 'Western_5', 'Western_7', 'Western_2', 'Western_3', 'Western_6', 'Western_8', 'Western_4']\n", + "}\n", + "\n", + "Western = sorted(WesternTeam.keys())\n", + "Eastern = sorted(EasternTeam.keys())\n", + "\n", + "\n", + "def check(matched):\n", + " inversematched = dict((v,k) for k,v in matched.items())#\n", + " for E,W in matched.items():\n", + " Elikes = EasternTeam[E]\n", + " Elikesbetter = Elikes[:Elikes.index(W)]\n", + " Wlikes = WesternTeam[W]\n", + " Wlikesbetter =Wlikes[:Wlikes.index(E)]\n", + " for Wes in Elikesbetter:\n", + " Western_East = inversematched[Wes] \n", + " Weslikes = WesternTeam[Wes] \n", + " if Weslikes.index(Western_East) > Weslikes.index(E):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (E, Wes,W, Western_East))\n", + " return False\n", + " for Eas in Wlikesbetter:\n", + " Eastern_Wes = matched[Eas]\n", + " Easlikes = EasternTeam[Eas]\n", + " if Easlikes.index(Eastern_Wes) > Easlikes.index(W):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (W, Eas, E, Eastern_Wes))\n", + " return False\n", + " return True\n", + "\n", + "def matchmaker():\n", + " Westernfree = Western[:]\n", + " matched = {}\n", + " WesternTeam2 = copy.deepcopy(WesternTeam)\n", + " EasternTeam2 = copy.deepcopy(EasternTeam)\n", + " while Westernfree:\n", + " Wes = Westernfree.pop(0)\n", + " Westernlist = WesternTeam2[Wes]\n", + " Eas = Westernlist.pop(0)\n", + " competitor = matched.get(Eas)\n", + " if not competitor:\n", + " # E's free\n", + " matched[Eas] = Wes\n", + " print(\" %s and %s\" % (Wes, Eas))\n", + " else:\n", + " Easternlist = EasternTeam2[Eas]\n", + " if Easternlist.index(competitor) > Easternlist.index(Wes):\n", + " matched[Eas] = Wes\n", + " print(\" %s dumped %s for %s\" % (Eas, competitor, Wes))\n", + " if WesternTeam2[competitor]:\n", + " \n", + " Westernfree.append(competitor)\n", + " else:\n", + " if Westernlist:\n", + " Westernfree.append(Wes)\n", + " return matched\n", + "\n", + "\n", + "print('\\nMatch:')\n", + "matched = matchmaker()\n", + "\n", + "print('\\nPairs:')\n", + "print(' ' + ',\\n '.join('%s is matched to %s' % couple\n", + " for couple in sorted(matched.items())))\n", + "print()\n", + "print('Match stability check PASSED'\n", + " if check(matched) else 'Match stability check FAILED')\n", + "print(\"--- %s seconds ---\" % (round(time.time() - start_time, 10)))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "91f6e6a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eastern Team Preferences:\n", + "Eastern_1: ['Western_5', 'Western_12', 'Western_7', 'Western_14', 'Western_13', 'Western_8', 'Western_10', 'Western_15', 'Western_2', 'Western_1', 'Western_6', 'Western_16', 'Western_11', 'Western_9', 'Western_4', 'Western_3']\n", + "Eastern_2: ['Western_12', 'Western_2', 'Western_15', 'Western_13', 'Western_9', 'Western_6', 'Western_3', 'Western_10', 'Western_4', 'Western_1', 'Western_14', 'Western_5', 'Western_11', 'Western_8', 'Western_16', 'Western_7']\n", + "Eastern_3: ['Western_11', 'Western_6', 'Western_12', 'Western_7', 'Western_1', 'Western_9', 'Western_8', 'Western_13', 'Western_16', 'Western_4', 'Western_5', 'Western_3', 'Western_2', 'Western_15', 'Western_10', 'Western_14']\n", + "Eastern_4: ['Western_8', 'Western_15', 'Western_2', 'Western_3', 'Western_5', 'Western_13', 'Western_6', 'Western_1', 'Western_7', 'Western_11', 'Western_14', 'Western_10', 'Western_16', 'Western_9', 'Western_4', 'Western_12']\n", + "Eastern_5: ['Western_13', 'Western_2', 'Western_8', 'Western_11', 'Western_14', 'Western_6', 'Western_10', 'Western_15', 'Western_5', 'Western_12', 'Western_1', 'Western_9', 'Western_16', 'Western_3', 'Western_7', 'Western_4']\n", + "Eastern_6: ['Western_8', 'Western_13', 'Western_3', 'Western_5', 'Western_12', 'Western_10', 'Western_15', 'Western_6', 'Western_14', 'Western_7', 'Western_4', 'Western_1', 'Western_9', 'Western_11', 'Western_16', 'Western_2']\n", + "Eastern_7: ['Western_15', 'Western_2', 'Western_16', 'Western_1', 'Western_5', 'Western_3', 'Western_9', 'Western_10', 'Western_7', 'Western_6', 'Western_11', 'Western_13', 'Western_12', 'Western_14', 'Western_8', 'Western_4']\n", + "Eastern_8: ['Western_14', 'Western_9', 'Western_3', 'Western_10', 'Western_13', 'Western_11', 'Western_5', 'Western_2', 'Western_12', 'Western_8', 'Western_16', 'Western_1', 'Western_4', 'Western_7', 'Western_15', 'Western_6']\n", + "Eastern_9: ['Western_1', 'Western_16', 'Western_7', 'Western_12', 'Western_3', 'Western_4', 'Western_8', 'Western_11', 'Western_13', 'Western_6', 'Western_2', 'Western_9', 'Western_14', 'Western_5', 'Western_15', 'Western_10']\n", + "Eastern_10: ['Western_9', 'Western_10', 'Western_15', 'Western_7', 'Western_5', 'Western_4', 'Western_2', 'Western_6', 'Western_14', 'Western_8', 'Western_16', 'Western_11', 'Western_12', 'Western_3', 'Western_1', 'Western_13']\n", + "Eastern_11: ['Western_14', 'Western_13', 'Western_2', 'Western_1', 'Western_7', 'Western_9', 'Western_12', 'Western_16', 'Western_8', 'Western_5', 'Western_4', 'Western_3', 'Western_6', 'Western_11', 'Western_15', 'Western_10']\n", + "Eastern_12: ['Western_14', 'Western_9', 'Western_11', 'Western_12', 'Western_10', 'Western_15', 'Western_6', 'Western_13', 'Western_8', 'Western_4', 'Western_1', 'Western_7', 'Western_2', 'Western_16', 'Western_5', 'Western_3']\n", + "Eastern_13: ['Western_13', 'Western_10', 'Western_6', 'Western_9', 'Western_12', 'Western_7', 'Western_4', 'Western_15', 'Western_1', 'Western_16', 'Western_2', 'Western_8', 'Western_11', 'Western_5', 'Western_14', 'Western_3']\n", + "Eastern_14: ['Western_6', 'Western_8', 'Western_2', 'Western_11', 'Western_15', 'Western_14', 'Western_7', 'Western_9', 'Western_13', 'Western_1', 'Western_4', 'Western_16', 'Western_3', 'Western_10', 'Western_12', 'Western_5']\n", + "Eastern_15: ['Western_13', 'Western_10', 'Western_8', 'Western_15', 'Western_3', 'Western_4', 'Western_9', 'Western_14', 'Western_1', 'Western_12', 'Western_11', 'Western_16', 'Western_6', 'Western_7', 'Western_5', 'Western_2']\n", + "Eastern_16: ['Western_4', 'Western_1', 'Western_11', 'Western_8', 'Western_12', 'Western_9', 'Western_5', 'Western_16', 'Western_14', 'Western_3', 'Western_10', 'Western_13', 'Western_6', 'Western_7', 'Western_15', 'Western_2']\n", + "\n", + "Western Team Preferences:\n", + "Western_1: ['Eastern_15', 'Eastern_12', 'Eastern_8', 'Eastern_13', 'Eastern_16', 'Eastern_5', 'Eastern_4', 'Eastern_6', 'Eastern_3', 'Eastern_9', 'Eastern_1', 'Eastern_10', 'Eastern_7', 'Eastern_2', 'Eastern_14', 'Eastern_11']\n", + "Western_2: ['Eastern_9', 'Eastern_11', 'Eastern_2', 'Eastern_5', 'Eastern_6', 'Eastern_7', 'Eastern_1', 'Eastern_16', 'Eastern_15', 'Eastern_13', 'Eastern_12', 'Eastern_14', 'Eastern_4', 'Eastern_10', 'Eastern_8', 'Eastern_3']\n", + "Western_3: ['Eastern_4', 'Eastern_5', 'Eastern_10', 'Eastern_3', 'Eastern_16', 'Eastern_11', 'Eastern_1', 'Eastern_8', 'Eastern_13', 'Eastern_6', 'Eastern_2', 'Eastern_12', 'Eastern_14', 'Eastern_7', 'Eastern_9', 'Eastern_15']\n", + "Western_4: ['Eastern_9', 'Eastern_10', 'Eastern_8', 'Eastern_1', 'Eastern_11', 'Eastern_6', 'Eastern_12', 'Eastern_16', 'Eastern_14', 'Eastern_4', 'Eastern_13', 'Eastern_15', 'Eastern_7', 'Eastern_2', 'Eastern_5', 'Eastern_3']\n", + "Western_5: ['Eastern_14', 'Eastern_1', 'Eastern_6', 'Eastern_8', 'Eastern_3', 'Eastern_5', 'Eastern_15', 'Eastern_9', 'Eastern_11', 'Eastern_4', 'Eastern_16', 'Eastern_13', 'Eastern_7', 'Eastern_12', 'Eastern_10', 'Eastern_2']\n", + "Western_6: ['Eastern_15', 'Eastern_16', 'Eastern_8', 'Eastern_2', 'Eastern_12', 'Eastern_13', 'Eastern_10', 'Eastern_6', 'Eastern_14', 'Eastern_7', 'Eastern_9', 'Eastern_11', 'Eastern_3', 'Eastern_4', 'Eastern_5', 'Eastern_1']\n", + "Western_7: ['Eastern_9', 'Eastern_10', 'Eastern_12', 'Eastern_11', 'Eastern_16', 'Eastern_4', 'Eastern_2', 'Eastern_1', 'Eastern_3', 'Eastern_14', 'Eastern_8', 'Eastern_5', 'Eastern_13', 'Eastern_15', 'Eastern_6', 'Eastern_7']\n", + "Western_8: ['Eastern_4', 'Eastern_14', 'Eastern_7', 'Eastern_11', 'Eastern_9', 'Eastern_5', 'Eastern_1', 'Eastern_10', 'Eastern_13', 'Eastern_2', 'Eastern_12', 'Eastern_3', 'Eastern_8', 'Eastern_15', 'Eastern_16', 'Eastern_6']\n", + "Western_9: ['Eastern_6', 'Eastern_11', 'Eastern_1', 'Eastern_15', 'Eastern_9', 'Eastern_5', 'Eastern_7', 'Eastern_14', 'Eastern_16', 'Eastern_12', 'Eastern_8', 'Eastern_2', 'Eastern_13', 'Eastern_10', 'Eastern_3', 'Eastern_4']\n", + "Western_10: ['Eastern_14', 'Eastern_11', 'Eastern_8', 'Eastern_10', 'Eastern_15', 'Eastern_6', 'Eastern_7', 'Eastern_4', 'Eastern_13', 'Eastern_12', 'Eastern_9', 'Eastern_1', 'Eastern_16', 'Eastern_3', 'Eastern_2', 'Eastern_5']\n", + "Western_11: ['Eastern_10', 'Eastern_6', 'Eastern_12', 'Eastern_13', 'Eastern_11', 'Eastern_14', 'Eastern_1', 'Eastern_5', 'Eastern_2', 'Eastern_8', 'Eastern_9', 'Eastern_7', 'Eastern_15', 'Eastern_16', 'Eastern_3', 'Eastern_4']\n", + "Western_12: ['Eastern_5', 'Eastern_6', 'Eastern_4', 'Eastern_15', 'Eastern_3', 'Eastern_1', 'Eastern_12', 'Eastern_14', 'Eastern_7', 'Eastern_16', 'Eastern_10', 'Eastern_9', 'Eastern_2', 'Eastern_8', 'Eastern_11', 'Eastern_13']\n", + "Western_13: ['Eastern_4', 'Eastern_9', 'Eastern_11', 'Eastern_12', 'Eastern_1', 'Eastern_8', 'Eastern_6', 'Eastern_15', 'Eastern_5', 'Eastern_16', 'Eastern_14', 'Eastern_13', 'Eastern_10', 'Eastern_2', 'Eastern_3', 'Eastern_7']\n", + "Western_14: ['Eastern_7', 'Eastern_13', 'Eastern_10', 'Eastern_15', 'Eastern_11', 'Eastern_1', 'Eastern_6', 'Eastern_4', 'Eastern_16', 'Eastern_3', 'Eastern_8', 'Eastern_12', 'Eastern_5', 'Eastern_14', 'Eastern_9', 'Eastern_2']\n", + "Western_15: ['Eastern_7', 'Eastern_12', 'Eastern_9', 'Eastern_2', 'Eastern_11', 'Eastern_14', 'Eastern_6', 'Eastern_3', 'Eastern_13', 'Eastern_1', 'Eastern_4', 'Eastern_5', 'Eastern_10', 'Eastern_15', 'Eastern_8', 'Eastern_16']\n", + "Western_16: ['Eastern_15', 'Eastern_16', 'Eastern_6', 'Eastern_4', 'Eastern_3', 'Eastern_8', 'Eastern_1', 'Eastern_10', 'Eastern_2', 'Eastern_12', 'Eastern_14', 'Eastern_5', 'Eastern_13', 'Eastern_11', 'Eastern_7', 'Eastern_9']\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "# Define the list of team names for both East and West teams\n", + "east_teams = ['Eastern_' + str(i) for i in range(1, 17)]\n", + "west_teams = ['Western_' + str(i) for i in range(1, 17)]\n", + "\n", + "# Initialize empty preference tables for East and West teams\n", + "eastern_preferences = {}\n", + "western_preferences = {}\n", + "\n", + "# Generate random preference tables for East and West teams\n", + "for east_team in east_teams:\n", + " # Shuffle the list of west teams to create random preferences\n", + " random_west_prefs = random.sample(west_teams, len(west_teams))\n", + " eastern_preferences[east_team] = random_west_prefs\n", + "\n", + "for west_team in west_teams:\n", + " # Shuffle the list of east teams to create random preferences\n", + " random_east_prefs = random.sample(east_teams, len(east_teams))\n", + " western_preferences[west_team] = random_east_prefs\n", + "\n", + "# Print the generated preference tables\n", + "print(\"Eastern Team Preferences:\")\n", + "for team, prefs in eastern_preferences.items():\n", + " print(f\"{team}: {prefs}\")\n", + "\n", + "print(\"\\nWestern Team Preferences:\")\n", + "for team, prefs in western_preferences.items():\n", + " print(f\"{team}: {prefs}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "725d49f4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Match:\n", + " Eastern_1 and Western_5\n", + " Eastern_10 and Western_9\n", + " Eastern_11 and Western_14\n", + " Eastern_13 and Western_13\n", + " Eastern_14 and Western_6\n", + " Western_13 dumped Eastern_13 for Eastern_15\n", + " Eastern_16 and Western_4\n", + " Eastern_2 and Western_12\n", + " Eastern_3 and Western_11\n", + " Eastern_4 and Western_8\n", + " Eastern_7 and Western_15\n", + " Eastern_9 and Western_1\n", + " Western_9 dumped Eastern_10 for Eastern_12\n", + " Eastern_13 and Western_10\n", + " Eastern_5 and Western_2\n", + " Western_13 dumped Eastern_15 for Eastern_6\n", + " Western_10 dumped Eastern_13 for Eastern_10\n", + " Eastern_8 and Western_3\n", + " Western_6 dumped Eastern_14 for Eastern_13\n", + " Western_11 dumped Eastern_3 for Eastern_14\n", + " Western_9 dumped Eastern_12 for Eastern_15\n", + " Western_12 dumped Eastern_2 for Eastern_3\n", + " Western_11 dumped Eastern_14 for Eastern_12\n", + " Western_2 dumped Eastern_5 for Eastern_2\n", + " Eastern_14 and Western_7\n", + " Western_12 dumped Eastern_3 for Eastern_5\n", + " Western_7 dumped Eastern_14 for Eastern_3\n", + " Eastern_14 and Western_16\n", + "\n", + "Pairs:\n", + " Western_1 is matched to Eastern_9,\n", + " Western_10 is matched to Eastern_10,\n", + " Western_11 is matched to Eastern_12,\n", + " Western_12 is matched to Eastern_5,\n", + " Western_13 is matched to Eastern_6,\n", + " Western_14 is matched to Eastern_11,\n", + " Western_15 is matched to Eastern_7,\n", + " Western_16 is matched to Eastern_14,\n", + " Western_2 is matched to Eastern_2,\n", + " Western_3 is matched to Eastern_8,\n", + " Western_4 is matched to Eastern_16,\n", + " Western_5 is matched to Eastern_1,\n", + " Western_6 is matched to Eastern_13,\n", + " Western_7 is matched to Eastern_3,\n", + " Western_8 is matched to Eastern_4,\n", + " Western_9 is matched to Eastern_15\n", + "\n", + "Match stability check PASSED\n", + "--- 0.0015025139 seconds ---\n" + ] + } + ], + "source": [ + "import copy\n", + "import time\n", + "start_time = time.time()\n", + "WesternTeam = {\n", + " 'Eastern_1': ['Western_5', 'Western_12', 'Western_7', 'Western_14', 'Western_13', 'Western_8', 'Western_10', 'Western_15', 'Western_2', 'Western_1', 'Western_6', 'Western_16', 'Western_11', 'Western_9', 'Western_4', 'Western_3'],\n", + " 'Eastern_2': ['Western_12', 'Western_2', 'Western_15', 'Western_13', 'Western_9', 'Western_6', 'Western_3', 'Western_10', 'Western_4', 'Western_1', 'Western_14', 'Western_5', 'Western_11', 'Western_8', 'Western_16', 'Western_7'],\n", + " 'Eastern_3': ['Western_11', 'Western_6', 'Western_12', 'Western_7', 'Western_1', 'Western_9', 'Western_8', 'Western_13', 'Western_16', 'Western_4', 'Western_5', 'Western_3', 'Western_2', 'Western_15', 'Western_10', 'Western_14'],\n", + " 'Eastern_4': ['Western_8', 'Western_15', 'Western_2', 'Western_3', 'Western_5', 'Western_13', 'Western_6', 'Western_1', 'Western_7', 'Western_11', 'Western_14', 'Western_10', 'Western_16', 'Western_9', 'Western_4', 'Western_12'],\n", + " 'Eastern_5': ['Western_13', 'Western_2', 'Western_8', 'Western_11', 'Western_14', 'Western_6', 'Western_10', 'Western_15', 'Western_5', 'Western_12', 'Western_1', 'Western_9', 'Western_16', 'Western_3', 'Western_7', 'Western_4'],\n", + " 'Eastern_6': ['Western_8', 'Western_13', 'Western_3', 'Western_5', 'Western_12', 'Western_10', 'Western_15', 'Western_6', 'Western_14', 'Western_7', 'Western_4', 'Western_1', 'Western_9', 'Western_11', 'Western_16', 'Western_2'],\n", + " 'Eastern_7': ['Western_15', 'Western_2', 'Western_16', 'Western_1', 'Western_5', 'Western_3', 'Western_9', 'Western_10', 'Western_7', 'Western_6', 'Western_11', 'Western_13', 'Western_12', 'Western_14', 'Western_8', 'Western_4'],\n", + " 'Eastern_8': ['Western_14', 'Western_9', 'Western_3', 'Western_10', 'Western_13', 'Western_11', 'Western_5', 'Western_2', 'Western_12', 'Western_8', 'Western_16', 'Western_1', 'Western_4', 'Western_7', 'Western_15', 'Western_6'],\n", + " 'Eastern_9': ['Western_1', 'Western_16', 'Western_7', 'Western_12', 'Western_3', 'Western_4', 'Western_8', 'Western_11', 'Western_13', 'Western_6', 'Western_2', 'Western_9', 'Western_14', 'Western_5', 'Western_15', 'Western_10'],\n", + " 'Eastern_10': ['Western_9', 'Western_10', 'Western_15', 'Western_7', 'Western_5', 'Western_4', 'Western_2', 'Western_6', 'Western_14', 'Western_8', 'Western_16', 'Western_11', 'Western_12', 'Western_3', 'Western_1', 'Western_13'],\n", + " 'Eastern_11': ['Western_14', 'Western_13', 'Western_2', 'Western_1', 'Western_7', 'Western_9', 'Western_12', 'Western_16', 'Western_8', 'Western_5', 'Western_4', 'Western_3', 'Western_6', 'Western_11', 'Western_15', 'Western_10'],\n", + " 'Eastern_12': ['Western_14', 'Western_9', 'Western_11', 'Western_12', 'Western_10', 'Western_15', 'Western_6', 'Western_13', 'Western_8', 'Western_4', 'Western_1', 'Western_7', 'Western_2', 'Western_16', 'Western_5', 'Western_3'],\n", + " 'Eastern_13': ['Western_13', 'Western_10', 'Western_6', 'Western_9', 'Western_12', 'Western_7', 'Western_4', 'Western_15', 'Western_1', 'Western_16', 'Western_2', 'Western_8', 'Western_11', 'Western_5', 'Western_14', 'Western_3'],\n", + " 'Eastern_14': ['Western_6', 'Western_8', 'Western_2', 'Western_11', 'Western_15', 'Western_14', 'Western_7', 'Western_9', 'Western_13', 'Western_1', 'Western_4', 'Western_16', 'Western_3', 'Western_10', 'Western_12', 'Western_5'],\n", + " 'Eastern_15': ['Western_13', 'Western_10', 'Western_8', 'Western_15', 'Western_3', 'Western_4', 'Western_9', 'Western_14', 'Western_1', 'Western_12', 'Western_11', 'Western_16', 'Western_6', 'Western_7', 'Western_5', 'Western_2'],\n", + " 'Eastern_16': ['Western_4', 'Western_1', 'Western_11', 'Western_8', 'Western_12', 'Western_9', 'Western_5', 'Western_16', 'Western_14', 'Western_3', 'Western_10', 'Western_13', 'Western_6', 'Western_7', 'Western_15', 'Western_2']\n", + "}\n", + "\n", + "EasternTeam = {\n", + " 'Western_1': ['Eastern_15', 'Eastern_12', 'Eastern_8', 'Eastern_13', 'Eastern_16', 'Eastern_5', 'Eastern_4', 'Eastern_6', 'Eastern_3', 'Eastern_9', 'Eastern_1', 'Eastern_10', 'Eastern_7', 'Eastern_2', 'Eastern_14', 'Eastern_11'],\n", + " 'Western_2': ['Eastern_9', 'Eastern_11', 'Eastern_2', 'Eastern_5', 'Eastern_6', 'Eastern_7', 'Eastern_1', 'Eastern_16', 'Eastern_15', 'Eastern_13', 'Eastern_12', 'Eastern_14', 'Eastern_4', 'Eastern_10', 'Eastern_8', 'Eastern_3'],\n", + " 'Western_3': ['Eastern_4', 'Eastern_5', 'Eastern_10', 'Eastern_3', 'Eastern_16', 'Eastern_11', 'Eastern_1', 'Eastern_8', 'Eastern_13', 'Eastern_6', 'Eastern_2', 'Eastern_12', 'Eastern_14', 'Eastern_7', 'Eastern_9', 'Eastern_15'],\n", + " 'Western_4': ['Eastern_9', 'Eastern_10', 'Eastern_8', 'Eastern_1', 'Eastern_11', 'Eastern_6', 'Eastern_12', 'Eastern_16', 'Eastern_14', 'Eastern_4', 'Eastern_13', 'Eastern_15', 'Eastern_7', 'Eastern_2', 'Eastern_5', 'Eastern_3'],\n", + " 'Western_5': ['Eastern_14', 'Eastern_1', 'Eastern_6', 'Eastern_8', 'Eastern_3', 'Eastern_5', 'Eastern_15', 'Eastern_9', 'Eastern_11', 'Eastern_4', 'Eastern_16', 'Eastern_13', 'Eastern_7', 'Eastern_12', 'Eastern_10', 'Eastern_2'],\n", + " 'Western_6': ['Eastern_15', 'Eastern_16', 'Eastern_8', 'Eastern_2', 'Eastern_12', 'Eastern_13', 'Eastern_10', 'Eastern_6', 'Eastern_14', 'Eastern_7', 'Eastern_9', 'Eastern_11', 'Eastern_3', 'Eastern_4', 'Eastern_5', 'Eastern_1'],\n", + " 'Western_7': ['Eastern_9', 'Eastern_10', 'Eastern_12', 'Eastern_11', 'Eastern_16', 'Eastern_4', 'Eastern_2', 'Eastern_1', 'Eastern_3', 'Eastern_14', 'Eastern_8', 'Eastern_5', 'Eastern_13', 'Eastern_15', 'Eastern_6', 'Eastern_7'],\n", + " 'Western_8': ['Eastern_4', 'Eastern_14', 'Eastern_7', 'Eastern_11', 'Eastern_9', 'Eastern_5', 'Eastern_1', 'Eastern_10', 'Eastern_13', 'Eastern_2', 'Eastern_12', 'Eastern_3', 'Eastern_8', 'Eastern_15', 'Eastern_16', 'Eastern_6'],\n", + " 'Western_9': ['Eastern_6', 'Eastern_11', 'Eastern_1', 'Eastern_15', 'Eastern_9', 'Eastern_5', 'Eastern_7', 'Eastern_14', 'Eastern_16', 'Eastern_12', 'Eastern_8', 'Eastern_2', 'Eastern_13', 'Eastern_10', 'Eastern_3', 'Eastern_4'],\n", + " 'Western_10': ['Eastern_14', 'Eastern_11', 'Eastern_8', 'Eastern_10', 'Eastern_15', 'Eastern_6', 'Eastern_7', 'Eastern_4', 'Eastern_13', 'Eastern_12', 'Eastern_9', 'Eastern_1', 'Eastern_16', 'Eastern_3', 'Eastern_2', 'Eastern_5'],\n", + " 'Western_11': ['Eastern_10', 'Eastern_6', 'Eastern_12', 'Eastern_13', 'Eastern_11', 'Eastern_14', 'Eastern_1', 'Eastern_5', 'Eastern_2', 'Eastern_8', 'Eastern_9', 'Eastern_7', 'Eastern_15', 'Eastern_16', 'Eastern_3', 'Eastern_4'],\n", + " 'Western_12': ['Eastern_5', 'Eastern_6', 'Eastern_4', 'Eastern_15', 'Eastern_3', 'Eastern_1', 'Eastern_12', 'Eastern_14', 'Eastern_7', 'Eastern_16', 'Eastern_10', 'Eastern_9', 'Eastern_2', 'Eastern_8', 'Eastern_11', 'Eastern_13'],\n", + " 'Western_13': ['Eastern_4', 'Eastern_9', 'Eastern_11', 'Eastern_12', 'Eastern_1', 'Eastern_8', 'Eastern_6', 'Eastern_15', 'Eastern_5', 'Eastern_16', 'Eastern_14', 'Eastern_13', 'Eastern_10', 'Eastern_2', 'Eastern_3', 'Eastern_7'],\n", + " 'Western_14': ['Eastern_7', 'Eastern_13', 'Eastern_10', 'Eastern_15', 'Eastern_11', 'Eastern_1', 'Eastern_6', 'Eastern_4', 'Eastern_16', 'Eastern_3', 'Eastern_8', 'Eastern_12', 'Eastern_5', 'Eastern_14', 'Eastern_9', 'Eastern_2'],\n", + " 'Western_15': ['Eastern_7', 'Eastern_12', 'Eastern_9', 'Eastern_2', 'Eastern_11', 'Eastern_14', 'Eastern_6', 'Eastern_3', 'Eastern_13', 'Eastern_1', 'Eastern_4', 'Eastern_5', 'Eastern_10', 'Eastern_15', 'Eastern_8', 'Eastern_16'],\n", + " 'Western_16': ['Eastern_15', 'Eastern_16', 'Eastern_6', 'Eastern_4', 'Eastern_3', 'Eastern_8', 'Eastern_1', 'Eastern_10', 'Eastern_2', 'Eastern_12', 'Eastern_14', 'Eastern_5', 'Eastern_13', 'Eastern_11', 'Eastern_7', 'Eastern_9']\n", + "}\n", + "\n", + "Western = sorted(WesternTeam.keys())\n", + "Eastern = sorted(EasternTeam.keys())\n", + "\n", + "\n", + "def check(matched):\n", + " inversematched = dict((v,k) for k,v in matched.items())#\n", + " for E,W in matched.items():\n", + " Elikes = EasternTeam[E]\n", + " Elikesbetter = Elikes[:Elikes.index(W)]\n", + " Wlikes = WesternTeam[W]\n", + " Wlikesbetter =Wlikes[:Wlikes.index(E)]\n", + " for Wes in Elikesbetter:\n", + " Western_East = inversematched[Wes] \n", + " Weslikes = WesternTeam[Wes] \n", + " if Weslikes.index(Western_East) > Weslikes.index(E):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (E, Wes,W, Western_East))\n", + " return False\n", + " for Eas in Wlikesbetter:\n", + " Eastern_Wes = matched[Eas]\n", + " Easlikes = EasternTeam[Eas]\n", + " if Easlikes.index(Eastern_Wes) > Easlikes.index(W):\n", + " print(\"%s and %s tend to play against each other better than \"\n", + " \"their present rival: %s and %s, respectively\"\n", + " % (W, Eas, E, Eastern_Wes))\n", + " return False\n", + " return True\n", + "\n", + "def matchmaker():\n", + " Westernfree = Western[:]\n", + " matched = {}\n", + " WesternTeam2 = copy.deepcopy(WesternTeam)\n", + " EasternTeam2 = copy.deepcopy(EasternTeam)\n", + " while Westernfree:\n", + " Wes = Westernfree.pop(0)\n", + " Westernlist = WesternTeam2[Wes]\n", + " Eas = Westernlist.pop(0)\n", + " competitor = matched.get(Eas)\n", + " if not competitor:\n", + " # E's free\n", + " matched[Eas] = Wes\n", + " print(\" %s and %s\" % (Wes, Eas))\n", + " else:\n", + " Easternlist = EasternTeam2[Eas]\n", + " if Easternlist.index(competitor) > Easternlist.index(Wes):\n", + " matched[Eas] = Wes\n", + " print(\" %s dumped %s for %s\" % (Eas, competitor, Wes))\n", + " if WesternTeam2[competitor]:\n", + " \n", + " Westernfree.append(competitor)\n", + " else:\n", + " if Westernlist:\n", + " Westernfree.append(Wes)\n", + " return matched\n", + "\n", + "\n", + "print('\\nMatch:')\n", + "matched = matchmaker()\n", + "\n", + "print('\\nPairs:')\n", + "print(' ' + ',\\n '.join('%s is matched to %s' % couple\n", + " for couple in sorted(matched.items())))\n", + "print()\n", + "print('Match stability check PASSED'\n", + " if check(matched) else 'Match stability check FAILED')\n", + "print(\"--- %s seconds ---\" % (round(time.time() - start_time, 10)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa5c5e8b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Weiyu_Wang_002746483/Assignment_1.ipynb b/Submissions/Weiyu_Wang_002746483/Assignment_1.ipynb new file mode 100644 index 0000000..0ae214f --- /dev/null +++ b/Submissions/Weiyu_Wang_002746483/Assignment_1.ipynb @@ -0,0 +1,259 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "480bd430", + "metadata": {}, + "outputs": [], + "source": [ + "# Assignment_1\n", + "# 1.Arrange the following functions in increasing order of growth:\n", + "\n", + "# 2^n\n", + "# n^(2*log(n))\n", + "# 3^(log(n))\n", + "# n!\n", + "# log(n^2)\n", + "# 1000n^2\n", + "# √n * log(n)\n", + "# n^(log(log(n)))\n", + "# 2^(2^n)\n", + "# n^3\n", + "\n", + "# Answer:\n", + "# log(n^2) (O(log n))\n", + "# √n * log(n) (O(√n * log n))\n", + "# n^(log(log(n))) (O(n^(log(log n))))\n", + "# n^3 (O(n^3))\n", + "# 1000n^2 (O(n^2))\n", + "# 3^(log(n)) (O(3^log n))\n", + "# n^(2log(n)) (O(n^(2log n)))\n", + "# 2^n (O(2^n))\n", + "# 2^(2^n) (O(4^n))\n", + "# n! (O(n!))\n", + "\n", + "# 2. Assume that you have function f and g such that f(n) is O(g(n)). For each of the following statements decide whether it is true or false and give a proof or counter example.\n", + "# log f(n) = O(log g(n))\n", + "# 2^f(n) is O(2^g(n))\n", + "# f(n) = Ω(g(n))\n", + "\n", + "# Answer：\n", + "# Counter proof: If f(n) = 2 then Big o is O(1) and g(n) = 1. log f(n) = 1, log g(n) = 0.\n", + "# Counter proof: If f(n) = 2n then Big O is O(n) and g(n) = n. 2^2n > c*2^n when n go to infinity. Suppose c = 5 when n = 2, 2^2n < c*2^n.\n", + "# If f(n) is O(g(n)), it means that f(n) grows at a slower rate than or equal to g(n). If g(n) = Ω(f(n)), it implies that g(n) grows at a lower bound that is at least as fast as f(n). If f(n) = n^2, and g(n) = n, then f(n) is O(g(n)), and g(n) is Ω(f(n)), because g(n) grows at a lower bound of n^2, which is at least as fast as f(n).\n", + "\n", + "# 3. Imagine a situation in a school where there are \"n\" students and \"m\" available projects, each with its own set of requirements and preferences. The students are interested in participating in these projects, but there are different constraints:\n", + "\n", + "# Each project has a limited number of available slots, and some projects can accommodate more students than others.\n", + "# Each student has a ranking of their preferred projects based on personal interests and skills.\n", + "# Each project also has a ranking of students based on their suitability and qualifications.\n", + "# Our goal is to find a stable assignment of students to projects while ensuring that each project's capacity is not exceeded. The assignment is considered stable if none of the following situations arises:\n", + "\n", + "# There are students S1 and S2 and project P, where:\n", + "\n", + "# S1 is assigned to P.\n", + "# S2 is unassigned.\n", + "# P prefers S2 to S1 based on qualifications and skills.\n", + "# There are students S1 and S2 and projects P1 and P2, where:\n", + "\n", + "# S1 is assigned to P1.\n", + "# S2 is assigned to P2.\n", + "# P1 prefers S2 to S1.\n", + "# S2 prefers P1 to P2.\n", + "# Formulate this as a stable matching problem with capacity constraints.\n", + "# Prove that there is always a stable assignment possible in this scenario.\n", + "# Devise an algorithm to find a stable assignment while respecting project capacity constraints.\n", + "\n", + "# Answer:\n", + "# While some project m have p available positions\n", + "# It is assumed that all students have completed the application.\n", + "# Project m ranks students according to their suitability and qualifications.\n", + "\n", + "# for(offer to students according to their ranking){\n", + "# if(project m have available positions x, x > 0){\n", + "# sent offer to the next student on ranking;\n", + "# If (student is free){\n", + "# student will accept project m offer;\n", + "# \t x - 1; \n", + "# }else(assume another project m1){\n", + "# if(student prefer m){\n", + "# student will accept project m offer;\n", + "# \t x - 1;\n", + "# number of avaliable positions at m1 + 1;\n", + "# }else{\n", + "# student will accept project m1 offer;\n", + "\t \n", + "# }\n", + "# }\n", + "# }\n", + "# }\n", + "\n", + "\n", + "# 4. You have two algorithms for solving a specific problem. Algorithm A requires 5n^2 microseconds to run, and Algorithm B requires 3n*log2(n) microseconds to run.\n", + "# Which one is asymptotically faster? What is the cross-over value of n?\n", + "\n", + "# Answer:\n", + "\n", + "# Algorithm A is quadratic (O(n^2)), and Algorithm B is linearithmic (O(nlog(n))). In terms of asymptotic performance, Algorithm B (O(nlog(n))) is faster than Algorithm A (O(n^2)) because the logarithmic term grows more slowly than the quadratic term as \"n\" increases. When n > 11.498, Algorithm A is faster.\n", + "\n", + "# 5. You are tasked with constructing a staircase using blocks, where each step consists of a series of blocks placed on top of each other. The number of blocks used in each step follows a pattern: the total number of blocks in each step is the sum of the number of blocks used in the previous step and the current step. However, there is a constraint: the total number of blocks used in each step is bounded by a constant \"c,\" and you need to build the staircase with a maximum of \"n\" blocks.\n", + "\n", + "# Your goal is to devise a way to construct this staircase using blocks of the smallest possible size, represented by a function \"f(n)\" that grows as slowly as possible while satisfying the constraints.\n", + "\n", + "# Please explain how you would construct the staircase and determine the function \"f(n)\" for the size of the blocks to achieve this goal.\n", + "\n", + "# Answer\n", + "# Start with an initial step that contains 1 block. In each subsequent step, add the same number of blocks as the previous two steps combined. This follows the Fibonacci sequence.\n", + "# The initial step has 1 block, so f(1) = 1.\n", + "# The second step has 1 block as well, so f(2) = 1.\n", + "# The third step has 2 blocks, so f(3) = 2.\n", + "# The fourth step has 3 blocks, so f(4) = 3.\n", + "# The fifth step has 5 blocks, so f(5) = 5.\n", + "# The n step has f(n-1) + f(n-2) blocks, so f(n) = f(n-1) + f(n-2)\n", + "# The Fibonacci sequence grows slowly, and it ensures that each step of the staircase doesn't exceed \"c\" blocks, and the total number of blocks used doesn't exceed \"n.\"\n", + "\n", + "# 6. You have two sorting algorithms for sorting a list of numbers. Algorithm A takes n^2 seconds to sort n numbers, while Algorithm B takes n log2(n) seconds to sort n numbers.\n", + "# Determine which sorting algorithm grows asymptotically faster.\n", + "# Calculate the cross-over value of \"n\".\n", + "\n", + "# Answer:\n", + "# Algorithm A is n^2, Big O is O(n^2). Algorithm B is n log2(n), Big O is O(nlogn).\n", + "# Algorithm B grows asymptotically faster than Algorithm A, This is because the growth rate of n log2(n) is slower than n^2 for large values of n. The cross over value is approximately 16.61, that means when n is greater than approximately 16.61, Algorithm A becomes faster than Algorithm B, and when n is less than approximately 16.61, Algorithm B is faster.\n", + "\n", + "# 7. In a stable matching problem using the Gale-Shapley algorithm, there are two groups: Group \"H\" (hospitals) and Group \"D\" (doctors). Each hospital ranks doctors based on their preferences, and each doctor ranks hospitals based on their preferences. The algorithm proceeds as follows:\n", + "\n", + "# Hospitals propose to their most preferred doctors.\n", + "# Doctors accept or reject proposals based on their preferences.\n", + "# If a doctor rejects a hospital's proposal, the hospital moves to its next preferred doctor.\n", + "# The algorithm continues until all doctors are matched.\n", + "# Assuming a scenario in which there is one specific hospital \"H1\" that is ranked first by every doctor, and \"H1\" ranks every doctor first as well, analyze the following:\n", + "\n", + "# Will \"H1\" always end up with its most preferred doctors in every stable matching?\n", + "# Provide an innovative explanation and an example to support your answer for part (1).\n", + "\n", + "# Answer:\n", + "# No, \"H1\" will not always end up with its most preferred doctors in every stable matching.\n", + "# Consider a scenario with three hospitals (H1, H2, H3) and three doctors (D1, D2, D3).\n", + "# Hospital \"H1\" is ranked first by all doctors.\n", + "# Hospital \"H2\" is ranked second by all doctors.\n", + "# Hospital \"H3\" is ranked last by all doctors.\n", + "\n", + "# For the Doctors' preferences:\n", + "# D1: H1 > H2 > H3\n", + "# D2: H1 > H2 > H3\n", + "# D3: H1 > H2 > H3\n", + "\n", + "# In the first round of proposals, \"H1\" proposes to D1, D2, and D3. All doctors accept because \"H1\" is their top choice. \"H2\" and \"H3\" remain unmatched.\n", + "# The stable matching is (H1, D1), (H2, D2), and (H3, D3).\n", + "# In this match, H1 only matches once to get the most matched doctor, and the reason is that while \"H1\" is the top choice for all doctors, doctors D2 and D3 had already accepted proposals from \"H2\" and \"H3,\" respectively, before \"H1\" had a chance to propose to them. Although \"H1\" is the top choice for all doctors, due to the dynamic nature of the Gale-Shapley algorithm and the suggested timing, it may not get all the favorite doctors in every stable match.\n", + "\n", + "# 8. Two rival Chess clubs, Club A and Club B, are competing in a Chess tournament. Each club has a roster of chess players, and each player has a skill rating. The clubs want to create strategies (assignments of players to matches) to maximize their chances of winning the tournament. However, they need to ensure that their strategies are stable, meaning that neither club can unilaterally change its strategy to win more matches.\n", + "\n", + "# The rules are as follows:\n", + "\n", + "# Each player can be assigned to only one match.\n", + "# A club wins a match if its player has a higher skill rating than the opposing club's player.\n", + "# Clubs aim to maximize the number of matches they win.\n", + "# Is there always a stable pair of strategies (assignments of players to matches) for both clubs in such a chess tournament? Explain why or why not.\n", + "\n", + "# Answer:\n", + "# There isn't always a stable pair of strategies for both clubs in such a chess tournament.\n", + "# Suppose Club A has two players, {A1, A2}, with ratings 1800 and 2000, and Club B has two players, {B1, B2}, with ratings 1900 and 2100.\n", + "# If Club A pairs A1 against B1 and A2 against B2, Club B would prefer to switch its strategy to pair B1 against A2 and B2 against A1. This change would result in Club B winning both matches instead of just one. \n", + "# Conversely, if Club A pairs A1 against B2 and A2 against B1, Club A would prefer to switch its strategy to pair A1 against B1 and A2 against B2 to win both matches.\n", + "# In both cases, one of the clubs can unilaterally change its strategy to win more games, thus making the pair's strategy unstable. The stability of pairings depends on the specific player rating, and it is possible for one club to have an advantage first, while the other club can strategically adjust its pairings to gain an advantage. Therefore, there is not always a stable pair of strategies in such a chess tournament.\n", + "\n", + "# 9.The NHL (National Hockey League) is considering a change to its playoff format, and they want to use the Gale-Shapley matching algorithm to determine the matchups. Currently, teams from the Eastern Conference play each other, and teams from the Western Conference play each other in the playoffs. However, they are now planning to have a cross-conference playoff format, where the top eight teams from the Eastern Conference will be matched against the top eight teams from the Western Conference using the Gale-Shapley matching algorithm.\n", + "\n", + "# A. Modify an existing Gale-Shapley implementation in Python so that the top eight Eastern Conference teams will be matched against the top eight Western Conference teams. You can create preference lists for each team based on their performance in the regular season.\"\n", + "\n", + "# Instructions:\n", + "\n", + "# Create preference lists for the top eight Eastern Conference teams and the top eight Western Conference teams based on their regular season performance.\n", + "# Modify the Gale-Shapley algorithm to accommodate this new preference structure.\n", + "# Execute the algorithm to determine the cross-conference playoff matchups.\n", + "\n", + "# Answer：\n", + "# File name on github: Assignmen1_Q9_A\n", + "\n", + "# B.Use a loop to shuffle the preference lists for each team 1000 times. Calculate the percentage of stable playoff matches. See the function random.shuffle(x[, random])\n", + "\n", + "# Answer:\n", + "# File name on github: Assignmen1_Q9_B\n", + "\n", + "# C.Randomly assume certain teams win and lose each round and eliminate the losers from the preference lists for each team. Can the Gale-Shapley matching algorithm be applied over and over in each round (16 teams, 8 teams, 4 teams, 2 teams) to create stable matches?\n", + "\n", + "# Answer:\n", + "# The Gale-Shapley matching algorithm is designed to produce stable matches when applied to a list of preferences, where each participant has a one-time opportunity to propose and accept/reject a match. It does not apply if the match changes dynamically over multiple rounds or if participants are eliminated. As teams are eliminated, team preferences change dynamically, and there is no straightforward way to maintain a stable match. Therefore, we need to update the number of teams in each round, so that the algorithm can find more stable matching scenes in the one-time matching process.\n", + "\n", + "# D. Now combine the lists so that any team can be matched against any other irrespective of conference.\n", + "# Can the Gale-Shapley matching algorithm still create stable matches? (With just one list matching against itself?)\n", + " \n", + "# Answer:\n", + "# If you combine the preference lists of all teams into a single list, allowing any team to be matched against any other team irrespective of conference, and then apply the Gale-Shapley algorithm to create stable matches, it may not always guarantee stable matches.\n", + "# The stability of the game depends on the specific preferences of the team in the new environment. If there is an unstable loop of teams' preferences, meaning that teams can prefer each other in a circular fashion, the algorithm may not be able to find a stable match. The stability of the Gale-Shapley algorithm is based on the idea that if there is a blocking pair (team and opponent) and both players like each other more than the current match, then the current match is unstable. In a combinatorial list scenario, if such blocking pairs exist, the algorithm may not converge to a stable match because there may not be a stable match to begin with.\n", + "\n", + "# E. Double the size of the lists in problem A several times (you can make up team names like team1, team2, etc.) and measure the amount of time it takes to create stable matches. How fast does the execution time grow in relation to the size of the lists?\n", + "\n", + "# Answer:\n", + "# File name on github: Assignmen1_Q9_E\n", + "\n", + "# Summary：\n", + "# Chatgpt provides programming advice and code examples: ChatGPT can generate Python code examples to help solve specific programming problems, such as modifying the Gale-Shapley algorithm to accommodate different tournament rankings.\n", + "\n", + "# Explaining algorithms and concepts: It is able to explain how Gale-Shapley algorithms work, stability concepts, and how they can be applied to different scenarios, which helps to better understand and adapt algorithms to meet needs.\n", + "\n", + "# Provide insight into randomness and loop problems: For randomness and loop problems in problem design, it can provide advice on how to deal with these challenges to ensure that stable matching results are generated.\n", + "\n", + "# In facing this task, I faced the following challenges:\n", + "\n", + "# The complexity of the problem: Designing a stable, on-demand matching algorithm involves deep knowledge of computer science, including areas such as algorithm design and graph theory.\n", + "\n", + "# Randomness handling: When dealing with randomness and loop problems, careful thought and testing is required to ensure that the generated matching results do not lead to unstable situations.\n", + "\n", + "# In the field of algorithm (Gale-Shapley algorithm), I have learned the following knowledge of problem design:\n", + "\n", + "# Stable matching theory: Understand the concept and conditions of stable matching, and how to apply Gale-Shapley algorithm to solve such problems.\n", + "\n", + "# Dynamic of the algorithm: The Gale-Shapley algorithm is a static algorithm for one-time matching. But in dynamic environments, such as multi-round elimination matches in a tournament, different algorithms and strategies need to be considered to handle the matching of each round.\n", + "\n", + "# Randomness and stochastic algorithms: When dealing with randomness and stochastic algorithms, you need to consider how to design the algorithm to deal with possible randomness cases, and how to conduct randomness tests to verify the stability of the algorithm.\n", + "\n", + "# In general, this task not only tests algorithm design and programming skills, but also involves problem design knowledge in dealing with randomness and dynamics. ChatGPT and similar tools provide valuable support in providing guidance and insights.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Weiyu_Wang_002746483/readme.md b/Submissions/Weiyu_Wang_002746483/readme.md new file mode 100644 index 0000000..1059f55 --- /dev/null +++ b/Submissions/Weiyu_Wang_002746483/readme.md @@ -0,0 +1,6 @@ +First Name: "Weiyu" +Last Name : "Wang" +NU_ID : "002746483" + +Assignment-1 : "Summary of assignment 1" + diff --git a/Submissions/Yuxuan_Zhang_002778556/README.md b/Submissions/Yuxuan_Zhang_002778556/README.md new file mode 100644 index 0000000..f046237 --- /dev/null +++ b/Submissions/Yuxuan_Zhang_002778556/README.md @@ -0,0 +1,17 @@ +# Assignment-1 +[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme) +## Install +This project uses anaconda and python. Go check them out if you don't have them locally installed. +## Usage +This is a jupyter notebook, please use anaconda to open it. +## Description +This are some algorithms problems. +## Project structure +- Yuxuan_Zhang_002778556 +- YuxuanZhang_Assignment1.ipynb +- Assignment1_README.md +## Contributor & Maintainer +name: Yuxuan Zhang +Email: zhang.yuxuan5@northeastern.edu +NUID: 002778556 +github username: lucaszhang98 \ No newline at end of file diff --git a/Submissions/Yuxuan_Zhang_002778556/YuxuanZhang_Assignment1.ipynb b/Submissions/Yuxuan_Zhang_002778556/YuxuanZhang_Assignment1.ipynb new file mode 100644 index 0000000..91a8e94 --- /dev/null +++ b/Submissions/Yuxuan_Zhang_002778556/YuxuanZhang_Assignment1.ipynb @@ -0,0 +1,855 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1837d7b9", + "metadata": {}, + "source": [ + "# INFO 6205 - Program Structure and Algorithms\n", + "# Worked Assignment 1 Solutions\n", + "### student Name: Yuxuan Zhang\n", + "### Professor: Nik Bear Brown\n", + "### Date: 20/09/2023" + ] + }, + { + "cell_type": "markdown", + "id": "62dcd8ed", + "metadata": {}, + "source": [ + "\n", + "Q1(10Points) \n", + "Arrange the following functions in increasing order of growth: \n", + "1. $2^n$\n", + "2. $log_2(n^2)$\n", + "3. $5n^2 + 4n$\n", + "4. $n \\cdot \\log_2(n)$\n", + "5. $\\log_2(\\log_2(n))$\n", + "6. $n^3$\n", + "7. $3^n$\n", + "8. $10n$\n", + "9. $(\\log_2(n))^2$\n", + "10. $n!$" + ] + }, + { + "cell_type": "markdown", + "id": "533d8323", + "metadata": {}, + "source": [ + "Solution:\n", + "\n", + "1. $2^n$:\n", + " Exponential growth, which is rapid. For our set, this is outpaced only by the factorial function.\n", + "\n", + "2. $log_2(n^2)$:\n", + " Using logarithm properties, this becomes $2 \\log_2(n)$. This is still a logarithmic function, so it has a growth rate of $O(\\log(n))$.\n", + "\n", + "3. $5n^2 + 4n$:\n", + " A polynomial function where the dominant term is $n^2$. So, its growth rate is $O(n^2)$.\n", + "\n", + "4. $n \\cdot log_2(n)$:\n", + " This is a logarithmic-linear function, or commonly known as $O(n \\log n)$, which grows faster than linear functions but slower than quadratic functions.\n", + "\n", + "5. $log_2(\\log_2(n))$:\n", + " This is even slower-growing than a regular logarithm.\n", + "\n", + "6. $n^3$:\n", + " A cubic polynomial, so its growth rate is $O(n^3)$.\n", + "\n", + "7. $3^n$:\n", + " Another exponential function but with a base larger than the first. This grows faster than $2^n$ but slower than $n!$.\n", + "\n", + "8. $10n$:\n", + " A linear function with a growth rate of $O(n)$.\n", + "\n", + "9. $(\\log_2(n))^2$:\n", + " Logarithm squared, meaning it grows faster than a simple logarithm but much slower than any polynomial of degree 1 or higher.\n", + "\n", + "10. $n!$:\n", + " Factorial growth, which outpaces all the other functions in the list for sufficiently large $n$.\n", + "\n", + "Given the analysis, the functions in increasing order of growth are:\n", + "\n", + "1. $log_2(\\log_2(n))$\n", + "2. $log_2(n^2) $\n", + "3. $(\\log_2(n))^2$\n", + "4. $10n$\n", + "5. $n \\cdot log_2(n)$\n", + "6. $5n^2 + 4n$\n", + "7. $n^3$\n", + "8. $2^n$\n", + "9. $3^n$\n", + "10. $n!$\n", + "\n", + "So, as $n$ goes to infinity, $n!$ grows the fastest while $log_2(\\log_2(n))$ grows the slowest." + ] + }, + { + "cell_type": "markdown", + "id": "59ee0a27", + "metadata": {}, + "source": [ + "\n", + "Q2(10Points) \n", + "Assume that you have functions $h$ and $k$ such that $h(n) = O(k(n))$. For each of the following statements, decide whether it is true or false and provide a proof or counterexample:\n", + "\n", + "1. $h(2n) = O(k(n))$\n", + "2. $h(n^2) = O(k(2n))$\n", + "3. If $h(n) = O(k(n))$, does it imply $k(n^3) = \\Omega(h(n^2))$?\n", + "4. $h(n) + k(n) = O(h(n) \\cdot k(n))$\n", + "5. $h(n) \\cdot k(n) = O(h(n) + k(n))$\n", + "\n", + "Evaluate the truthiness of each of the above statements and provide reasoning or examples." + ] + }, + { + "cell_type": "markdown", + "id": "823c4fe6", + "metadata": {}, + "source": [ + "\n", + "Solution:\n", + "1. $h(2n) = O(k(n))$\n", + "\n", + "**Claim:** False.\n", + "\n", + "**Counterexample:** \n", + "Consider $h(n) = n$ and $k(n) = n$. Clearly, $h(n) = O(k(n))$. However, $h(2n) = 2n$, which is not $O(n)$. Therefore, the claim is false.\n", + "\n", + "2. $h(n^2) = O(k(2n))$\n", + "\n", + "**Claim:** False.\n", + "\n", + "**Counterexample:** \n", + "Consider $h(n) = 2^n$ and $k(n) = n$. While $h(n) = O(2^n)$, $h(n^2) = 2^{n^2}$ clearly grows much faster than $k(2n) = 2n$, and thus cannot be bounded by it. Hence, the claim is false.\n", + "\n", + "3. If $h(n) = O(k(n))$, does it imply $k(n^3) = \\Omega(h(n^2))$?\n", + "\n", + "**Claim:** False.\n", + "\n", + "**Counterexample:** \n", + "Let's use $h(n) = n^2$ and $k(n) = n^3$. While $h(n) = O(k(n))$, $k(n^3) = n^9$, which is not bounded below by a constant multiple of $h(n^2) = n^4$. Therefore, the statement is false.\n", + "\n", + "4. $h(n) + k(n) = O(h(n) \\cdot k(n))$\n", + "\n", + "**Claim:** True.\n", + "\n", + "**Proof:** \n", + "Given $h(n) = O(k(n))$, there exist constants $c$ and $n_0$ such that $0 \\leq h(n) \\leq c \\cdot k(n)$ for all $n > n_0$. \n", + "Now, $h(n) + k(n) \\leq c \\cdot k(n) + k(n) = (c+1) \\cdot k(n)$. Clearly, $h(n) \\cdot k(n)$ will grow faster than this, so the claim is true. \n", + "\n", + "5. $h(n) \\cdot k(n) = O(h(n) + k(n))$\n", + "\n", + "**Claim:** False.\n", + "\n", + "**Counterexample:** \n", + "Consider $h(n) = n$ and $k(n) = n$. Then $h(n) \\cdot k(n) = n^2$, while $h(n) + k(n) = 2n$. Clearly, $n^2$ cannot be bounded by a constant multiple of $2n$. Therefore, the statement is false.\n", + "\n", + "These solutions provide a basis for understanding the relationships between these functions in big O notation and showcase the importance of choosing functions carefully when evaluating growth rates." + ] + }, + { + "cell_type": "markdown", + "id": "72689502", + "metadata": {}, + "source": [ + "Q3(10Points) \n", + "Suppose in a university, there are $ y $ distinct research projects, each having a specified number of positions for graduate students. There are $ m $ graduate students, each looking to join a research project. We will assume that there are more research projects than the total positions available across all projects.\n", + "\n", + "Each research project has a ranking for students based on their prior work, academic achievements, and research interests. Similarly, each student has a ranking for the research projects based on the project's relevance to their interests, the prominence of the principal investigator, and potential career benefits.\n", + "\n", + "The goal is to assign each student to at most one research project, ensuring all positions in a project are filled. There might be some projects without any students due to the constraints.\n", + "\n", + "A pairing is considered stable if:\n", + "\n", + "1. No student $ s_1 $ is matched to a project $ p $ while another student $ s_2 $ is unmatched, and project $ p $ prefers $ s_2 $ over $ s_1 $.\n", + "2. No students $ s_1 $ and $ s_2 $ are matched to projects $ p_1 $ and $ p_2 $ respectively, such that:\n", + " - $ s_1 $ prefers $ p_2 $ over $ p_1 $, and\n", + " - $ p_2 $ prefers $ s_1 $ over $ s_2 $.\n", + "\n", + "Under these circumstances:\n", + "\n", + "1. Can you prove that a stable assignment of students to research projects always exists?\n", + "2. Propose an algorithm to find one such stable assignment." + ] + }, + { + "cell_type": "markdown", + "id": "e755e5ae", + "metadata": {}, + "source": [ + "Solution: \n", + " \n", + "\n", + "**Proof of Existence:**\n", + "\n", + "We can show the existence of a stable assignment by demonstrating that the Gale-Shapley algorithm will always terminate and will result in a stable assignment:\n", + "\n", + "1. Every iteration of the algorithm reduces the number of unmatched students (unless they've proposed to all projects).\n", + "2. The algorithm ends when every student is matched or has proposed to every project.\n", + "3. By the end, no project has an unfilled slot because, before moving on to a less preferred student, every student will propose to every project.\n", + "\n", + "**Gale-Shapley Algorithm for University Research Projects:**\n", + "\n", + "1. Initially, all students are unmatched and all research projects have their full capacities available.\n", + "2. Each student proposes to their top-choice research project.\n", + "3. Research projects, on receiving proposals:\n", + " - If the project hasn't reached its capacity, it temporarily accepts the student.\n", + " - If the project has reached its capacity but prefers the new student over one it has already accepted, it rejects the least-preferred student and temporarily accepts the new student. The rejected student becomes unmatched.\n", + " - If the project has reached its capacity and does not prefer the new student over any of its current students, it rejects the new student.\n", + "4. Unmatched students propose to their next-choice projects.\n", + "5. Continue the process until every student has either been accepted by a project or has been rejected by all projects.\n", + "\n", + "**Proof of Stability:**\n", + "\n", + "- For any student $ s_1 $ matched to project $ p_1 $, there cannot be another student $ s_2 $ not matched to any project that $ p_1 $ prefers over $ s_1 $, because if that were the case, $ p_1 $ would have accepted $s_2 $ before $ s_1 $.\n", + " \n", + "- For any student $ s_1 $ matched to project $ p_1 $ and any student $ s_2 $ matched to project $ p_2 $, where $ s_2 $ prefers $ p_1 $ over $ p_2 $ and $ p_1 $ prefers $ s_2 $ over $ s_1 $, this situation is impossible. This is because $ s_2 $ would have proposed to $ p_1 $ before proposing to $ p_2 $. If $ p_1$ preferred $ s_2 $ over its least-preferred student at that time, it would have accepted $s_2 $ and not $ s_1$, contradicting our assumption.\n", + "\n", + "This ensures that the final matching is stable." + ] + }, + { + "cell_type": "markdown", + "id": "62d57c23", + "metadata": {}, + "source": [ + "Q4(10Points) \n", + "\n", + "Consider two different algorithms:\n", + "\n", + "One algorithm takes $log_2(4n)$ milliseconds, and another algorithm takes $2n$ milliseconds. \n", + "\n", + "1. Which algorithm is asymptotically faster?\n", + "2. Determine the cross-over value of $n$ where the two algorithms take the same amount of time. \n" + ] + }, + { + "cell_type": "markdown", + "id": "5d934483", + "metadata": {}, + "source": [ + " Solution: \n", + " \n", + "The second algorithm is asymptotically faster than the first one. \n", + "The order of growth of $log_2(4n)$ is less than the order of growth of $2n$. \n", + "Crossover point of $n$ are $1$ and $1/2$." + ] + }, + { + "cell_type": "markdown", + "id": "663f4d61", + "metadata": {}, + "source": [ + "Q5(10Points) \n", + "\n", + "A tower is constructed by stacking cylindrical drums. The total height of drums in each level is the summation of the height of drums in the current level and the level below. We are in the process of constructing the tower with these drums. An asymptotic analysis can be applied here.\n", + "\n", + "Assume that:\n", + "1. Each level of the tower can hold drums with a combined height of at most a constant $d$.\n", + "2. The entire tower will be constructed with drums having a total height of at most $h$.\n", + "\n", + "Given the constraints, how can you design the tower such that the drums have a height $g(h)$, where $g(h)$ is a function that grows as slowly as possible? Describe the function $g(h)$ and explain the construction process." + ] + }, + { + "cell_type": "markdown", + "id": "6e59e0b2", + "metadata": {}, + "source": [ + " Solution: \n", + "\n", + "1. **Tower Construction**:\n", + " - The tower is built level by level.\n", + " - If we denote the height of drums at level $i$ as $D_i$, then the relationship is $D_i = D_{i-1} + D_{i-2}$.\n", + " - The beginning levels (initial conditions) can be set as $D_1 = 1$ and $D_2 = 1$, based on the Fibonacci sequence logic.\n", + "\n", + "2. **Space Requirement**:\n", + " - For each level, the height occupied by the drums is limited by the constant $d$.\n", + " - The total height occupied by all levels together cannot exceed $h$.\n", + " - The height occupied by all the drums for the tower is $D_1 + D_2 + ... + D_R \\leq h$, where $R$ is the number of levels.\n", + "\n", + "3. **Relating Total Height to Levels**:\n", + " - Given the relationship based on the Fibonacci-like sequence, the total height can be expressed as the sum of the first $R$ elements of a modified Fibonacci sequence, which is $\\frac{R(R+1)}{2}$. \n", + " - From this, we get the relationship: $\\frac{1}{2} R(R+1) \\leq h$.\n", + " - Solving for $R$, we deduce: $R \\leq \\sqrt{2h}$.\n", + "\n", + "4. **Function $g(h)$**:\n", + " - Using the relationship derived above, the height of drums at any level based on the maximum height $h$ is given by: $g(h) \\leq d + d\\sqrt{2h}$.\n", + " - Therefore, the height function $g(h)$ grows as $O(\\sqrt{h})$.\n", + "\n", + "### Construction Process:\n", + "\n", + "1. Begin with drums of height 1 for the first level.\n", + "2. Use drums of height 1 for the second level.\n", + "3. For each subsequent level, stack drums such that their combined height is the sum of the heights from the two previous levels, ensuring it doesn’t exceed $d$ or the total $h$.\n", + "4. Continue this process until the combined height of all drums reaches $h$." + ] + }, + { + "cell_type": "markdown", + "id": "497749c5", + "metadata": {}, + "source": [ + "Q6(5Points) \n", + " \n", + "One algorithm requires $ \\log_3(6n) $ milliseconds and another algorithm requires $ 1/2n $ milliseconds. Which one grows asymptotically faster? That is, which grows faster as $ n $ gets large? What is the cross-over value of $ n $? " + ] + }, + { + "cell_type": "markdown", + "id": "f0e5d59f", + "metadata": {}, + "source": [ + " Solution: \n", + " \n", + "The second algorithm is asymptotically faster than the first one. \n", + "The order of growth of $log_3(6n)$ is less than the order of growth of $1/2n $. \n", + "Crossover point of $n$ are $6.73375$ and $0.18443$." + ] + }, + { + "cell_type": "markdown", + "id": "f570f8ed", + "metadata": {}, + "source": [ + "Q7(10Points) \n", + "\n", + "Consider an instance of the Stable Marriage problem in which there exists a man $ M $ and a woman $ W $ such that man $ M $ has woman $ W $ as his top-ranked choice and woman $ W $ has man $ M $ as her top-ranked choice. In other words, they each prefer each other over anyone else. Then, for every stable marriage set $ S $ for this instance, the pair $ (M, W) $ belongs to $ S $.\n", + "\n", + "• Is the above statement True or False? \n", + "• If the statement is true, provide a brief explanation. If false, offer a counterexample." + ] + }, + { + "cell_type": "markdown", + "id": "3599dcd9", + "metadata": {}, + "source": [ + " Solution: \n", + " \n", + "The statement is True.\n", + "\n", + "Suppose, for the sake of contradiction, that there exists a stable marriage set $ S $ in which $ M $ and $ W $ are not paired together. \n", + "\n", + "Let's say in set $ S $:\n", + "1. $ M $ is paired with some woman $ W' $.\n", + "2. $ W $ is paired with some man $ M' $.\n", + "\n", + "Given our initial setup:\n", + "1. $ W $ would prefer $ M $ over $ M' $ since $ M $ is $ W $'s top choice.\n", + "2. $ M $ would prefer $ W $ over $ W' $ since $ W $ is $ M $'s top choice.\n", + "\n", + "This introduces an instability in the set $ S $ because both $ M $ and $ W $ would rather be with each other than with their current partners. Thus, our assumption that $ S $ is a stable set where $ M $ and $ W $ are not paired together contradicts the definition of stability.\n", + "\n", + "Therefore, for every stable marriage set $ S $ for this instance, the pair $ (M, W) $ must belong to $ S $." + ] + }, + { + "cell_type": "markdown", + "id": "185b196e", + "metadata": {}, + "source": [ + "Q8(10Points) \n", + " \n", + "Consider two renowned basketball leagues: the EuroLeague (Europe's premier club basketball competition) and the NBA (North America's premier professional basketball league). Both leagues wish to hold an exhibition series of matches to foster intercontinental basketball relations. They want to decide the matchups in a way that maximizes the excitement and competition. \n", + "\n", + "Each league has top teams, and every team has a set of star players. Let's consider the star players as $ p $ and their roles in the team (like point guard, shooting guard, etc.) as $ q $. Understandably, some players excel in multiple roles. The performance of a team in these exhibition matches depends solely on the performance of these star players in their assigned roles. \n", + "\n", + "Every player has a unique rating for every role they can play, derived from their stats over the last season. For simplicity, assume there's no tie in ratings. A team wins a match if the total rating of its assigned players in their respective roles surpasses that of the opposing team. Both leagues aim to win the most matches in the series to gain intercontinental supremacy.\n", + "\n", + "In the initial matches, EuroLeague teams reveal strategy $ E $ while the NBA teams reveal strategy $ N $. Based on these strategies, the teams win a certain number of games. A strategy pair $ (E, N) $ is deemed stable if no team from either league can adjust its strategy unilaterally to win more games. This implies there's no strategy $ E' $ such that a EuroLeague team wins more games with $ (E', N) $, and likewise, there's no strategy $ N' $ such that an NBA team wins more games with $ (E, N') $.\n", + "\n", + "Given the players and their ratings for each role:\n", + "- Is there always a stable pair of strategies for every given set of player ratings?\n", + "- Address this question by:\n", + " - Proposing an algorithm that determines a stable pair of strategies considering any set of players and their ratings.\n", + " OR\n", + " - Presenting an example of a set of players and ratings for which there's no stable pair of strategies." + ] + }, + { + "cell_type": "markdown", + "id": "0edab915", + "metadata": {}, + "source": [ + " Solution: \n", + "\n", + "1. **Initialize**: Each team is free and hasn't proposed to any team.\n", + "\n", + "2. **Proposal**: Each EuroLeague team proposes to the NBA team it has the highest winning chance against, based on its current strategy.\n", + "\n", + "3. **Rejection/Match**: \n", + " - If the NBA team is free, it accepts the proposal if it doesn't have a better match (a team it can beat with a higher margin).\n", + " - If the NBA team is already matched with another EuroLeague team but now has a proposal from a EuroLeague team it can beat with a bigger margin, it will reject its current match and accept the new proposal.\n", + "\n", + "4. **Termination**: The algorithm terminates when every EuroLeague team is matched with an NBA team.\n", + "\n", + "Analysis:\n", + "\n", + "This solution guarantees a stable pair of strategies for both leagues:\n", + "\n", + "- No EuroLeague team can unilaterally change its strategy to get a better match since it already proposed to the teams in decreasing order of preference. If it's matched with an NBA team, it means the EuroLeague team couldn't win against higher-ranked NBA teams based on the ratings and roles of players.\n", + "\n", + "- No NBA team would want to change its strategy as it accepted the best available proposal from a EuroLeague team that it can win against.\n", + "\n", + "Thus, the pair of strategies will be stable." + ] + }, + { + "cell_type": "markdown", + "id": "b8a48cc6", + "metadata": {}, + "source": [ + "Q9(25Points): Coding Problem \n", + " \n", + "The UEFA Champions League is innovating its group stage format using the Gale-Shapley matching algorithm. Instead of teams from the same league potentially facing each other, the top eight teams from the English Premier League (EPL) will be matched against the top eight teams from La Liga using the Gale-Shapley matching algorithm. Additionally, online polls will be used to gather feedback from fans, analysts, players, and managers to rank which teams they'd prefer their favorite teams to compete against.\n", + "\n", + "A. Adapt an existing Gale-Shapley implementation in python to match the eight EPL teams against the eight La Liga teams. Design your preference lists for each team based on hypothetical data." + ] + }, + { + "cell_type": "markdown", + "id": "007bc680", + "metadata": {}, + "source": [ + " Solution: \n", + " \n", + "Let's first set up a hypothetical scenario for our teams and their preferences:\n", + "\n", + "EPL Teams:\n", + "\n", + "1. Manchester United (MU)\n", + "2. Manchester City (MC)\n", + "3. Liverpool (LIV)\n", + "4. Chelsea (CHE)\n", + "5. Arsenal (ARS)\n", + "6. Tottenham (TOT)\n", + "7. Everton (EVE)\n", + "8. West Ham (WH)\n", + "\n", + "La Liga Teams:\n", + "\n", + "1. Barcelona (BAR)\n", + "2. Real Madrid (RM)\n", + "3. Atletico Madrid (AM)\n", + "4. Sevilla (SEV)\n", + "5. Valencia (VAL)\n", + "6. Villarreal (VIL)\n", + "7. Real Betis (BET)\n", + "8. Getafe (GET)\n", + "\n", + "Here is code:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b989ca4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'BAR': 'MU', 'RM': 'MC', 'AM': 'LIV', 'SEV': 'CHE', 'VAL': 'WH', 'VIL': 'EVE', 'BET': 'TOT', 'GET': 'ARS'}\n" + ] + } + ], + "source": [ + "# Gale-Shapley Algorithm Implementation\n", + "\n", + "def stable_matching(epl, la_liga, epl_prefs, la_liga_prefs):\n", + " # Initial empty matching\n", + " matches = {}\n", + " free_teams = list(epl)\n", + " \n", + " while free_teams:\n", + " team = free_teams.pop(0)\n", + " team_prefs = epl_prefs[team]\n", + " choice = team_prefs.pop(0)\n", + " if choice in matches:\n", + " current_match = matches[choice]\n", + " if la_liga_prefs[choice].index(team) < la_liga_prefs[choice].index(current_match):\n", + " free_teams.append(current_match)\n", + " matches[choice] = team\n", + " else:\n", + " free_teams.append(team)\n", + " else:\n", + " matches[choice] = team\n", + " \n", + " return matches\n", + "\n", + "\n", + "epl = ['MU', 'MC', 'LIV', 'CHE', 'ARS', 'TOT', 'EVE', 'WH']\n", + "la_liga = ['BAR', 'RM', 'AM', 'SEV', 'VAL', 'VIL', 'BET', 'GET']\n", + "\n", + "epl_prefs = {\n", + " 'MU': ['BAR', 'RM', 'AM', 'SEV', 'VAL', 'VIL', 'BET', 'GET'],\n", + " 'MC': ['RM', 'BAR', 'SEV', 'AM', 'VIL', 'VAL', 'GET', 'BET'],\n", + " 'LIV': ['AM', 'SEV', 'BAR', 'RM', 'BET', 'GET', 'VAL', 'VIL'],\n", + " 'CHE': ['BAR', 'RM', 'AM', 'SEV', 'VAL', 'VIL', 'BET', 'GET'],\n", + " 'ARS': ['BAR', 'RM', 'AM', 'SEV', 'VAL', 'VIL', 'BET', 'GET'],\n", + " 'TOT': ['BAR', 'RM', 'AM', 'SEV', 'VAL', 'VIL', 'BET', 'GET'],\n", + " 'EVE': ['BAR', 'RM', 'AM', 'SEV', 'VAL', 'VIL', 'BET', 'GET'],\n", + " 'WH': ['BAR', 'RM', 'AM', 'SEV', 'VAL', 'VIL', 'BET', 'GET']\n", + "}\n", + "\n", + "la_liga_prefs = {\n", + " 'BAR': ['MU', 'MC', 'LIV', 'CHE', 'ARS', 'TOT', 'EVE', 'WH'],\n", + " 'RM': ['MC', 'MU', 'ARS', 'LIV', 'CHE', 'TOT', 'WH', 'EVE'],\n", + " 'AM': ['LIV', 'CHE', 'MU', 'MC', 'WH', 'EVE', 'TOT', 'ARS'],\n", + " 'SEV': ['LIV', 'CHE', 'MU', 'MC', 'WH', 'EVE', 'TOT', 'ARS'],\n", + " 'VAL': ['LIV', 'CHE', 'MU', 'MC', 'WH', 'EVE', 'TOT', 'ARS'],\n", + " 'VIL': ['LIV', 'CHE', 'MU', 'MC', 'WH', 'EVE', 'TOT', 'ARS'],\n", + " 'BET': ['LIV', 'CHE', 'MU', 'MC', 'WH', 'EVE', 'TOT', 'ARS'],\n", + " 'GET': ['LIV', 'CHE', 'MU', 'MC', 'WH', 'EVE', 'TOT', 'ARS']\n", + "}\n", + "\n", + "matches = stable_matching(epl, la_liga, epl_prefs, la_liga_prefs)\n", + "print(matches)\n" + ] + }, + { + "cell_type": "markdown", + "id": "d3f2df83", + "metadata": {}, + "source": [ + "B. Implement a loop to mix the preference lists for each team 1000 times. Determine the proportion of stable group stage matchups using these shuffled lists. Consider utilizing the function random.shuffle(x[, random]).\n" + ] + }, + { + "cell_type": "markdown", + "id": "803f1742", + "metadata": {}, + "source": [ + " Solution: \n", + "\n", + "1. Create a function to check if a matching is stable.\n", + "2. Shuffle the preference lists 1000 times and use the Gale-Shapley algorithm to find matchings.\n", + "3. For each matching, check if it's stable. If it is, increment the stable match count.\n", + "4. Calculate the percentage of stable playoff matches. \n", + "Here is code: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e35ebbbc", + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "\n", + "# Gale-Shapley Matching\n", + "def gale_shapley(men_prefs, women_prefs):\n", + " free_men = list(men_prefs.keys())\n", + " matchings = {}\n", + " \n", + " while free_men:\n", + " man = free_men.pop(0)\n", + " man_list = men_prefs[man]\n", + " \n", + " for woman in man_list:\n", + " fiance = matchings.get(woman)\n", + " if not fiance:\n", + " matchings[woman] = man\n", + " break\n", + "\n", + " woman_list = women_prefs[woman]\n", + " if woman_list.index(man) < woman_list.index(fiance):\n", + " free_men.append(fiance)\n", + " break\n", + " \n", + " return matchings\n", + "\n", + "# Initial teams and preferences\n", + "initial_teams_epl = ['EPL'+str(i) for i in range(1,9)]\n", + "initial_teams_la_liga = ['LaLiga'+str(i) for i in range(1,9)]\n", + "initial_prefs_epl = {team: initial_teams_la_liga.copy() for team in initial_teams_epl}\n", + "initial_prefs_la_liga = {team: initial_teams_epl.copy() for team in initial_teams_la_liga}\n", + "for team in initial_prefs_epl:\n", + " random.shuffle(initial_prefs_epl[team])\n", + "for team in initial_prefs_la_liga:\n", + " random.shuffle(initial_prefs_la_liga[team])\n", + "\n", + "# Get an initial matching to check stability later\n", + "initial_matching = gale_shapley(initial_prefs_epl, initial_prefs_la_liga)\n", + "\n", + "stable_match_count = 0\n", + "iterations = 1000\n", + "\n", + "for _ in range(iterations):\n", + " for team in initial_prefs_epl:\n", + " random.shuffle(initial_prefs_epl[team])\n", + " for team in initial_prefs_la_liga:\n", + " random.shuffle(initial_prefs_la_liga[team])\n", + "\n", + " new_matching = gale_shapley(initial_prefs_epl, initial_prefs_la_liga)\n", + " \n", + " if new_matching == initial_matching:\n", + " stable_match_count += 1\n", + "\n", + "percentage_stable_matches = (stable_match_count / iterations) * 100\n", + "print(f\"Percentage of Stable Matchups: {percentage_stable_matches}%\")" + ] + }, + { + "cell_type": "markdown", + "id": "f381b9cf", + "metadata": {}, + "source": [ + "C. Based on fictional match outcomes, determine which teams proceed and which get eliminated in each round. Following this, remove the ousted teams from the preference lists for the upcoming rounds. Can you continuously apply the Gale-Shapley matching algorithm for each phase (32 teams, 16 teams, 8 teams, 4 teams) to achieve stable draws?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "be4c2467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Round with 16 teams:\n", + "{'BET': 'MU', 'GET': 'EVE', 'VAL': 'CHE', 'SEV': 'LIV', 'BAR': 'MC', 'VIL': 'WH'}\n", + "Eliminated: ['GET', 'MU', 'WH', 'BET', 'WH', 'WH', 'VIL', 'LIV']\n", + "Round with 8 teams:\n", + "{'VAL': 'CHE', 'BAR': 'MC'}\n", + "Eliminated: ['VAL', 'CHE', 'CHE', 'CHE']\n", + "Round with 4 teams:\n", + "{'BAR': 'MC'}\n", + "Eliminated: ['BAR', 'BAR']\n", + "Round with 2 teams:\n", + "{'SEV': 'MC'}\n", + "Eliminated: ['SEV']\n", + "Playoff complete!\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "def gale_shapley(epl, la_liga, epl_prefs, la_liga_prefs):\n", + " free_teams = epl.copy()\n", + " matches = {}\n", + " proposals = {team: [] for team in epl}\n", + " \n", + " while free_teams:\n", + " team_epl = free_teams.pop()\n", + " for team_la_liga in epl_prefs[team_epl]:\n", + " if team_la_liga not in proposals[team_epl]:\n", + " proposals[team_epl].append(team_la_liga)\n", + " if team_la_liga not in matches:\n", + " matches[team_la_liga] = team_epl\n", + " break\n", + " elif la_liga_prefs[team_la_liga].index(team_epl) < la_liga_prefs[team_la_liga].index(matches[team_la_liga]):\n", + " free_teams.append(matches[team_la_liga])\n", + " matches[team_la_liga] = team_epl\n", + " break\n", + " return matches\n", + "\n", + "def eliminate_teams(matches):\n", + " # This function randomly eliminates one team from each match\n", + " return random.choice([team for pair in matches.items() for team in pair])\n", + "\n", + "# Start the playoff with the initial teams and preferences\n", + "epl_remaining = epl.copy()\n", + "la_liga_remaining = la_liga.copy()\n", + "epl_prefs_remaining = epl_prefs.copy()\n", + "la_liga_prefs_remaining = la_liga_prefs.copy()\n", + "\n", + "rounds = [16, 8, 4, 2]\n", + "\n", + "for r in rounds:\n", + " print(f\"Round with {r} teams:\")\n", + " matches = gale_shapley(epl_remaining, la_liga_remaining, epl_prefs_remaining, la_liga_prefs_remaining)\n", + " print(matches)\n", + " \n", + " # Eliminate half of the teams\n", + " eliminated = [eliminate_teams(matches) for _ in range(r // 2)]\n", + " print(f\"Eliminated: {eliminated}\")\n", + " \n", + " # Update remaining teams and their preferences\n", + " epl_remaining = [team for team in epl_remaining if team not in eliminated]\n", + " la_liga_remaining = [team for team in la_liga_remaining if team not in eliminated]\n", + " epl_prefs_remaining = {team: prefs for team, prefs in epl_prefs_remaining.items() if team not in eliminated}\n", + " la_liga_prefs_remaining = {team: prefs for team, prefs in la_liga_prefs_remaining.items() if team not in eliminated}\n", + " for team, prefs in epl_prefs_remaining.items():\n", + " epl_prefs_remaining[team] = [p for p in prefs if p not in eliminated]\n", + " for team, prefs in la_liga_prefs_remaining.items():\n", + " la_liga_prefs_remaining[team] = [p for p in prefs if p not in eliminated]\n", + "\n", + "print(\"Playoff complete!\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "1aeddfb9", + "metadata": {}, + "source": [ + "D. Merge the team lists, disregarding their leagues, so that any team can potentially face any other. In this scenario, does the Gale-Shapley matching algorithm still establish stable matchups, especially when it's a single list matching within itself?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "cb4b07f2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'MU': 'MC', 'MC': 'MU', 'LIV': 'CHE', 'CHE': 'LIV', 'ARS': 'TOT', 'TOT': 'ARS', 'EVE': 'WH', 'WH': 'EVE', 'BAR': 'RM', 'RM': 'BAR', 'AM': 'SEV', 'SEV': 'AM', 'VAL': 'VIL', 'VIL': 'VAL', 'BET': 'GET', 'GET': 'BET'}\n" + ] + } + ], + "source": [ + "def gale_shapley_all_teams(all_teams, prefs):\n", + " free_teams = all_teams.copy()\n", + " matches = {}\n", + " proposals = {team: [] for team in all_teams}\n", + " \n", + " while free_teams:\n", + " team1 = free_teams.pop()\n", + " for team2 in prefs[team1]:\n", + " if team2 != team1 and team2 not in proposals[team1]: # Team shouldn't match with itself\n", + " proposals[team1].append(team2)\n", + " if team2 not in matches:\n", + " matches[team2] = team1\n", + " break\n", + " elif prefs[team2].index(team1) < prefs[team2].index(matches[team2]):\n", + " free_teams.append(matches[team2])\n", + " matches[team2] = team1\n", + " break\n", + " \n", + " return matches\n", + "\n", + "# Combining the teams from both conferences\n", + "all_teams = epl + la_liga\n", + "\n", + "# Combining the preferences\n", + "all_prefs = {}\n", + "for team in epl:\n", + " all_prefs[team] = [t for t in all_teams if t != team] # Excluding the team itself from preferences\n", + "\n", + "for team in la_liga:\n", + " all_prefs[team] = [t for t in all_teams if t != team] # Excluding the team itself from preferences\n", + "\n", + "matches = gale_shapley_all_teams(all_teams, all_prefs)\n", + "print(matches)\n" + ] + }, + { + "cell_type": "markdown", + "id": "95fadf72", + "metadata": {}, + "source": [ + "E. Progressively double the size of the lists you used in problem A (you can invent team names like FCAlpha, FCBeta, etc.). Monitor how long it takes to get stable matchups in each case. How does the time taken correlate with the escalating size of the lists?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1abd14dc", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import random\n", + "\n", + "# Gale-Shapley Matching\n", + "def gale_shapley(men_prefs, women_prefs):\n", + " free_men = list(men_prefs.keys())\n", + " matchings = {}\n", + " \n", + " while free_men:\n", + " man = free_men.pop(0)\n", + " man_list = men_prefs[man]\n", + " \n", + " for woman in man_list:\n", + " fiance = matchings.get(woman)\n", + " if not fiance:\n", + " matchings[woman] = man\n", + " break\n", + "\n", + " woman_list = women_prefs[woman]\n", + " if woman_list.index(man) < woman_list.index(fiance):\n", + " free_men.append(fiance)\n", + " break\n", + " \n", + " return matchings\n", + "\n", + "# Function to double the teams and preferences\n", + "def double_teams_and_prefs(original_teams):\n", + " new_teams = original_teams + [\"FC\" + chr(i) for i in range(65, 65 + len(original_teams))]\n", + " new_prefs = {team: new_teams.copy() for team in new_teams}\n", + " for team, prefs in new_prefs.items():\n", + " random.shuffle(prefs)\n", + " return new_teams, new_prefs\n", + "\n", + "# Measure Gale-Shapley execution time\n", + "def measure_time_for_gale_shapley(men_prefs, women_prefs):\n", + " start_time = time.time()\n", + " gale_shapley(men_prefs, women_prefs)\n", + " return time.time() - start_time\n", + "\n", + "# Initial teams\n", + "initial_teams_epl = ['EPL'+str(i) for i in range(1,9)]\n", + "initial_teams_la_liga = ['LaLiga'+str(i) for i in range(1,9)]\n", + "initial_prefs_epl = {team: initial_teams_la_liga.copy() for team in initial_teams_epl}\n", + "initial_prefs_la_liga = {team: initial_teams_epl.copy() for team in initial_teams_la_liga}\n", + "for team in initial_prefs_epl:\n", + " random.shuffle(initial_prefs_epl[team])\n", + "for team in initial_prefs_la_liga:\n", + " random.shuffle(initial_prefs_la_liga[team])\n", + "\n", + "team_counts = [len(initial_teams_epl)]\n", + "times = [measure_time_for_gale_shapley(initial_prefs_epl, initial_prefs_la_liga)]\n", + "\n", + "# Double the size and measure execution time\n", + "for _ in range(5): # Doubling 5 times as an example\n", + " initial_teams_epl, initial_prefs_epl = double_teams_and_prefs(initial_teams_epl)\n", + " initial_teams_la_liga, initial_prefs_la_liga = double_teams_and_prefs(initial_teams_la_liga)\n", + " elapsed_time = measure_time_for_gale_shapley(initial_prefs_epl, initial_prefs_la_liga)\n", + " times.append(elapsed_time)\n", + " team_counts.append(len(initial_teams_epl))\n", + "\n", + "print(\"Number of teams:\", team_counts)\n", + "print(\"Execution times:\", times)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66cddee5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Zhenhao_Chen_002682716/Assignment-1.readme b/Submissions/Zhenhao_Chen_002682716/Assignment-1.readme new file mode 100644 index 0000000..7baa89a --- /dev/null +++ b/Submissions/Zhenhao_Chen_002682716/Assignment-1.readme @@ -0,0 +1,15 @@ +First Name: Zhenhao +Last Name : Chen +NU_ID : 002682716 + +Assignment-1 : Reflection of assignment 1 + +How ChatGPT or the tool you used assisted in this task: +I used ChatGPT to assist me in this task. It's really a cool tool for us to create something and learn something. When I have confusion about the sample questions, ChatGPT could provide me explanations. And it produced a typical Gale-Shapley problem for me which I think the process I solved this problem can greatly enhance my understanding to this algorithm. + +Challenges you faced while ensuring the problem maintained the spirit of the example: +It's not difficult to ensure the problem maintained the spirit of the example since it's a very typical Gale-Shapley problem. When I saw the problem, I can realize it ask me to find a stable marriage for males and females. + +What you learned about problem design in the realm of algorithms: +- The most important thing that I've learned is that a well-designed algorithmic problem is clear and precisely defined. Ambiguity can lead to confusion and difficulties in understanding the problem's requirements. Therefore, it's of great essential to provide a clear and unambiguous problem statement. +- Moreover, it's also helpful to provide clear sample input and output since they clarify the problem's requirements. \ No newline at end of file diff --git a/Submissions/Zhenhao_Chen_002682716/Untitled.ipynb b/Submissions/Zhenhao_Chen_002682716/Untitled.ipynb new file mode 100644 index 0000000..eaa2ecb --- /dev/null +++ b/Submissions/Zhenhao_Chen_002682716/Untitled.ipynb @@ -0,0 +1,225 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "612c98ac", + "metadata": {}, + "source": [ + "# Assignments-1" + ] + }, + { + "cell_type": "markdown", + "id": "6cb69809", + "metadata": {}, + "source": [ + "# 09/24/2023" + ] + }, + { + "cell_type": "markdown", + "id": "b7024ae8", + "metadata": {}, + "source": [ + "# Q1" + ] + }, + { + "cell_type": "markdown", + "id": "50bac24f", + "metadata": {}, + "source": [ + "Suppose there are two groups of people, one consisting of males (M1, M2, M3, M4...) and the other of females (W1, W2, W3, W4...). Each male has a preference list ranking their preferences for females, and likewise, each female has a preference list ranking their preferences for males.\n", + "\n", + "Using the Gale-Shapley Stable Marriage Algorithm, males and females will propose to each other based on their preferences. When a female receives a proposal, she will consider her preference list. If the current proposer is more preferable than the previous one, she will accept the proposal; otherwise, she will reject it. Males continue proposing to the next female on their preference list until either all males have been rejected or all females have accepted." + ] + }, + { + "cell_type": "markdown", + "id": "9627866c", + "metadata": {}, + "source": [ + "### (a)" + ] + }, + { + "cell_type": "raw", + "id": "6a0710b9", + "metadata": {}, + "source": [ + "Provide preference lists for both males and females. For example:\n", + "Male preference lists:\n", + "M1: W2, W1, W3, W4\n", + "M2: W1, W2, W3, W4\n", + "M3: W2, W3, W4, W1\n", + "M4: W1, W2, W3, W4\n", + "Female preference lists:\n", + "W1: M2, M1, M3, M4\n", + "W2: M1, M2, M3, M4\n", + "W3: M1, M2, M4, M3\n", + "W4: M3, M2, M1, M4\n", + "Using the Gale-Shapley Stable Marriage Algorithm, calculate a stable marriage matching and list the final matches for each male and female. For example, the output format should be like [[M1, W1][M2, W2]]." + ] + }, + { + "cell_type": "markdown", + "id": "e24c9ed7", + "metadata": {}, + "source": [ + "### (b)" + ] + }, + { + "cell_type": "markdown", + "id": "78b04444", + "metadata": {}, + "source": [ + "Explain what a stable marriage is and how this algorithm ensures stability in marriages." + ] + }, + { + "cell_type": "markdown", + "id": "7a9582e0", + "metadata": {}, + "source": [ + "### Ans:" + ] + }, + { + "cell_type": "raw", + "id": "9d627ccd", + "metadata": {}, + "source": [ + "(a)\n", + "According to Gale-Shapley, we know that males and females will prefer to their first choice, then the second choice, the third choice and so on. Given the preference lists above, we can simulate the process.\n", + "\n", + "We use '->' to represent a male proposes to a female or a female accepts a male.\n", + "M1 -> W2\n", + "W2 -> M1\n", + "M2 -> W1\n", + "W1 -> M2\n", + "M3 -> W2\n", + "W2 rejected M3\n", + "M4 -> W1\n", + "W1 rejected M4\n", + "Now, M1 and M2 have been accepted. M3 and M4 have been rejected.\n", + "\n", + "M3 -> W3\n", + "W3 -> M3\n", + "M4 -> W2\n", + "W2 rejected M4\n", + "Now, M1, M2 and M3 have been accepted. M4 has been rejected.\n", + "\n", + "M4 -> W3\n", + "W3 rejected M3\n", + "W3 -> M4\n", + "Now, M1, M2 and M4 have been accepted cause W3 prefers M4 to M3. M3 has been rejected.\n", + "\n", + "M3 -> W4\n", + "W4 -> M3\n", + "Now, all the males have been accepted.\n", + "\n", + "The final matches should be:\n", + "[[M1, W2]\n", + " [M2, W1]\n", + " [M3, W4]\n", + " [M4, W3]]\n", + "\n", + "We can use pseudo code to represent the process:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13b98931", + "metadata": {}, + "outputs": [], + "source": [ + "maleList:[(male preference lists)]\n", + "femaleList:[(female preference lists)]\n", + "matchList:[]\n", + "while (there is a male M who has not been accepetd):\n", + " M proposes to the highest-ranked female W that he has not proposed yet in his maleList\n", + " if (W has accepted a male M2 already):\n", + " if(W prefers M to M2 in femaleList):\n", + " W rejects M2\n", + " W accepts M\n", + " delete [W, M2] in matchList\n", + " add [W, M] matchList\n", + " else:\n", + " W rejects M\n", + " else:\n", + " W accepts M\n", + " add [W, M] in matchList\n", + " \n", + "return matchList" + ] + }, + { + "cell_type": "raw", + "id": "f5f28a8a", + "metadata": {}, + "source": [ + "(b)\n", + "In my opinion, a stable marriage means that there are no such a male and a female that would prefer each other instead of their current partners. That is to say, they have already proposed to or accepted the best-suited partners for them.\n", + "\n", + "The algorithm ensures the marriage stability by:\n", + "A male M will propose to females in his preference list in order. When M proposes to a female W, W will first compare M with her current partner(if exists) and accept the preferable one. In this way, W can always choose the she preferred the most.\n", + "When it comes to males, if M get rejected by W, M will keep proposing to the next female in his preference list unitl he is accepted or get rejected by every female. In this way, M can also find the best-suited female." + ] + }, + { + "cell_type": "markdown", + "id": "8bf76622", + "metadata": {}, + "source": [ + "# Reflection" + ] + }, + { + "cell_type": "raw", + "id": "f145a8e5", + "metadata": {}, + "source": [ + "How ChatGPT or the tool you used assisted in this task:\n", + "I used ChatGPT to assist me in this task. It's really a cool tool for us to create something and learn something. When I have confusion about the sample questions, ChatGPT could provide me explanations. And it produced a typical Gale-Shapley problem for me which I think the process I solved this problem can greatly enhance my understanding to this algorithm.\n", + "\n", + "Challenges you faced while ensuring the problem maintained the spirit of the example:\n", + "It's not difficult to ensure the problem maintained the spirit of the example since it's a very typical Gale-Shapley problem. When I saw the problem, I can realize it ask me to find a stable marriage for males and females.\n", + "\n", + "What you learned about problem design in the realm of algorithms:\n", + "- The most important thing that I've learned is that a well-designed algorithmic problem is clear and precisely defined. Ambiguity can lead to confusion and difficulties in understanding the problem's requirements. Therefore, it's of great essential to provide a clear and unambiguous problem statement.\n", + "- Moreover, it's also helpful to provide clear sample input and output since they clarify the problem's requirements." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad8a4b55", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Zihao_Liu_001567668/.ipynb_checkpoints/Assignment1-checkpoint.ipynb b/Submissions/Zihao_Liu_001567668/.ipynb_checkpoints/Assignment1-checkpoint.ipynb new file mode 100644 index 0000000..f8ed071 --- /dev/null +++ b/Submissions/Zihao_Liu_001567668/.ipynb_checkpoints/Assignment1-checkpoint.ipynb @@ -0,0 +1,651 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "954618bd-99f7-4210-b0cc-99364e75ace0", + "metadata": {}, + "source": [ + "# Assignment 1\n", + "### Zihao Liu\n", + "### 001567668" + ] + }, + { + "cell_type": "markdown", + "id": "f32e07b6-8c7a-4a36-a007-6a3dbfc78554", + "metadata": {}, + "source": [ + "## Q1:\n", + " Arrange the following functions in increasing order of growth:\n", + "\n", + "log(2n) \n", + "2^n \n", + "n^2 + 3n\n", + "3^n \n", + "n! \n", + "log(n!) \n", + "n^log(n) \n", + "4n \n", + "2n^2 \n", + "n^(3/2) \n", + "\n", + "### Answer 1:\n", + "1. log(2n)\n", + "2. 4n\n", + "3. n^2+3n\n", + "4. 2n^2\n", + "5. n^(3/2)\n", + "6. n^log(n)\n", + "7. log(n!)\n", + "8. 2^n\n", + "9. 3^n \n", + "10. n!\n", + "\n", + "### Explain:\n", + "The Orders of common functions is:\n", + "1. Constant\n", + "2. Logarithmic Function\n", + "3. Root Functions\n", + "4. Linear Function\n", + "5. Log-linear (Linearithmic) Function\n", + "6. Polynomial Functions\n", + "7. Exponential Functions\n", + "8. Factorial Function\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d478ce25-b47c-4925-85c4-e3f102f70231", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "3dd1e961-e316-4319-9bf2-3b8c43f6601d", + "metadata": {}, + "source": [ + "## Q2:\n", + "Consider two sets, $ A = \\{a_1, a_2\\} $ and $ B = \\{b_1, b_2\\}$, where $ A $ and $ B $ are two different sets of individuals seeking to be matched with each other. The preference lists for the individuals are as follows:\n", + "\n", + "- $ a_1 $: $ b_1, b_2 $\n", + "- $ a_2 $: $ b_2, b_1 $\n", + "- $ b_1 $: $ a_2, a_1 $\n", + "- $ b_2 $: $ a_1, a_2 $\n", + "\n", + "Apply the Gale-Shapley Algorithm to find a stable matching. Is there more than one stable matching for the given preference lists?\n", + "\n", + "### Answer 2:\n", + "Let each individual in A propose to their preferred individual in set B. Base on the preference list of B. each individual in set B either accepting the proposal or rejecting it.\n", + "\n", + "1. $ a_1 $ proposes to $ b_1 $ and $ a_2 $ proposes to $ b_2 $.\n", + "2. $ b_1 $ prefers $ a_2 $ to $ a_1 $ and $ b_2 $ prefers $ a_1 $ to $ a_2 $.\n", + "3. So, $ b_1 $ rejects $ a_1 $ and $ b_2 $ rejects $ a_2 $.\n", + "4. Now, $ a_1 $ proposes to $ b_2 $ and $ a_2 $ proposes to $ b_1 $.\n", + "\n", + "Thus rhe stable matching is $ \\{(a_1, b_2), (a_2, b_1)\\} $." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b0ab6df-5a7f-441a-a674-7f78535b6e7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "5a73bfd2-2dcc-40ba-979d-4b6fe784eb17", + "metadata": {}, + "source": [ + "## Q3:\n", + "\n", + "### Problem Statement\n", + "\n", + "**Objective:**\n", + "\n", + "Create a program that takes two lists, one of applicants and one of companies, where each applicant has a list of preferred companies and each company has a list of preferred applicants. The program should output stable matches.\n", + "\n", + "**Background:**\n", + "\n", + "A matching is stable if there exists no applicant-company pair (A, C) such that:\n", + "- A is matched with C' but prefers C over C'.\n", + "- C is matched with A' but prefers A over A'.\n", + "\n", + "### Inputs:\n", + "\n", + "- A list `applicants`, where each applicant is represented as a dictionary with the following keys:\n", + " - `'name'`: a string representing the name of the applicant.\n", + " - `'preferences'`: a list of strings representing the names of companies in decreasing order of preference.\n", + " \n", + "- A list `companies`, where each company is represented as a dictionary with the following keys:\n", + " - `'name'`: a string representing the name of the company.\n", + " - `'preferences'`: a list of strings representing the names of applicants in decreasing order of preference.\n", + "\n", + "### Output:\n", + "\n", + "- A list of dictionaries representing the stable matches, where each dictionary has the following keys:\n", + " - `'applicant'`: a string representing the name of the applicant.\n", + " - `'company'`: a string representing the name of the company.\n", + "\n", + "### Constraints:\n", + "\n", + "- 1 ≤ |applicants|, |companies| ≤ 1000\n", + "- All names of applicants and companies are unique and consist of lowercase and uppercase English letters, and have length at most 100.\n", + "- Each applicant has a list of all companies in their preferences list, and each company has a list of all applicants in their preferences list.\n", + "\n", + "### Example:\n", + "\n", + "#### Input:\n", + "\n", + "```python\n", + "applicants = [\n", + " {'name': 'Alice', 'preferences': ['Google', 'Facebook']},\n", + " {'name': 'Bob', 'preferences': ['Facebook', 'Google']}\n", + "]\n", + "\n", + "companies = [\n", + " {'name': 'Google', 'preferences': ['Alice', 'Bob']},\n", + " {'name': 'Facebook', 'preferences': ['Bob', 'Alice']}\n", + "]\n", + "```\n", + "\n", + "#### Output:\n", + "\n", + "```python\n", + "[\n", + " {'applicant': 'Alice', 'company': 'Google'},\n", + " {'applicant': 'Bob', 'company': 'Facebook'}\n", + "]\n", + "```\n", + "\n", + "### Explanation:\n", + "\n", + "In this example:\n", + "- Alice prefers to work at Google over Facebook, and Google prefers Alice over Bob, so they form a stable match.\n", + "- Bob prefers to work at Facebook over Google, and Facebook prefers Bob over Alice, so they form a stable match." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "54f3c710-623f-41d5-abd6-cf0370977143", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'applicant': 'Alice', 'company': 'Google'}, {'applicant': 'Bob', 'company': 'Facebook'}]\n" + ] + } + ], + "source": [ + "def stable_matching(applicants, companies):\n", + " # Initialize the company and applicant dictionaries with their preferences\n", + " applicant_pref_dict = {a['name']: a['preferences'] for a in applicants}\n", + " company_pref_dict = {c['name']: c['preferences'] for c in companies}\n", + " \n", + " # Dictionary to keep track of the applicants' current companies\n", + " applicant_current_company = {a['name']: None for a in applicants}\n", + " \n", + " # Dictionary to keep track of companies' current applicants\n", + " company_current_applicants = {c['name']: [] for c in companies}\n", + " \n", + " # List of free applicants\n", + " free_applicants = [a['name'] for a in applicants]\n", + " \n", + " while free_applicants:\n", + " applicant = free_applicants.pop(0)\n", + " prefs = applicant_pref_dict[applicant]\n", + " \n", + " # Iterate through the applicant's preferences\n", + " for company in prefs:\n", + " # If applicant is not matched with any company\n", + " if applicant_current_company[applicant] is None:\n", + " # Check the company's preferences\n", + " company_prefs = company_pref_dict[company]\n", + " \n", + " # If company has no applicants yet\n", + " if not company_current_applicants[company]:\n", + " # Match the applicant and company\n", + " applicant_current_company[applicant] = company\n", + " company_current_applicants[company].append(applicant)\n", + " break\n", + " else:\n", + " # If company prefers the new applicant over the current one\n", + " current_applicant = company_current_applicants[company][0]\n", + " if company_prefs.index(applicant) < company_prefs.index(current_applicant):\n", + " # Set the current applicant as free\n", + " applicant_current_company[current_applicant] = None\n", + " free_applicants.append(current_applicant)\n", + " \n", + " # Match the new applicant and company\n", + " applicant_current_company[applicant] = company\n", + " company_current_applicants[company][0] = applicant\n", + " break\n", + " \n", + " # Formulate the output\n", + " result = []\n", + " for applicant, company in applicant_current_company.items():\n", + " result.append({'applicant': applicant, 'company': company})\n", + " \n", + " return result\n", + "\n", + "\n", + "# Example usage:\n", + "applicants = [\n", + " {'name': 'Alice', 'preferences': ['Google', 'Facebook']},\n", + " {'name': 'Bob', 'preferences': ['Facebook', 'Google']}\n", + "]\n", + "\n", + "companies = [\n", + " {'name': 'Google', 'preferences': ['Alice', 'Bob']},\n", + " {'name': 'Facebook', 'preferences': ['Bob', 'Alice']}\n", + "]\n", + "\n", + "print(stable_matching(applicants, companies))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1ac951a-90b6-4763-ac04-f286cf1575f1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "1e57e08c-363f-482a-8976-2dcc0c50f8a9", + "metadata": {}, + "source": [ + "## Q4:\n", + "### Question:\n", + "\n", + "Consider the undirected graph G with vertices {A, B, C, D, E, F} and edges {AB, AC, BD, CD, DE, EF}. Suppose you perform a Breadth-First Search (BFS) starting from vertex A.\n", + "\n", + "```plaintext\n", + " A\n", + " / \\\n", + " B - C\n", + " | |\n", + " D - E - F\n", + "```\n", + "\n", + "What is the correct order of the vertices visited by a BFS traversal starting from vertex A?\n", + "\n", + "### Choices:\n", + "\n", + "A) A, B, C, D, E, F \n", + "B) A, C, B, E, D, F \n", + "C) A, B, C, D, F, E \n", + "D) A, C, B, D, E, F \n", + "\n", + "### Answer:\n", + "\n", + "A\n", + "\n", + "\n", + "### Explain:\n", + "BFS algorithm explores all the neighbors at the present depth before moving on to the next level." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69a5ac61-3a3c-454b-a72d-eb2347b874cb", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "51855b5c-c4eb-43a8-b3bb-8b1dbfab6e55", + "metadata": {}, + "source": [ + "### Q5:\n", + "Consider a directed graph G = (V, E) where V is a set of vertices and E is a set of edges. The graph has n vertices numbered from 1 to n. You have been given a task to implement a Depth-First Search (DFS) to traverse the graph and print the vertices in the order they are visited.\n", + "\n", + "You are given the following information:\n", + "- The graph may contain one or more connected components.\n", + "- Vertices are numbered, and the graph is represented using an adjacency list.\n", + "- It is guaranteed that there are no self-loops, i.e., there will be no edges from a vertex to itself.\n", + "- The graph may contain cycles.\n", + "\n", + "Write a Python function named `dfs_traversal` that takes an adjacency list representing the graph and a starting vertex as input and returns a list containing the vertices in the order they are visited by a Depth-First Search (DFS). If the graph has more than one connected component, your function should still return the vertices of all components in the order they are visited.\n", + "\n", + "### Function Signature:\n", + "```python\n", + "def dfs_traversal(adj_list: Dict[int, List[int]], start_vertex: int) -> List[int]:\n", + "```\n", + "\n", + "### Input:\n", + "- `adj_list` (1 <= len(adj_list) <= 1000) is a dictionary where the key is a vertex (int) and the value is a list of integers representing the adjacent vertices.\n", + "- `start_vertex` (1 <= start_vertex <= n) is an integer representing the starting vertex for the DFS.\n", + "\n", + "### Output:\n", + "- A list of integers representing the vertices in the order they are visited by DFS.\n", + "\n", + "### Example:\n", + "#### Input:\n", + "```python\n", + "adj_list = {\n", + " 1: [2],\n", + " 2: [3, 4],\n", + " 3: [],\n", + " 4: [5],\n", + " 5: [],\n", + " 6: [7],\n", + " 7: []\n", + "}\n", + "start_vertex = 1\n", + "```\n", + "\n", + "#### Output:\n", + "```python\n", + "[1, 2, 3, 4, 5, 6, 7]\n", + "```\n", + "\n", + "#### Explanation:\n", + "- Starting from vertex 1, the DFS visits vertices 2, 3, and 4, in this order.\n", + "- After completing the traversal for vertex 4, it goes back and visits vertex 5.\n", + "- Vertices 6 and 7 are in a different connected component, but they are also included in the output list as they are part of the overall graph.\n", + "\n", + "### Note:\n", + "You need to ensure that all vertices in the graph are visited, even if they are in different connected components. Also, take care to handle the case where cycles are present in the graph to avoid infinite loops. You can assume that the input graph is well-formed, and there are no isolated vertices (vertices not present in the adjacency list)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "26858d23-b7f2-498f-a144-795a90924a4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7]\n" + ] + } + ], + "source": [ + "def dfs_traversal(adj_list: dict, start_vertex: int) -> list:\n", + " visited = set()\n", + " result = []\n", + " \n", + " def dfs(vertex):\n", + " # If the vertex is visited, then return\n", + " if vertex in visited:\n", + " return\n", + " # Mark the vertex as visited\n", + " visited.add(vertex)\n", + " # Add the vertex to the result list\n", + " result.append(vertex)\n", + " # Visit all the adjacent vertices\n", + " for neighbor in adj_list.get(vertex, []):\n", + " dfs(neighbor)\n", + " \n", + " # Start the DFS from the given start_vertex\n", + " dfs(start_vertex)\n", + " \n", + " # Check for any unvisited vertices and traverse them as well\n", + " for vertex in adj_list.keys():\n", + " if vertex not in visited:\n", + " dfs(vertex)\n", + " \n", + " return result\n", + "\n", + "adj_list = {\n", + " 1: [2],\n", + " 2: [3, 4],\n", + " 3: [],\n", + " 4: [5],\n", + " 5: [],\n", + " 6: [7],\n", + " 7: []\n", + "}\n", + "\n", + "print(dfs_traversal(adj_list, 1))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e7a15f4-f77a-462f-be28-59740449901d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "e952bcd2-3719-4cc9-8219-e92260b9aa8d", + "metadata": {}, + "source": [ + "## Q6:\n", + "Consider an undirected graph G consisting of n vertices and m edges. An edge connects two distinct vertices, and there are no self-loops or multiple edges between the same pair of vertices.\n", + "\n", + "Which of the following statements is always true for an undirected graph with n vertices and m edges?\n", + "\n", + "A) If m > n, the graph must have a cycle. \n", + "B) If m < n, the graph must be disconnected. \n", + "C) The graph can have at most n(n - 1) / 2 edges. \n", + "D) If m = n, the graph is a tree.\n", + "\n", + "### Answer:\n", + "C) The graph can have at most n(n - 1) / 2 edges.\n", + "\n", + "### Explanation:\n", + "- A is incorrect because it’s possible to have a graph with more edges than vertices without forming a cycle. One possible counterproof is a star graph.\n", + "```\n", + " 1\n", + " /|\\\n", + " 2-4-3\n", + " \\|\n", + " 5\n", + "```\n", + " \n", + "- B is incorrect because even if the graph has fewer edges than vertices, it may still be connected. For example, a tree graph.\n", + "\n", + "```\n", + " 1 - 2 - 3\n", + "```\n", + "\n", + "- Option C is correct because an undirected graph can have at most n(n - 1) / 2 edges, which corresponds to a complete graph where every pair of distinct vertices is connected by a unique edge.\n", + "\n", + "- Option D is incorrect because even if a graph has the same number of edges as vertices, it may not be a tree. For example, a graph with 3 vertices and 3 edges forming a cycle is not a tree.\n", + "\n", + "```\n", + " 1 - 2\n", + " | /\n", + " 3\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f2528829-f6fc-4734-ada0-3627fc7cdd2c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "a4b02930-1720-4b9d-a949-d1af7bf84e50", + "metadata": { + "tags": [] + }, + "source": [ + "## Q7:\n", + "\n", + "Consider the two functions $f(n)$ and $g(n)$ defined as follows:\n", + "\n", + "$f(n) = 4n^2 + 100n + 1000$\n", + "\n", + "$g(n) = n^2$\n", + "\n", + "1. **Part A:** Using Big O notation, describe the upper bound of $f(n)$.\n", + "2. **Part B:** Is $f(n) = O(g(n))$? Justify your answer.\n", + "3. **Part C:** Given another function $(h(n) = 100n^3$, is $f(n) = O(h(n))$? Justify your answer.\n", + "\n", + "### Answer:\n", + "\n", + "1. **Part A:** $f(n)$ has an upper bound described by $O(n^2)$.\n", + "\n", + "2. **Part B:** Yes, because $f(n)$ has a highest degree term of $n^2$, and so does $g(n)$. Therefore, $g(n)$ is an upper bound for $f(n)$.\n", + "\n", + "3. **Part C:** Yes, $f(n) = O(h(n))$. Since $h(n) = 100n^3$, it grows at a cubic rate, which is faster than the quadratic rate at which $f(n)$ grows. So, $h(n)$ is an upper bound for $f(n)$ in terms of Big O notation, hence $f(n) = O(h(n)$.\n", + "A graph example from WolframAlpha: https://www.wolframalpha.com/input?i=intersect+of+x%5E3+and+x%5E2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ce130e2-22ba-4af5-92fe-b5033491fcc5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f4cf0139-0c4f-4c02-a6aa-335bfa600e2b", + "metadata": {}, + "source": [ + "### Q8:\n", + "\n", + "Consider a graph, G, consisting of vertices and edges. A vertex represents a point, and an edge represents a line connecting two vertices. A graph is “connected” if there is a path through edges from any vertex to any other vertex in the graph. \n", + "\n", + "Given the following graph, G:\n", + "\n", + "```\n", + " A — B\n", + " | / |\n", + " |/ |\n", + " C — D\n", + " |\n", + " E\n", + "```\n", + "\n", + "1. **List the vertices and edges in Graph G.**\n", + "2. **Is Graph G connected? Explain why or why not.**\n", + "3. **Find a path from Vertex A to Vertex E.**\n", + "\n", + "### Answer:\n", + "\n", + "1. Vertices: A, B, C, D, E\n", + " Edges: (A, B), (A, C), (B, C), (B, D), (C, D), (C, E)\n", + " \n", + "2. Yes, Graph G is connected. A graph is connected if there is a path from any vertex to any other vertex in the graph. In Graph G, we can reach any vertex from any other vertex through the available edges.\n", + "\n", + "3. A $\\rightarrow$ C $\\rightarrow$ E." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8cb583a-5e78-4b7a-9f31-94ce1836fa0c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f2219dad-9ad8-4ad0-9d5f-d6ee954b38f9", + "metadata": {}, + "source": [ + "## Q9:\n", + "\n", + "You are given a list of integers, and you are to write a function that finds the two elements in the list that sum up to a specific target. You need to return these two elements. If there are multiple pairs that match the target sum, you can return any of them. If no such pair exists, return an empty list. You are required to write a solution with a time complexity better than $O(n^2)$.\n", + "\n", + "### Example:\n", + "\n", + "```python\n", + "nums = [1, 2, 3, 4, 5]\n", + "target = 9\n", + "# Your function should return [4,5] (or [5,4]) since 4 + 5 = 9.\n", + "```\n", + "\n", + "### Constraints:\n", + "\n", + "- The list can have up to $10^5$ integers.\n", + "- The list and target will be such that a solution will always exist." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3732544d-1d5e-401c-8b53-4030e0564895", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5, 4]\n" + ] + } + ], + "source": [ + "def two_sum(nums, target):\n", + " seen = set()\n", + " for num in nums:\n", + " if target - num in seen:\n", + " return [num, target - num]\n", + " seen.add(num)\n", + " return []\n", + "\n", + "print(two_sum([1, 2, 3, 4, 5], 9))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4f0755d-b213-46de-871e-68a1e6c0e1a3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "8d9d0325-7912-4cce-a8f7-e96a76927991", + "metadata": {}, + "source": [ + "All summaries and reflections are included in Readme.md file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f94fbe2a-02ba-4fd4-8afd-b3ef5d322e4b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Zihao_Liu_001567668/Assignment1.ipynb b/Submissions/Zihao_Liu_001567668/Assignment1.ipynb new file mode 100644 index 0000000..f8ed071 --- /dev/null +++ b/Submissions/Zihao_Liu_001567668/Assignment1.ipynb @@ -0,0 +1,651 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "954618bd-99f7-4210-b0cc-99364e75ace0", + "metadata": {}, + "source": [ + "# Assignment 1\n", + "### Zihao Liu\n", + "### 001567668" + ] + }, + { + "cell_type": "markdown", + "id": "f32e07b6-8c7a-4a36-a007-6a3dbfc78554", + "metadata": {}, + "source": [ + "## Q1:\n", + " Arrange the following functions in increasing order of growth:\n", + "\n", + "log(2n) \n", + "2^n \n", + "n^2 + 3n\n", + "3^n \n", + "n! \n", + "log(n!) \n", + "n^log(n) \n", + "4n \n", + "2n^2 \n", + "n^(3/2) \n", + "\n", + "### Answer 1:\n", + "1. log(2n)\n", + "2. 4n\n", + "3. n^2+3n\n", + "4. 2n^2\n", + "5. n^(3/2)\n", + "6. n^log(n)\n", + "7. log(n!)\n", + "8. 2^n\n", + "9. 3^n \n", + "10. n!\n", + "\n", + "### Explain:\n", + "The Orders of common functions is:\n", + "1. Constant\n", + "2. Logarithmic Function\n", + "3. Root Functions\n", + "4. Linear Function\n", + "5. Log-linear (Linearithmic) Function\n", + "6. Polynomial Functions\n", + "7. Exponential Functions\n", + "8. Factorial Function\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d478ce25-b47c-4925-85c4-e3f102f70231", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "3dd1e961-e316-4319-9bf2-3b8c43f6601d", + "metadata": {}, + "source": [ + "## Q2:\n", + "Consider two sets, $ A = \\{a_1, a_2\\} $ and $ B = \\{b_1, b_2\\}$, where $ A $ and $ B $ are two different sets of individuals seeking to be matched with each other. The preference lists for the individuals are as follows:\n", + "\n", + "- $ a_1 $: $ b_1, b_2 $\n", + "- $ a_2 $: $ b_2, b_1 $\n", + "- $ b_1 $: $ a_2, a_1 $\n", + "- $ b_2 $: $ a_1, a_2 $\n", + "\n", + "Apply the Gale-Shapley Algorithm to find a stable matching. Is there more than one stable matching for the given preference lists?\n", + "\n", + "### Answer 2:\n", + "Let each individual in A propose to their preferred individual in set B. Base on the preference list of B. each individual in set B either accepting the proposal or rejecting it.\n", + "\n", + "1. $ a_1 $ proposes to $ b_1 $ and $ a_2 $ proposes to $ b_2 $.\n", + "2. $ b_1 $ prefers $ a_2 $ to $ a_1 $ and $ b_2 $ prefers $ a_1 $ to $ a_2 $.\n", + "3. So, $ b_1 $ rejects $ a_1 $ and $ b_2 $ rejects $ a_2 $.\n", + "4. Now, $ a_1 $ proposes to $ b_2 $ and $ a_2 $ proposes to $ b_1 $.\n", + "\n", + "Thus rhe stable matching is $ \\{(a_1, b_2), (a_2, b_1)\\} $." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b0ab6df-5a7f-441a-a674-7f78535b6e7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "5a73bfd2-2dcc-40ba-979d-4b6fe784eb17", + "metadata": {}, + "source": [ + "## Q3:\n", + "\n", + "### Problem Statement\n", + "\n", + "**Objective:**\n", + "\n", + "Create a program that takes two lists, one of applicants and one of companies, where each applicant has a list of preferred companies and each company has a list of preferred applicants. The program should output stable matches.\n", + "\n", + "**Background:**\n", + "\n", + "A matching is stable if there exists no applicant-company pair (A, C) such that:\n", + "- A is matched with C' but prefers C over C'.\n", + "- C is matched with A' but prefers A over A'.\n", + "\n", + "### Inputs:\n", + "\n", + "- A list `applicants`, where each applicant is represented as a dictionary with the following keys:\n", + " - `'name'`: a string representing the name of the applicant.\n", + " - `'preferences'`: a list of strings representing the names of companies in decreasing order of preference.\n", + " \n", + "- A list `companies`, where each company is represented as a dictionary with the following keys:\n", + " - `'name'`: a string representing the name of the company.\n", + " - `'preferences'`: a list of strings representing the names of applicants in decreasing order of preference.\n", + "\n", + "### Output:\n", + "\n", + "- A list of dictionaries representing the stable matches, where each dictionary has the following keys:\n", + " - `'applicant'`: a string representing the name of the applicant.\n", + " - `'company'`: a string representing the name of the company.\n", + "\n", + "### Constraints:\n", + "\n", + "- 1 ≤ |applicants|, |companies| ≤ 1000\n", + "- All names of applicants and companies are unique and consist of lowercase and uppercase English letters, and have length at most 100.\n", + "- Each applicant has a list of all companies in their preferences list, and each company has a list of all applicants in their preferences list.\n", + "\n", + "### Example:\n", + "\n", + "#### Input:\n", + "\n", + "```python\n", + "applicants = [\n", + " {'name': 'Alice', 'preferences': ['Google', 'Facebook']},\n", + " {'name': 'Bob', 'preferences': ['Facebook', 'Google']}\n", + "]\n", + "\n", + "companies = [\n", + " {'name': 'Google', 'preferences': ['Alice', 'Bob']},\n", + " {'name': 'Facebook', 'preferences': ['Bob', 'Alice']}\n", + "]\n", + "```\n", + "\n", + "#### Output:\n", + "\n", + "```python\n", + "[\n", + " {'applicant': 'Alice', 'company': 'Google'},\n", + " {'applicant': 'Bob', 'company': 'Facebook'}\n", + "]\n", + "```\n", + "\n", + "### Explanation:\n", + "\n", + "In this example:\n", + "- Alice prefers to work at Google over Facebook, and Google prefers Alice over Bob, so they form a stable match.\n", + "- Bob prefers to work at Facebook over Google, and Facebook prefers Bob over Alice, so they form a stable match." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "54f3c710-623f-41d5-abd6-cf0370977143", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'applicant': 'Alice', 'company': 'Google'}, {'applicant': 'Bob', 'company': 'Facebook'}]\n" + ] + } + ], + "source": [ + "def stable_matching(applicants, companies):\n", + " # Initialize the company and applicant dictionaries with their preferences\n", + " applicant_pref_dict = {a['name']: a['preferences'] for a in applicants}\n", + " company_pref_dict = {c['name']: c['preferences'] for c in companies}\n", + " \n", + " # Dictionary to keep track of the applicants' current companies\n", + " applicant_current_company = {a['name']: None for a in applicants}\n", + " \n", + " # Dictionary to keep track of companies' current applicants\n", + " company_current_applicants = {c['name']: [] for c in companies}\n", + " \n", + " # List of free applicants\n", + " free_applicants = [a['name'] for a in applicants]\n", + " \n", + " while free_applicants:\n", + " applicant = free_applicants.pop(0)\n", + " prefs = applicant_pref_dict[applicant]\n", + " \n", + " # Iterate through the applicant's preferences\n", + " for company in prefs:\n", + " # If applicant is not matched with any company\n", + " if applicant_current_company[applicant] is None:\n", + " # Check the company's preferences\n", + " company_prefs = company_pref_dict[company]\n", + " \n", + " # If company has no applicants yet\n", + " if not company_current_applicants[company]:\n", + " # Match the applicant and company\n", + " applicant_current_company[applicant] = company\n", + " company_current_applicants[company].append(applicant)\n", + " break\n", + " else:\n", + " # If company prefers the new applicant over the current one\n", + " current_applicant = company_current_applicants[company][0]\n", + " if company_prefs.index(applicant) < company_prefs.index(current_applicant):\n", + " # Set the current applicant as free\n", + " applicant_current_company[current_applicant] = None\n", + " free_applicants.append(current_applicant)\n", + " \n", + " # Match the new applicant and company\n", + " applicant_current_company[applicant] = company\n", + " company_current_applicants[company][0] = applicant\n", + " break\n", + " \n", + " # Formulate the output\n", + " result = []\n", + " for applicant, company in applicant_current_company.items():\n", + " result.append({'applicant': applicant, 'company': company})\n", + " \n", + " return result\n", + "\n", + "\n", + "# Example usage:\n", + "applicants = [\n", + " {'name': 'Alice', 'preferences': ['Google', 'Facebook']},\n", + " {'name': 'Bob', 'preferences': ['Facebook', 'Google']}\n", + "]\n", + "\n", + "companies = [\n", + " {'name': 'Google', 'preferences': ['Alice', 'Bob']},\n", + " {'name': 'Facebook', 'preferences': ['Bob', 'Alice']}\n", + "]\n", + "\n", + "print(stable_matching(applicants, companies))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1ac951a-90b6-4763-ac04-f286cf1575f1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "1e57e08c-363f-482a-8976-2dcc0c50f8a9", + "metadata": {}, + "source": [ + "## Q4:\n", + "### Question:\n", + "\n", + "Consider the undirected graph G with vertices {A, B, C, D, E, F} and edges {AB, AC, BD, CD, DE, EF}. Suppose you perform a Breadth-First Search (BFS) starting from vertex A.\n", + "\n", + "```plaintext\n", + " A\n", + " / \\\n", + " B - C\n", + " | |\n", + " D - E - F\n", + "```\n", + "\n", + "What is the correct order of the vertices visited by a BFS traversal starting from vertex A?\n", + "\n", + "### Choices:\n", + "\n", + "A) A, B, C, D, E, F \n", + "B) A, C, B, E, D, F \n", + "C) A, B, C, D, F, E \n", + "D) A, C, B, D, E, F \n", + "\n", + "### Answer:\n", + "\n", + "A\n", + "\n", + "\n", + "### Explain:\n", + "BFS algorithm explores all the neighbors at the present depth before moving on to the next level." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69a5ac61-3a3c-454b-a72d-eb2347b874cb", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "51855b5c-c4eb-43a8-b3bb-8b1dbfab6e55", + "metadata": {}, + "source": [ + "### Q5:\n", + "Consider a directed graph G = (V, E) where V is a set of vertices and E is a set of edges. The graph has n vertices numbered from 1 to n. You have been given a task to implement a Depth-First Search (DFS) to traverse the graph and print the vertices in the order they are visited.\n", + "\n", + "You are given the following information:\n", + "- The graph may contain one or more connected components.\n", + "- Vertices are numbered, and the graph is represented using an adjacency list.\n", + "- It is guaranteed that there are no self-loops, i.e., there will be no edges from a vertex to itself.\n", + "- The graph may contain cycles.\n", + "\n", + "Write a Python function named `dfs_traversal` that takes an adjacency list representing the graph and a starting vertex as input and returns a list containing the vertices in the order they are visited by a Depth-First Search (DFS). If the graph has more than one connected component, your function should still return the vertices of all components in the order they are visited.\n", + "\n", + "### Function Signature:\n", + "```python\n", + "def dfs_traversal(adj_list: Dict[int, List[int]], start_vertex: int) -> List[int]:\n", + "```\n", + "\n", + "### Input:\n", + "- `adj_list` (1 <= len(adj_list) <= 1000) is a dictionary where the key is a vertex (int) and the value is a list of integers representing the adjacent vertices.\n", + "- `start_vertex` (1 <= start_vertex <= n) is an integer representing the starting vertex for the DFS.\n", + "\n", + "### Output:\n", + "- A list of integers representing the vertices in the order they are visited by DFS.\n", + "\n", + "### Example:\n", + "#### Input:\n", + "```python\n", + "adj_list = {\n", + " 1: [2],\n", + " 2: [3, 4],\n", + " 3: [],\n", + " 4: [5],\n", + " 5: [],\n", + " 6: [7],\n", + " 7: []\n", + "}\n", + "start_vertex = 1\n", + "```\n", + "\n", + "#### Output:\n", + "```python\n", + "[1, 2, 3, 4, 5, 6, 7]\n", + "```\n", + "\n", + "#### Explanation:\n", + "- Starting from vertex 1, the DFS visits vertices 2, 3, and 4, in this order.\n", + "- After completing the traversal for vertex 4, it goes back and visits vertex 5.\n", + "- Vertices 6 and 7 are in a different connected component, but they are also included in the output list as they are part of the overall graph.\n", + "\n", + "### Note:\n", + "You need to ensure that all vertices in the graph are visited, even if they are in different connected components. Also, take care to handle the case where cycles are present in the graph to avoid infinite loops. You can assume that the input graph is well-formed, and there are no isolated vertices (vertices not present in the adjacency list)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "26858d23-b7f2-498f-a144-795a90924a4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7]\n" + ] + } + ], + "source": [ + "def dfs_traversal(adj_list: dict, start_vertex: int) -> list:\n", + " visited = set()\n", + " result = []\n", + " \n", + " def dfs(vertex):\n", + " # If the vertex is visited, then return\n", + " if vertex in visited:\n", + " return\n", + " # Mark the vertex as visited\n", + " visited.add(vertex)\n", + " # Add the vertex to the result list\n", + " result.append(vertex)\n", + " # Visit all the adjacent vertices\n", + " for neighbor in adj_list.get(vertex, []):\n", + " dfs(neighbor)\n", + " \n", + " # Start the DFS from the given start_vertex\n", + " dfs(start_vertex)\n", + " \n", + " # Check for any unvisited vertices and traverse them as well\n", + " for vertex in adj_list.keys():\n", + " if vertex not in visited:\n", + " dfs(vertex)\n", + " \n", + " return result\n", + "\n", + "adj_list = {\n", + " 1: [2],\n", + " 2: [3, 4],\n", + " 3: [],\n", + " 4: [5],\n", + " 5: [],\n", + " 6: [7],\n", + " 7: []\n", + "}\n", + "\n", + "print(dfs_traversal(adj_list, 1))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e7a15f4-f77a-462f-be28-59740449901d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "e952bcd2-3719-4cc9-8219-e92260b9aa8d", + "metadata": {}, + "source": [ + "## Q6:\n", + "Consider an undirected graph G consisting of n vertices and m edges. An edge connects two distinct vertices, and there are no self-loops or multiple edges between the same pair of vertices.\n", + "\n", + "Which of the following statements is always true for an undirected graph with n vertices and m edges?\n", + "\n", + "A) If m > n, the graph must have a cycle. \n", + "B) If m < n, the graph must be disconnected. \n", + "C) The graph can have at most n(n - 1) / 2 edges. \n", + "D) If m = n, the graph is a tree.\n", + "\n", + "### Answer:\n", + "C) The graph can have at most n(n - 1) / 2 edges.\n", + "\n", + "### Explanation:\n", + "- A is incorrect because it’s possible to have a graph with more edges than vertices without forming a cycle. One possible counterproof is a star graph.\n", + "```\n", + " 1\n", + " /|\\\n", + " 2-4-3\n", + " \\|\n", + " 5\n", + "```\n", + " \n", + "- B is incorrect because even if the graph has fewer edges than vertices, it may still be connected. For example, a tree graph.\n", + "\n", + "```\n", + " 1 - 2 - 3\n", + "```\n", + "\n", + "- Option C is correct because an undirected graph can have at most n(n - 1) / 2 edges, which corresponds to a complete graph where every pair of distinct vertices is connected by a unique edge.\n", + "\n", + "- Option D is incorrect because even if a graph has the same number of edges as vertices, it may not be a tree. For example, a graph with 3 vertices and 3 edges forming a cycle is not a tree.\n", + "\n", + "```\n", + " 1 - 2\n", + " | /\n", + " 3\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f2528829-f6fc-4734-ada0-3627fc7cdd2c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "a4b02930-1720-4b9d-a949-d1af7bf84e50", + "metadata": { + "tags": [] + }, + "source": [ + "## Q7:\n", + "\n", + "Consider the two functions $f(n)$ and $g(n)$ defined as follows:\n", + "\n", + "$f(n) = 4n^2 + 100n + 1000$\n", + "\n", + "$g(n) = n^2$\n", + "\n", + "1. **Part A:** Using Big O notation, describe the upper bound of $f(n)$.\n", + "2. **Part B:** Is $f(n) = O(g(n))$? Justify your answer.\n", + "3. **Part C:** Given another function $(h(n) = 100n^3$, is $f(n) = O(h(n))$? Justify your answer.\n", + "\n", + "### Answer:\n", + "\n", + "1. **Part A:** $f(n)$ has an upper bound described by $O(n^2)$.\n", + "\n", + "2. **Part B:** Yes, because $f(n)$ has a highest degree term of $n^2$, and so does $g(n)$. Therefore, $g(n)$ is an upper bound for $f(n)$.\n", + "\n", + "3. **Part C:** Yes, $f(n) = O(h(n))$. Since $h(n) = 100n^3$, it grows at a cubic rate, which is faster than the quadratic rate at which $f(n)$ grows. So, $h(n)$ is an upper bound for $f(n)$ in terms of Big O notation, hence $f(n) = O(h(n)$.\n", + "A graph example from WolframAlpha: https://www.wolframalpha.com/input?i=intersect+of+x%5E3+and+x%5E2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ce130e2-22ba-4af5-92fe-b5033491fcc5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f4cf0139-0c4f-4c02-a6aa-335bfa600e2b", + "metadata": {}, + "source": [ + "### Q8:\n", + "\n", + "Consider a graph, G, consisting of vertices and edges. A vertex represents a point, and an edge represents a line connecting two vertices. A graph is “connected” if there is a path through edges from any vertex to any other vertex in the graph. \n", + "\n", + "Given the following graph, G:\n", + "\n", + "```\n", + " A — B\n", + " | / |\n", + " |/ |\n", + " C — D\n", + " |\n", + " E\n", + "```\n", + "\n", + "1. **List the vertices and edges in Graph G.**\n", + "2. **Is Graph G connected? Explain why or why not.**\n", + "3. **Find a path from Vertex A to Vertex E.**\n", + "\n", + "### Answer:\n", + "\n", + "1. Vertices: A, B, C, D, E\n", + " Edges: (A, B), (A, C), (B, C), (B, D), (C, D), (C, E)\n", + " \n", + "2. Yes, Graph G is connected. A graph is connected if there is a path from any vertex to any other vertex in the graph. In Graph G, we can reach any vertex from any other vertex through the available edges.\n", + "\n", + "3. A $\\rightarrow$ C $\\rightarrow$ E." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8cb583a-5e78-4b7a-9f31-94ce1836fa0c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f2219dad-9ad8-4ad0-9d5f-d6ee954b38f9", + "metadata": {}, + "source": [ + "## Q9:\n", + "\n", + "You are given a list of integers, and you are to write a function that finds the two elements in the list that sum up to a specific target. You need to return these two elements. If there are multiple pairs that match the target sum, you can return any of them. If no such pair exists, return an empty list. You are required to write a solution with a time complexity better than $O(n^2)$.\n", + "\n", + "### Example:\n", + "\n", + "```python\n", + "nums = [1, 2, 3, 4, 5]\n", + "target = 9\n", + "# Your function should return [4,5] (or [5,4]) since 4 + 5 = 9.\n", + "```\n", + "\n", + "### Constraints:\n", + "\n", + "- The list can have up to $10^5$ integers.\n", + "- The list and target will be such that a solution will always exist." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3732544d-1d5e-401c-8b53-4030e0564895", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5, 4]\n" + ] + } + ], + "source": [ + "def two_sum(nums, target):\n", + " seen = set()\n", + " for num in nums:\n", + " if target - num in seen:\n", + " return [num, target - num]\n", + " seen.add(num)\n", + " return []\n", + "\n", + "print(two_sum([1, 2, 3, 4, 5], 9))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4f0755d-b213-46de-871e-68a1e6c0e1a3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "8d9d0325-7912-4cce-a8f7-e96a76927991", + "metadata": {}, + "source": [ + "All summaries and reflections are included in Readme.md file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f94fbe2a-02ba-4fd4-8afd-b3ef5d322e4b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Submissions/Zihao_Liu_001567668/readme.md b/Submissions/Zihao_Liu_001567668/readme.md new file mode 100644 index 0000000..bb6a7d0 --- /dev/null +++ b/Submissions/Zihao_Liu_001567668/readme.md @@ -0,0 +1,20 @@ +First Name: "Zihao" +Last Name : "Liu" +NU_ID : "001567668" + +Assignment-1 : + +### How ChatGPT or the tool you used assisted in this task + +Question 1, 7, 9 are about big O notation. I created question 2, 3 regarding Stable matching. Question 4, 5, 6, 8 are graphs questions. I learned from ChatGPT on creating graph and how to use markdown language. +I want to emphasize how helpful ChatGPT is for helping me on Question 7. It is a tricky question because I was confused about part 3. The growth rate for cubic function should be faster than quadratic function but come with a conclusion that $h(n)$ is an upper bound of $h(n)$. ChatGPT gives me a deeper explanation regarding part 3 that $h(n)$ grows at least as fast as $f(n)$ but in this case it is faster. Because $h(n)$ will eventually outgrow the quadratic function for sufficiently large values of n, thus $h(n)$ can be considered as an upper bound for $f(n)$ in terms of Big O notation. This is really helpful for me to better understand the worst-case runtime of an algorithm. +WolframAlpha also helped me with generating a graph to show the relationship between 2 functions. + + +### Challenges you faced while ensuring the problem maintained the spirit of the example + +Question 1 is similar to the sample homework assignment 1 question 1 because I find out this question is helpful for me to understand the order of the functions. +Other questions are related to the topics we have covered in the past 3 weeks of lecture. However, not all of them are necessarily similar to the sample question. To ensure the problem maintained the spirit of the example, I will need to make sure to review the lecture material and create similar questions we have discussed in lecture and the Youtube video. These questions are helps me to review the topics we have covered in lecture pretty well. + +### What you learned about problem design in the realm of algorithms +Designing algorithm problems and coding questions for the assignment helps me to identify the learning objective for the specific topic. Using ChatGPT for designing problem is a good way to learn new knowledge. \ No newline at end of file