Tasks Details
hard
1.
PetsAndToys
Each of N people has either a dog or a cat, and owns a toy for dog or for cat. Is it possible to exchange toys between acquaintances so that every animal gets an appropriate toy?
Task Score
100%
Correctness
100%
Performance
100%
During an Animal Day event, N people (numbered from 0 to N−1) showed up. Each of them had either a dog or a cat. The organizers decided to give them a wonderful gift: a toy for each animal.
After the event, it turned out that some people who owned a dog had received a cat-toy, and some people who owned a cat received a dog-toy. People may exchange toys, but only if they know each other (otherwise they have no way to contact the other person). The pair of people can exchange toys multiple times.
Knowing who knows who, who owns which animal, and what kind of toy he or she received, can you determine whether it is possible for people to exchange toys in such a way that every dog ends up with a dog-toy and every cat gets a cat-toy?
Write a function:
def solution(P, T, A, B)
that returns True if it is possible to exchange toys in such a way that every animal receives an appropriate toy, or False otherwise. First two arrays describe the pets (array P) and toys (array T) that every person owns. The J-th person owns pet P[J] and toy T[J] (1 means dog or dog-toy and 2 means cat or cat-toy). The next two arrays, A and B, both of length M, describe the relationships between people. For each integer K from 0 to M−1, person A[K] knows person B[K].
Examples:
1. Given:
P = [1, 1, 2] T = [2, 1, 1] A = [0, 2] B = [1, 1]the function should return True. Person 0 can exchange toys with person 1 to obtain a dog-toy, and then person 1 can exchange toys with person 2.
2. Given:
P = [2, 2, 1, 1, 1] T = [1, 1, 1, 2, 2] A = [0, 1, 2, 3] B = [1, 2, 0, 4]the function should return False. There is no way for persons 3 and 4 to exchange toys with others.
3. Given:
P = [1, 1, 2, 2, 1, 1, 2, 2] T = [1, 1, 1, 1, 2, 2, 2, 2] A = [0, 2, 4, 6] B = [1, 3, 5, 7]the function should return False. There is no way for persons 2 and 3 and for persons 4 and 5 to exchange toys with others.
4. Given:
P = [2, 2, 2, 2, 1, 1, 1, 1] T = [1, 1, 1, 1, 2, 2, 2, 2] A = [0, 1, 2, 3, 4, 5, 6] B = [1, 2, 3, 4, 5, 6, 7]the function should return True.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- M is an integer within the range [0..200,000];
- each element of arrays P and T is an integer that can have one of the following values: 1, 2;
- each element of arrays A and B is an integer within the range [0..N-1];
- for each integer K from 0 to M−1, elements A[K] and B[K] are different;
- there are no redundant elements in arrays A, B; more formally every unordered pair of persons a, b will appear as A[K], B[K] for at most one K.
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 40 minutes
Notes
not defined yet
Code: 20:14:23 UTC,
java,
autosave
Code: 20:18:14 UTC,
py,
autosave
Code: 20:18:33 UTC,
py,
autosave
Code: 20:18:44 UTC,
py,
autosave
Code: 20:20:12 UTC,
py,
autosave
Code: 20:20:22 UTC,
py,
autosave
Code: 20:20:52 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
pass
Code: 20:21:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]]
pass
Code: 20:21:57 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]]
pass
Code: 20:22:18 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].add(nodes[B[i]])
nodes[B[i]].add(nodes[A[i]])
pass
Code: 20:22:29 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
pass
Code: 20:22:43 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots =
Code: 20:22:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
Code: 20:23:07 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
node = Node()
Code: 20:23:17 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
node = nodes
Code: 20:23:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
nodes = set(nodes.values())
node = nodes
Code: 20:23:37 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
nodes = set(nodes.values())
node = nodes.
Code: 20:24:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
nodes = set(nodes.)
node = nodes.
Code: 20:24:21 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
nodes = set(nodes.keys())
node = nodes.
Code: 20:24:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
nodes = set(nodes.keys())
while nodes:
node = nodes.
Code: 20:24:45 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
nodes = set(nodes.keys())
while nodes:
node = nodes.pop()
node = nodes.
Code: 20:24:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:25:05 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:25:35 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
graph = []
keys = set(nodes.keys())
def iterate(node):
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:25:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
current.add(node)
for friend in node.friends:
iterate(friend)
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:26:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
key
current.add(node)
for friend in node.friends:
iterate(friend)
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:26:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:27:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
if not nodes:
return []
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
while keys:
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:27:20 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
if not nodes:
return []
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
while keys:
iterate(keys)
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:28:15 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
if not nodes:
return []
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
while keys:
iterate(nkeys)
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:28:25 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
if not nodes:
return []
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
while keys:
iterate(next(iter(keys)))
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:28:36 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
if not nodes:
return []
graph = []
current = []
keys = set(nodes.keys())
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
while keys:
iterate(next(iter(keys)))
graph.append(current)
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:29:05 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:29:20 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:29:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# asumes
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
roots = []
current = []
keys = set(nodes.keys())
while nodes:
node = nodes[keys.pop()]
node = nodes.
Code: 20:30:14 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
Code: 20:30:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
collections.Counter()
Code: 20:30:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.add(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pets for n in nodes])
toys = collections.Counter([n.toys for n in nodes])
if pets != toys:
return False
return True
Code: 20:31:38 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.add(nodes[B[i]])
nodes[B[i]].friends.add(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pets for n in nodes])
toys = collections.Counter([n.toys for n in nodes])
if pets != toys:
return False
return True
Code: 20:32:05 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(nodes[B[i]])
nodes[B[i]].friends.append(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pets for n in nodes])
toys = collections.Counter([n.toys for n in nodes])
if pets != toys:
return False
return True
Code: 20:32:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(nodes[next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(nodes[B[i]])
nodes[B[i]].friends.append(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pets for n in nodes])
toys = collections.Counter([n.toys for n in nodes])
if pets != toys:
return False
return True
Code: 20:32:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(nodes[next(iter(keys))])
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(nodes[B[i]])
nodes[B[i]].friends.append(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pets for n in nodes])
toys = collections.Counter([n.toys for n in nodes])
if pets != toys:
return False
return True
Code: 20:33:00 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(nodes[next(iter(keys))])
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(nodes[B[i]])
nodes[B[i]].friends.append(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pet for n in nodes])
toys = collections.Counter([n.toy for n in nodes])
if pets != toys:
return False
return True
Code: 20:35:38 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(nodes[next(iter(keys))])
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(odes[B[i]])
nodes[B[i]].friends.append(nodes[A[i]]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pet for n in nodes])
toys = collections.Counter([n.toy for n in nodes])
if pets != toys:
return False
return True
Code: 20:35:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(node):
if node.person not in keys:
return
keys.remove(node.person)
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(nodes[next(iter(keys))])
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pet for n in nodes])
toys = collections.Counter([n.toy for n in nodes])
if pets != toys:
return False
return True
Code: 20:36:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
node = nodes[person]
current.append(node)
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pet for n in nodes])
toys = collections.Counter([n.toy for n in nodes])
if pets != toys:
return False
return True
Code: 20:36:26 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
node = nodes[person]
for friend in node.friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pet for n in nodes])
toys = collections.Counter([n.toy for n in nodes])
if pets != toys:
return False
return True
Code: 20:36:36 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for nodes in graph:
pets = collections.Counter([n.pet for n in nodes])
toys = collections.Counter([n.toy for n in nodes])
if pets != toys:
return False
return True
Code: 20:37:00 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:38:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:38:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:39:06 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:40:00 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Analysis
Code: 20:40:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:40:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
if not nodes:
return []
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:40:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:41:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
# find th
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:41:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:41:38 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i]) # Is it transitive???
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:42:14 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:42:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
graph = buildGraph(nodes)
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:43:12 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = buildGraph(nodes)
# check that each connected social graph has the same
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:43:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def buildGraph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = buildGraph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:43:57 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = buildGraph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:44:07 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:46:36 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:47:06 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
nexts = []
graph.append(current)
return graph
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:47:18 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
nexts = [next(iter(keys))]
while nexts:
graph.append(current)
return graph
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:47:38 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
candidates = [next(iter(keys))]
while candidates:
candidate = candidates.pop()
graph.append(current)
return graph
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:47:51 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
candidates = [next(iter(keys))]
while candidates:
candidate = candidates.pop()
if candidate not in keys:
continue
keys.remove(candidate)
graph.append(current)
return graph
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:48:09 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
candidates = [next(iter(keys))]
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend()
graph.append(current)
return graph
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:48:24 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
candidates = [next(iter(keys))]
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:48:36 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
candidates = [next(iter(keys))]
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
'''
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
'''
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:48:40 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
graph = []
while keys:
current = []
candidates = [next(iter(keys))]
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
'''
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
'''
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Analysis
Code: 20:49:13 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fil
graph = []
while keys:
current = []
candidates = [next(iter(keys))]
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
'''
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
'''
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:49:30 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
'''
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
'''
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:49:40 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
#
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
'''
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
'''
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:49:51 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
# depth-first traversal through the nodes
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
'''
keys = set(nodes.keys())
current = []
def iterate(person):
# recurse to find all the people in this section of the social graph
if person not in keys:
return
keys.remove(person)
current.append(person)
for friend in nodes[person].friends:
iterate(friend)
# fill in a list of connected social graphs
graph = []
while keys:
# find the next (arbitrary) connected social graph
iterate(next(iter(keys)))
graph.append(current)
current = []
return graph
'''
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:50:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
# depth-first traversal through the nodes
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:52:38 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
# depth-first traversal through the nodes
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Analysis
Code: 20:53:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
# depth-first traversal through the nodes
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
Code: 20:53:07 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
# depth-first traversal through the nodes
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
User test case 1:
[[], [], [], []]
Analysis
Code: 20:53:35 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
# depth-first traversal through the nodes
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return True
User test case 1:
[[], [], [], []]
Analysis
Code: 20:53:38 UTC,
py,
final,
score:
100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import collections
Node = collections.namedtuple('Node', ['person', 'pet', 'toy', 'friends'])
def build_graph(nodes):
# assumes undirected graph, i.e. contact info is two-way
keys = set(nodes.keys())
# fill in a list of connected social graphs
graph = []
while keys:
# build the current social graph based on an arbitrary (remaining) starting node
current = []
candidates = [next(iter(keys))]
# depth-first traversal through the nodes
while candidates:
person = candidates.pop()
if person not in keys:
continue
keys.remove(person)
current.append(person)
candidates.extend(nodes[person].friends)
graph.append(current)
return graph
def solution(P, T, A, B):
# write your code in Python 3.6
nodes = {}
# create each person node with no friends
for i in range(len(P)):
nodes[i] = Node(i, P[i], T[i], [])
# fill in the friendships
for i in range(len(A)):
nodes[A[i]].friends.append(B[i])
nodes[B[i]].friends.append(A[i])
# find all the connected social graphs (for trading toys)
graph = build_graph(nodes)
# check that each connected social graph has the same number of pets as toys for each animal type
for persons in graph:
pets = collections.Counter([nodes[p].pet for p in persons])
toys = collections.Counter([nodes[p].toy for p in persons])
if pets != toys:
return False
return TrueAnalysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N+M)
expand all
Correctness tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
expand all
Performance tests
1.
0.304 s
OK
2.
0.308 s
OK
3.
0.328 s
OK
4.
0.320 s
OK
5.
0.332 s
OK
1.
1.200 s
OK
2.
1.172 s
OK
3.
1.196 s
OK
4.
1.144 s
OK
1.
0.896 s
OK
2.
0.832 s
OK
3.
0.836 s
OK
4.
0.812 s
OK
1.
1.248 s
OK
2.
1.152 s
OK
3.
1.176 s
OK
4.
1.228 s
OK