Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Implemented all methods #916

Open
wants to merge 5 commits into
base: main
Choose a base branch
from
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
28 changes: 26 additions & 2 deletions src/main/java/practice/CandidateValidator.java
Original file line number Diff line number Diff line change
@@ -1,5 +1,29 @@
package practice;

public class CandidateValidator {
//write your code here
import java.util.function.Predicate;
import model.Candidate;

public class CandidateValidator implements Predicate<Candidate> {
private static final int MIN_CANDIDATE_AGE = 35;
private static final int MIN_PERIOD_IN_UKRAINE = 10;

private static final String SPLIT_REGEX_HYPHEN = "-";
private static final int STAR_YEAR_INDEX = 0;
private static final int END_YEAR_INDEX = 1;
private static final String NEEDED_NATIONALITY = "Ukrainian";

@Override
public boolean test(Candidate candidate) {
if (candidate.isAllowedToVote()
&& candidate.getAge() >= MIN_CANDIDATE_AGE
&& candidate.getNationality().equals(NEEDED_NATIONALITY)) {
String[] inUkrYears = candidate.getPeriodsInUkr().split(SPLIT_REGEX_HYPHEN);
int startYear = Integer.parseInt(
inUkrYears[STAR_YEAR_INDEX]);
int endYear = Integer.parseInt(
inUkrYears[END_YEAR_INDEX]);
return endYear - startYear >= MIN_PERIOD_IN_UKRAINE;
}
return false;
}
}
121 changes: 65 additions & 56 deletions src/main/java/practice/StreamPractice.java
Original file line number Diff line number Diff line change
@@ -1,80 +1,89 @@
package practice;

import java.util.Collections;
import java.util.Arrays;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.function.Predicate;
import java.util.stream.IntStream;
import model.Candidate;
import model.Cat;
import model.Person;
import model.Person.Sex;

public class StreamPractice {
/**
* Given list of strings where each element contains 1+ numbers:
* input = {"5,30,100", "0,22,7", ...}
* return min integer value. One more thing - we're interested in even numbers.
* If there is no needed data throw RuntimeException with message
* "Can't get min value from list: < Here is our input 'numbers' >"
*/
private static final String NO_MIN_VALUE_EXCEPTION_MESSAGE = "Can't get min value from list: ";
private static final String EMPTY_LIST_EXCEPTION_MESSAGE = "Empty List provided";
private static final String SPLIT_REGEX_COMA = ",";
private final Predicate<Candidate> isAbleToRunForPresident = new CandidateValidator();

public int findMinEvenNumber(List<String> numbers) {
return 0;
return numbers.stream()
.map(stringNumber -> stringNumber.split(SPLIT_REGEX_COMA))
.flatMap(Arrays::stream)
.map(Integer::parseInt)
.filter(number -> !isOddNumber(number))
.sorted()
.findFirst()
.orElseThrow(() -> new RuntimeException(NO_MIN_VALUE_EXCEPTION_MESSAGE + numbers));
}

/**
* Given a List of Integer numbers,
* return the average of all odd numbers from the list or throw NoSuchElementException.
* But before that subtract 1 from each element on an odd position (having the odd index).
*/
public Double getOddNumsAverage(List<Integer> numbers) {
return 0D;
return IntStream.range(0, numbers.size())
.map(index -> {
Integer numByIndex = numbers.get(index);
return isOddNumber(index) ? numByIndex - 1 : numByIndex;
})
.filter(number -> isOddNumber(number))
.average()
.orElseThrow(() -> new NoSuchElementException(EMPTY_LIST_EXCEPTION_MESSAGE));
}

/**
* Given a List of `Person` instances (having `name`, `age` and `sex` fields),
* for example, `Arrays.asList( new Person(«Victor», 16, Sex.MAN),
* new Person(«Helen», 42, Sex.WOMAN))`,
* select from the List only men whose age is from `fromAge` to `toAge` inclusively.
* <p>
* Example: select men who can be recruited to army (from 18 to 27 years old inclusively).
*/
public List<Person> selectMenByAge(List<Person> peopleList, int fromAge, int toAge) {
return Collections.emptyList();
return peopleList.stream()
.filter(person -> {
int personAge = person.getAge();
return personAge >= fromAge
&& personAge <= toAge
&& Sex.MAN.equals(person.getSex());
})
.toList();
}

/**
* Given a List of `Person` instances (having `name`, `age` and `sex` fields),
* for example, `Arrays.asList( new Person(«Victor», 16, Sex.MAN),
* new Person(«Helen», 42, Sex.WOMAN))`,
* select from the List only people whose age is from `fromAge` and to `maleToAge` (for men)
* or to `femaleToAge` (for women) inclusively.
* <p>
* Example: select people of working age
* (from 18 y.o. and to 60 y.o. for men and to 55 y.o. for women inclusively).
*/
public List<Person> getWorkablePeople(int fromAge, int femaleToAge,
int maleToAge, List<Person> peopleList) {
return Collections.emptyList();
public List<Person> getWorkablePeople(int fromAge, int femaleToAge, int maleToAge,
List<Person> peopleList) {
Predicate<Person> isWorkable = person -> {
int personAge = person.getAge();
if (Sex.MAN.equals(person.getSex())) {
return personAge >= fromAge
&& personAge <= maleToAge;
}
return personAge >= fromAge
&& personAge <= femaleToAge;
};
return peopleList.stream()
.filter(isWorkable)
.toList();
}

/**
* Given a List of `Person` instances (having `name`, `age`, `sex` and `cats` fields,
* and each `Cat` having a `name` and `age`),
* return the names of all cats whose owners are women from `femaleAge` years old inclusively.
*/
public List<String> getCatsNames(List<Person> peopleList, int femaleAge) {
return Collections.emptyList();
Predicate<Person> isNeededCatOwner = person -> Sex.WOMAN.equals(person.getSex())
&& person.getAge() >= femaleAge;
return peopleList.stream()
.filter(isNeededCatOwner)
.flatMap(person -> person.getCats().stream())
.map(Cat::getName)
.toList();
}

/**
* Your help with a election is needed. Given list of candidates, where each element
* has Candidate.class type.
* Check which candidates are eligible to apply for president position and return their
* names sorted alphabetically.
* The requirements are: person should be older than 35 years, should be allowed to vote,
* have nationality - 'Ukrainian'
* and live in Ukraine for 10 years. For the last requirement use field periodsInUkr,
* which has following view: "2002-2015"
* We want to reuse our validation in future, so let's write our own impl of Predicate
* parametrized with Candidate in CandidateValidator.
*/
public List<String> validateCandidates(List<Candidate> candidates) {
return Collections.emptyList();
return candidates.stream()
.filter(isAbleToRunForPresident)
.map(Candidate::getName)
.sorted()
.toList();
}

private boolean isOddNumber(int number) {
return number % 2 != 0;
}
}
Loading