Infosys FA1 Mock Assessment

package pfusingjava1;

public class Solution {

    public static String tokenValidation(String input) {
        if (input == null || input.isEmpty()) {
            return "invalid";
        }

        int firstDollar = input.indexOf('$');
        int lastDollar = input.lastIndexOf('$');

        // Must have exactly one '$'
        if (firstDollar == -1 || firstDollar != lastDollar) {
            return "invalid";
        }

        String part1 = input.substring(0, firstDollar);
        String part2 = input.substring(firstDollar + 1);

        // Both parts must be non-empty
        if (part1.isEmpty() || part2.isEmpty()) {
            return "invalid";
        }

        boolean part1Valid = part1.matches("^[a-z]+$");
        boolean part2Valid = part2.matches("^[0-9]+$");

        if (part1Valid && part2Valid) {
            return part1 + "_valid";
        } else {
            return part1 + "_invalid";
        }
    }
}

package pfusingjava2;

public class Solution {

    public static String[] auditBatches(int[] actualArr, int[] thresholdArr) {
        if (actualArr == null || thresholdArr == null) {
            return new String[0];
        }

        String[] outArr = new String[actualArr.length];

        for (int i = 0; i < actualArr.length; i++) {
            if (actualArr[i] >= thresholdArr[i]) {
                outArr[i] = actualArr[i] + "_RELEASED";
            } else {
                outArr[i] = actualArr[i] + "_REJECTED";
            }
        }

        return outArr;
    }
}

public class Employee extends Certification {
    private static String[][] courseTypeArr = {
        {"Concept Based", "Hands-On", "Hybrid"},
        {"200.0", "500.0", "1000.0"}
    };
    private String employeeName;
    private String employeeType;
    private String orgName;
    private String reqCourseType;

    public Employee(Course course, String modeOfCertification, String employeeName, 
                    String employeeType, String orgName, String reqCourseType) {
        super(course, modeOfCertification);
        this.employeeName = employeeName;
        this.employeeType = employeeType;
        this.orgName = orgName;
        this.reqCourseType = reqCourseType;
    }

    public boolean validateEmployee() {
        return employeeName != null && !employeeName.isEmpty();
    }

    // 1. Enhanced identifyDiscountPercent
    public Integer identifyDiscountPercent(Certification certification) {
        int discount = 0;
        if (this.validateEmployee()) {
            discount = 10;
        } else {
            return 0;
        }

        // Additional 5% discount if mode fee >= 350
        if (certification.identifyModeOfCertificationFee() >= 350) {
            discount += 5;
        }

        // Additional discount based on course fee
        int courseFee = certification.getCourse().identifyCourseFee();
        if (courseFee >= 4500) {
            discount += 10;
        } else if (courseFee >= 3500) {
            discount += 8;
        } else if (courseFee >= 2500) {
            discount += 5;
        }

        return discount;
    }

    // 2. Implemented calculateTotalFee
    public void calculateTotalFee(Certification certification) {
        double courseFee = certification.getCourse().identifyCourseFee();
        int basicFee = 5000;

        if (this.validateEmployee() && courseFee != -1.0) {
            double cost = 0.0;

            // Case-sensitive comparison in courseTypeArr
            for (int i = 0; i < courseTypeArr[0].length; i++) {
                if (courseTypeArr[0][i].equals(this.reqCourseType)) {
                    cost = Double.parseDouble(courseTypeArr[1][i]);
                    break;
                }
            }

            cost = cost + basicFee + courseFee;

            // Case-insensitive comparison for Trainee & Infosys deduction
            if ("Trainee".equalsIgnoreCase(this.employeeType) && "Infosys".equalsIgnoreCase(this.orgName)) {
                cost -= 2000.0;
            }

            certification.setCertificationFee(cost);
            certification.generateCertificationId();
        } else {
            certification.setCertificationFee(-1.0);
            certification.setCertificationId("NA");
        }
    }
}

package dsausingjava;

import java.util.*;

public class Solution {

    public static ArrayDeque classifyCoupons(ArrayDeque allowedQueue, ArrayList blockedList) {
        ArrayDeque outQueue = new ArrayDeque<>();

        if (allowedQueue == null || allowedQueue.isEmpty()) {
            return outQueue;
        }

        // Count frequency of coupons in allowedQueue
        Map freq = new HashMap<>();
        for (Integer c : allowedQueue) {
            freq.put(c, freq.getOrDefault(c, 0) + 1);
        }

        // Stack used as temporary data structure for LIFO reverse order
        Stack tempStack = new Stack<>();

        for (Integer coupon : allowedQueue) {
            boolean moreThanOnce = freq.get(coupon) > 1;
            boolean isBlocked = (blockedList != null && blockedList.contains(coupon));

            if (moreThanOnce && !isBlocked) {
                tempStack.push(coupon + "_EC");
            } else {
                outQueue.add(coupon + "_IC");
            }
        }

        // Append in reverse order
        while (!tempStack.isEmpty()) {
            outQueue.add(tempStack.pop());
        }

        return outQueue;
    }
}