sarg · April 7, 2020 16:20
diff --git a/Problems.java b/Problems.java
 /*
 Mask all digits in credit card number unless they are first or last four characters.
 Never mask credit cards less than 6 characters
 */
 class CreditCard {
    /**
     * Mask credit card number for display.
     */
    public static String maskify(String creditCardNumber) {
        // Never mask credit cards with less than 6 characters.
        if (creditCardNumber.length() < 6) return creditCardNumber;

        char[] chars = creditCardNumber.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            // Mask all digits (0-9) with #, unless they are first or last four characters.
            if (i == 0 || i >= chars.length - 4) continue;
            
            // Never mask non-digit characters.
            if (chars[i] >= '0' && chars[i] <= '9') {
                chars[i] = '#';
            }
        }

        return new String(chars);
    }
 }


 /*
 Add ordinal indicator to a number as specified by english rules:
 https://en.wikipedia.org/wiki/English_numerals#Ordinal_numbers
 */
 class Challenge {
    
    /**
     * Append ordinal indicator to the given number.
     * @param number - natural number
     * @return string representation with ordinal indicator
     */
    public static String numberToOrdinal( Integer number ) {
        String suffix = number > 0 ? "th" : "";

        if ((number / 10) % 10 != 1) {
            switch (number % 10) {
                case 1: suffix = "st"; break;
                case 2: suffix = "nd"; break;
                case 3: suffix = "rd"; break;
            }
        }

        return number.toString() + suffix;
    }
 }


 import java.util.*;

 /*
 Implement RPN calculator. Allowed are +-*/ integers and floats. Return float.
 Ignore division by zero and possible stack errors.
 */
 public class Calc {
    private interface MathOps {
        float operation(float a, float b);   
    }
    
    private static void apply(Stack<Float> stack, MathOps math) {
        float op1 = stack.pop();
        float op2 = stack.pop();
        stack.push(math.operation(op2, op1));
    }

    /**
     * Evaluate RPN expression. Only + - * / on float/int arguments are supported.
     * All numbers are treated as floats so expect precision quirks.
     *
     * @param expr - reverse polish notation expression
     * @return evaluation result (last operation on stack)
     * @throws NumberFormatException for unknown tokens, e.g. "5 4 ."
     * @throws EmptyStackException for unbalanced expressions, e.g. "5 +"
     */
    public double evaluate(String expr) {
        StringTokenizer tokenizer = new StringTokenizer(expr, " ");
        
        Stack<Float> stack = new Stack<Float>(); 
        while (tokenizer.hasMoreTokens()) {
            String token = tokenizer.nextToken();
            switch (token) {
                case "+": apply(stack, (a, b) -> a + b); break;
                case "-": apply(stack, (a, b) -> a - b); break;
                case "*": apply(stack, (a, b) -> a * b); break; 
                case "/": apply(stack, (a, b) -> a / b); break;
                    
                default:
                    stack.push(Float.parseFloat(token));
            }
        }
        
        return stack.empty() ? 0 : stack.pop();
    }
	/*
	Mask all digits in credit card number unless they are first or last four characters.
	Never mask credit cards less than 6 characters
	*/
	class CreditCard {
	/**
	* Mask credit card number for display.
	*/
	public static String maskify(String creditCardNumber) {
	// Never mask credit cards with less than 6 characters.
	if (creditCardNumber.length() < 6) return creditCardNumber;

	char[] chars = creditCardNumber.toCharArray();
	for (int i = 0; i < chars.length; i++) {
	// Mask all digits (0-9) with #, unless they are first or last four characters.
	if (i == 0 \|\| i >= chars.length - 4) continue;

	// Never mask non-digit characters.
	if (chars[i] >= '0' && chars[i] <= '9') {
	chars[i] = '#';
	}
	}

	return new String(chars);
	}
	}


	/*
	Add ordinal indicator to a number as specified by english rules:
	https://en.wikipedia.org/wiki/English_numerals#Ordinal_numbers
	*/
	class Challenge {

	/**
	* Append ordinal indicator to the given number.
	* @param number - natural number
	* @return string representation with ordinal indicator
	*/
	public static String numberToOrdinal( Integer number ) {
	String suffix = number > 0 ? "th" : "";

	if ((number / 10) % 10 != 1) {
	switch (number % 10) {
	case 1: suffix = "st"; break;
	case 2: suffix = "nd"; break;
	case 3: suffix = "rd"; break;
	}
	}

	return number.toString() + suffix;
	}
	}


	import java.util.*;

	/*
	Implement RPN calculator. Allowed are +-*/ integers and floats. Return float.
	Ignore division by zero and possible stack errors.
	*/
	public class Calc {
	private interface MathOps {
	float operation(float a, float b);
	}

	private static void apply(Stack<Float> stack, MathOps math) {
	float op1 = stack.pop();
	float op2 = stack.pop();
	stack.push(math.operation(op2, op1));
	}

	/**
	* Evaluate RPN expression. Only + - * / on float/int arguments are supported.
	* All numbers are treated as floats so expect precision quirks.
	*
	* @param expr - reverse polish notation expression
	* @return evaluation result (last operation on stack)
	* @throws NumberFormatException for unknown tokens, e.g. "5 4 ."
	* @throws EmptyStackException for unbalanced expressions, e.g. "5 +"
	*/
	public double evaluate(String expr) {
	StringTokenizer tokenizer = new StringTokenizer(expr, " ");

	Stack<Float> stack = new Stack<Float>();
	while (tokenizer.hasMoreTokens()) {
	String token = tokenizer.nextToken();
	switch (token) {
	case "+": apply(stack, (a, b) -> a + b); break;
	case "-": apply(stack, (a, b) -> a - b); break;
	case "": apply(stack, (a, b) -> a b); break;
	case "/": apply(stack, (a, b) -> a / b); break;

	default:
	stack.push(Float.parseFloat(token));
	}
	}

	return stack.empty() ? 0 : stack.pop();
	}