Challenge Result
Solutions : 1 using Java, 3 using python.
Expected Soultion / My Solution was as below. (full code for Java can be found in the wiki)
/**
* <ol>
* <li>Get a Stream</li>
* <li>Group By Age</li>
* <li>Map The Value To Name instead of a Person</li>
* <li>Collect it in a Set</li>
* </ol>
*/
static Map<Integer, Set<String>> personsGroupedByAgeShowingNames(List<Person> persons) {
return persons.stream().collect(groupingBy(Person::getAge, mapping(Person::getName, toSet())));
}
/**
* <ol>
* <li>Get a Stream</li>
* <li>Group By Name</li>
* <li>Map The Value To Age instead of a Person</li>
* <li>Collect it in a Set</li>
* </ol>
*/
static Map<String, Set<Integer>> personsGroupedByNameShowingAges(List<Person> persons) {
return persons.stream().collect(groupingBy(Person::getName, mapping(Person::getAge, toSet())));
}So measuring form r of return till end (exlcuding semicolon) and replacing nicely named person to p
personsGroupedByAgeShowingNames == 88 Characters
return p.stream().collect(groupingBy(Person::getAge, mapping(Person::getName, toSet())))
personsGroupedByNameShowingAges == 88 Characters
return p.stream().collect(groupingBy(Person::getName, mapping(Person::getAge, toSet())))
- Winning Solution From Eduard Frank : 1st Prize
Map personsGroupedByNameShowingAges(List<Person> p) {
return p.stream().collect(groupingBy(Person::getName, mapping(Person::getAge, toSet())));
}
Map personsGroupedByAgeShowingNames(List<Person> p) {
return p.stream().collect(groupingBy(Person::getAge, mapping(Person::getName, toSet())));
}personsGroupedByAgeShowingNames == 88 Characters
return p.stream().collect(groupingBy(Person::getAge, mapping(Person::getName, toSet())))
personsGroupedByNameShowingAges == 88 Characters
return p.stream().collect(groupingBy(Person::getName, mapping(Person::getAge, toSet())))
*Disclaimer! *
- Solution from Jonas : 2nd Prize
from collections import namedtuple
from typing import Dict, Set, Sequence
Person = namedtuple("Person", ("name", "age"))
persons = [
Person("John", 15),
Person("Jane", 20),
Person("Bob", 23),
Person("Charlie", 30),
Person("Dave", 50),
Person("Json", 14),
Person("Taylor", 14),
Person("Dennis", 50),
Person("Brian", 50),
Person("Dorian", 23),
Person("Julian", 27),
Person("Json", 14),
Person("Donna", 25),
Person("Maria", 21),
Person("Dave", 50),
Person("Sara", 50),
Person("Charlie", 50),
Person("Bob", 50),
Person("Martin", 25),
Person("Trisha", 50),
Person("Donna", 25),
Person("Adam", 50),
Person("Sebastian", 50),
Person("Markus", 25),
Person("Jane", 21),
]
def names_by_age(data: Sequence[Person]) -> Dict[int, Set[str]]:
result = {person.age: set() for person in persons}
for person in data:
result[person.age].update({person.name})
return result
def ages_by_name(data: Sequence[Person]) -> Dict[str, Set[int]]:
result = {person.name: set() for person in persons}
for person in data:
result[person.name].update({person.age})
return result
def test():
print(names_by_age(persons))
print()
print(ages_by_name(persons))personsGroupedByAgeShowingNames == 100 Characters (excluding result = 91 Characters)
result = {p.age: set() for p in persons} for p in data: result[p.age].update({p.name}) return result
personsGroupedByNameShowingAges == 101 Characters (excluding result = 92 Characters)
result = {p.name: set() for p in persons} for p in data: result[p.name].update({p.age}) return result
- Also submitted by Rostik (Solution was correct, lost by characters)
person_list = [("John", 15),
("Jane", 20),
("Bob", 23),
("Charlie", 30),
("Dave", 50),
("Json", 14),
("Taylor", 14),
("Dennis", 50),
("Brian", 50),
("Dorian", 23),
("Julian", 27),
("Json", 14),
("Donna", 25),
("Maria", 21),
("Dave", 50),
("Sara", 50),
("Charlie", 50),
("Bob", 50),
("Martin", 25),
("Trisha", 50),
("Donna", 25),
("Adam", 50),
("Sebastian", 50),
("Markus", 25),
("Jane", 21)]
def age_to_name(p_list):
age_to_name = {}
for i in p_list:
if i[1] not in age_to_name: age_to_name[i[1]] = [i[0]]
elif i[0] not in age_to_name[i[1]]: age_to_name[i[1]].append(i[0])
return age_to_name
def name_to_age(a_to_n_list):
return {n:[i for i in a_to_n_list.keys() if n in a_to_n_list[i]] for k, n in a_to_n_list.items() for n in n}
print(age_to_name(person_list))
print(name_to_age(age_to_name(person_list)))personsGroupedByAgeShowingNames == 114 Characters (excluding p = {} 107 Characters) :: Also a bit hard to read then previous (ignoring the age_to_name changes to p)
p = {} for i in p_list: if i[1] not in p: p[i[1]] = [i[0]] elif i[0] not in p[i[1]]: p[i[1]].append(i[0]) return p
personsGroupedByNameShowingAges == 78 Characters (excluding return 71 Characters)
return {n:[i for i in p.keys() if n in p[i]] for k, n in p.items() for n in n}
Disclaimer! Above result though is more concise than even the Java one, in total it is more characters while being hard to read. (at leat for me who know a little bit on Python! ) Disclaimer! Also Rostik made a mistake initially and then corrected his solution
- Fourth entry was from Gregor but missed the Set (so no duplicates part)
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
SOME_PERSONS = [Person("John", 15), Person("Jane", 20), Person("Bob", 23), Person("Charlie", 30), Person("Dave", 50),
Person("Json", 14), Person("Taylor", 14), Person("Dennis", 50), Person("Brian", 50),
Person("Dorian", 23), Person("Julian", 27), Person("Json", 14), Person("Donna", 25),
Person("Maria", 21), Person("Dave", 50), Person("Sara", 50), Person("Charlie", 50), Person("Bob", 50),
Person("Martin", 25), Person("Trisha", 50), Person("Donna", 25), Person("Adam", 50),
Person("Sebastian", 50), Person("Markus", 25), Person("Jane", 21)]
def persons_by_age(ps): return {p.age: [x.name for x in ps if x.age == p.age] for p in ps}
def persons_by_name(ps): return {p.name: list(set([x.age for x in ps if x.name == p.name])) for p in ps}
print(persons_by_age(SOME_PERSONS))
print(persons_by_name(SOME_PERSONS))Characters are then not counted :) But nice try!
return {p.age: [x.name for x in ps if x.age == p.age] for p in ps}
return {p.name: list(set([x.age for x in ps if x.name == p.name])) for p in ps}
