练题--2023-优快云博客

这是一个Java程序，用于管理购物系统的优惠活动。PromotionSys类包含添加优惠(addPromotion)，处理优惠(processPromotion)以及查询剩余优惠数量(queryRemainingNum)等方法。processPromotion方法根据日期、商品目录和价格选择适用的最大优惠，考虑了优惠的有效期和价格限制。

package untitled.KunZai;

import untitled.TestUtils;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * 购物系统，其中activityId 活动ID;
 * startDate;优惠开始时间 endDate：优惠结束时间
 * category：商品目录；number优惠数量 priceLimit 可使用优惠的价格
 * discount 优惠价格，
 * 实现三个方法：
 * addPromotion：添加优惠，如果优惠活动ID已存在则直接返回false，如果不存在则添加成功，返回true
 * processPromotion：根据日期，商品目录，优惠购物价格
 * 1.价格大于优惠价格才能使用优惠券，否则返回原价；
 * 2.首先使用优惠最大的，其次优惠有效日期最近的，最后活动ID最小的
 * 3.使用优惠活动后，优惠活动数量减一
 * queryRemainingNum：根据日期和活动ID查询剩余的优惠数量
 * 如：
 * 输入：[“PromotionSys”,“addPromotion”,“processPromotion”,“queryRemainingNum”]
 * [[],[0,1,2,5,3,100,10],[1,5,210],[2,0]]
 * 输出 ：[null,true,200,2]
 * <p>
 * 输入：
 * [“PromotionSys”,“addPromotion”,“processPromotion”,“processPromotion”,“processPromotion”,“addPromotion”,“queryRemainingNum”,“processPromotion”,“addPromotion”,“addPromotion”,“processPromotion”,“queryRemainingNum”,“queryRemainingNum”,“addPromotion”]
 * [[],[0,1,3,5,1,20,10],[1,5,16],[2,5,25],[2,2,50],[1,2,7,5,2,10,6],[2,0],[2,5,22],[15,4,5,5,2,7,6],[2,4,5,5,20,7,6],[4,5,30],[5,2],[8,1],[0,2,2,4,3,10,5]]
 * 输出：[null,true,16,15,50,true,0,16,true,true,24,19,0,false]
 */
class PromotionSys {
    private ArrayList<Activity> activityList = new ArrayList<>();
    private HashMap<Integer, Activity> activityMap = new HashMap<Integer, Activity>();


    public PromotionSys() {
    }

    public boolean addPromotion(Activity activity) {
        if (activity == null) {
            return false;
        }
        if (!activityMap.containsKey(activity.activityId)) {
            activityList.add(activity);
            activityMap.put(activity.activityId, activity);
            return true;
        } else {
            return false;
        }
    }

    public int processPromotion(int date, int category, int price) {
        ArrayList<Activity> useList = new ArrayList<>();
        ArrayList<Activity> tmpList = new ArrayList<>();

        for (Activity activity : activityList) {
            if (activity.category == category && price > activity.priceLimit && date >= activity.startDate
                    && date <= activity.endDate && activity.number > 0) {
                useList.add(activity);
            }
        }

        // find max discount
        int maxDiscount = -1;
        for (Activity activity : useList) {
            if (activity.discount > maxDiscount) {
                maxDiscount = activity.discount;
                tmpList.clear();
                tmpList.add(activity);
            } else if (activity.discount == maxDiscount) {
                tmpList.add(activity);
            }
        }
        useList = tmpList;
        if (useList.size() == 1) {
            Activity activity = useList.get(0);
            activity.number -= 1;
            return price - activity.discount;
        }

        // find nearest date
        int minDateGap = Integer.MAX_VALUE;
        for (Activity activity : useList) {
            int dateGap = date - activity.endDate;
            if (dateGap < minDateGap) {
                minDateGap = dateGap;
                tmpList.clear();
                tmpList.add(activity);
            } else if (dateGap == minDateGap) {
                tmpList.add(activity);
            }
        }
        useList = tmpList;
        if (useList.size() == 1) {
            Activity activity = useList.get(0);
            activity.number -= 1;
            return price - activity.discount;
        }

        // find min activityId
        int minActivityId = Integer.MAX_VALUE;
        Activity suitableActivity = null;
        for (Activity activity : useList) {
            if (activity.activityId < minActivityId) {
                minActivityId = activity.activityId;
                suitableActivity = activity;
            } else if (activity.activityId == minDateGap) {
                throw new RuntimeException();
            }
        }

        if (suitableActivity != null) {
            suitableActivity.number -= 1;
            return price - suitableActivity.discount;
        }

        // never arrive
        return -1;
    }


    public int queryRemainingNum(int date, int activityId) {
        if (!activityMap.isEmpty()) {
            Activity activity = activityMap.get(activityId);
            if (date >= activity.startDate && date <= activity.endDate) {
                return activity.number;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        PromotionSys promotionSys = new PromotionSys();

        String action = "[“PromotionSys”,“addPromotion”,“processPromotion”,“queryRemainingNum”]";
        String param = "[[],[0,1,2,5,3,100,10],[1,5,210],[2,0]]";

        String[] doMethods = TestUtils.parseArraySurround(action);
        int[][] params = TestUtils.parse2DArrayToInt(param);

        Method[] declaredMethods = promotionSys.getClass().getDeclaredMethods();
        HashMap<String, Method> methodMap = new HashMap<>();
        for (int i = 0; i < declaredMethods.length; i++) {
            methodMap.put(declaredMethods[i].getName(), declaredMethods[i]);
        }

        // 假设我还不知道是哪个函数，但我想根据传入的函数名调用
        for (int i = 0; i < doMethods.length; i++) {
            Method method = methodMap.get(doMethods[i]);
            try {
                method.invoke(method.getName(), (Object) params[i]);
            } catch (IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}

class Activity {
    int activityId;
    int startDate;
    int endDate;
    int category;
    int number;
    int priceLimit;
    int discount;

    public Activity(int activityId, int startDate, int endDate,
                    int category, int number, int priceLimit, int discount) {
        this.activityId = activityId;
        this.startDate = startDate;
        this.endDate = endDate;
        this.category = category;
        this.number = number;
        this.priceLimit = priceLimit;
        this.discount = discount;
    }
}

package untitled;

import java.util.ArrayList;

/**
 * 功能描述
 *
 * @author x00617569
 * @since 2023-01-05
 */
public class TestUtils {
    /**
     * @param strings
     * @return
     */
    public static String[][] parse2DArray(String source) {
        char[] chars = source.toCharArray();
        ArrayList<ArrayList<String>> Array = new ArrayList<>();
        ArrayList<String> subArray = new ArrayList<>();
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == '[') {
                stringBuilder = new StringBuilder();
            } else if (chars[i] == ']') {
                Array.add(subArray);
                subArray = new ArrayList<>();
            } else if (chars[i] == ',') {
                subArray.add(stringBuilder.toString());
                stringBuilder = new StringBuilder();
            } else {
                stringBuilder.append(chars[i]);
            }
        }

        String[][] result = new String[Array.size()][];
        for (int i = 0; i < Array.size(); i++) {
            ArrayList<String> array = Array.get(i);
            result[i] = new String[array.size()];
            for (int j = 0; j < array.size(); j++) {
                result[i][j] = array.get(j);
            }
        }

        return result;
    }

    public static int[][] parse2DArrayToInt(String source) {
        String[][] string = parse2DArray(source);
        int[][] result = new int[string.length][];
        for (int i = 0; i < string.length; i++) {
            for (int j = 0; j < string[i].length; j++) {
                if(string[i][j] != null && !string[i][j].equals("")){
                    result[i][j] = Integer.parseInt(string[i][j]);
                }
            }
        }
        return result;
    }

    public static String[] parseArray(String source) {
        char[] chars = source.toCharArray();
        ArrayList<String> list = new ArrayList<>();
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == '[') {
                stringBuilder = new StringBuilder();
            } else if (chars[i] == ']') {
                break;
            } else if (chars[i] == ',') {
                list.add(stringBuilder.toString());
                stringBuilder = new StringBuilder();
            } else {
                stringBuilder.append(chars[i]);
            }
        }

        String[] array = new String[list.size()];
        for (int i = 0; i < array.length; i++) {
            array[i] = list.get(i);
        }

        return array;
    }

    public static String[] parseArraySurround(String source) {
        String[] strings = parseArray(source);
        String[] result = new String[strings.length];
        for (int i = 0; i < result.length; i++) {
            result[i] = strings[i].substring(1, strings[i].length() - 1);
        }
        return result;
    }
}