import java.util.Scanner; import java.util.Arrays; import java.util.List; import java.util.function.Function; import java.util.stream.IntStream; import java.util.Optional; import java.lang.IllegalArgumentException; /** *

* Takes a range of integers between first two parameters (inclusive), * applies an operation defined by third parameter and * prints sum of results. *

* *

* INPUT - String list of arguments separated by single spaces . * Takes first 3 values and ignores the rest. Format is a follows
*

Integer - lowest number in range (inclusive)
Integer - highest number in range (inclusive)
String - operation symbol and value of * second operand of operation, * for example "/2" or "+10"

* *

* OUTPUT - Integer sum of each integer in range after applying an operation * Examples: *

"1 5 +0" - 15 (1+2+3+4+5)
"1 5 +1" - 20 (2+3+4+5+6)
"3 6 *2" - 36 (6+8+10+12)
"2 5 /2" - 6 (1+1+2+2)
"1 4 !" - 33 (1+2+6+24)

* * *

* Following operations are allowed: *

Addition "+[value]" ("+2", "+10")
Subtraction "-[value]" ("-2", "-10")
Multiplication "*[value]" ("*2", "*10")
Division "/[value]" ("/2", "/10") "/0 will return error"
Factorial "!" (unary operator: only allows "!")
Modulo "%[value]" ("%2", "%10")

**/ public class Program { public static void main(String[] args) { String rawInput = new Scanner(System.in).nextLine(); List arguments = Arrays.asList( rawInput.split(" ") ); try{ Function< Integer,Integer > getResult = getOperation(arguments.get(2)); Optional operationSum = IntStream.range( Integer.valueOf(arguments.get(0)), Integer.valueOf(arguments.get(1))+1) .boxed() .map(value -> getResult.apply(value)) .reduce(Integer::sum); String result = operationSum .map(value -> String.valueOf(value)) .orElse("Could not calculate the answer"); System.out.println(result); } catch (IllegalArgumentException ex) { System.out.println(ex.getMessage()); return; } catch (IndexOutOfBoundsException ex){ System.out.println("List out of bounds: did you input enough arguments"); } } /** * Returns operation to do, curried with second operand if operation is binary. * * * @param operationString String composed of operation sign and second operand if function is binary * @return Function that takes first operand and returns result of operation * @throws IllegalArgumentException **/ private static Function< Integer,Integer > getOperation(String operationString) throws IllegalArgumentException{ try{ if(operationString.length() < 1) throw new IllegalArgumentException(); char operationChar = operationString.charAt(0); Optional operationValue = Optional.ofNullable(operationString.substring(1)) .filter(strValue -> !strValue.isEmpty()) .map(strValue -> Integer.valueOf(strValue)); if(operationValue.isPresent()){//binary operations switch(operationChar){ case '+': return (Integer inputVal) -> inputVal + operationValue.get(); case '-': return (Integer inputVal) -> inputVal - operationValue.get(); case '/': if(operationValue.get() == 0) throw new IllegalArgumentException(); return (Integer inputVal) -> inputVal / operationValue.get(); case '*': return (Integer inputVal) -> inputVal * operationValue.get(); case '%': return (Integer inputVal) -> inputVal % operationValue.get(); default: throw new IllegalArgumentException(); } } else{//unary operatios switch(operationChar){ case '!': return (Integer inputVal) -> factorial(inputVal); default: throw new IllegalArgumentException(); } } } catch(IllegalArgumentException ex){ throw new IllegalArgumentException(String.format("Illegal argument: \"%s\"", operationString)); } } private static Integer factorial(Integer value){ return (value <= 1)? 1 : value * factorial(value-1); } }

Summations 2: Functional Boogaloo