Merge branch 'master' of https://github.com/JoshuaJiangFD/leetcode-in-java

Author: jiangyong07

src/main/java/joshua/oop/callcenter/Call.java

@@ -0,0 +1,53 @@
+package joshua.oop.callcenter;
+
+/**
+ * Represents a call from a user. Calls have a minimum rank and are assigned to the
+ * first employee who can handle that call.
+ */
+public class Call {
+    /* Minimal rank of employee who can handle this call. */
+    private Rank rank;
+
+    /* Person who is calling. */
+    private Caller caller;
+
+    /* Employee who is handling call. */
+    private Employee handler;
+
+    public Call(Caller c) {
+        rank = Rank.Responder;
+        caller = c;
+    }
+
+    /* Set employee who is handling call. */
+    public void setHandler(Employee e) {
+        handler = e;
+    }
+
+    /* Play recorded message to the customer. */
+    public void reply(String message) {
+        System.out.println(message);
+    }
+
+    public Rank getRank() {
+        return rank;
+    }
+
+    public void setRank(Rank r) {
+        rank = r;
+    }
+
+    public Rank incrementRank() {
+        if (rank == Rank.Responder) {
+            rank = Rank.Manager;
+        } else if (rank == Rank.Manager) {
+            rank = Rank.Director;
+        }
+        return rank;
+    }
+
+    /* Disconnect call. */
+    public void disconnect() {
+        reply("Thank you for calling");
+    }
+}

src/main/java/joshua/oop/callcenter/CallCenter.java

@@ -0,0 +1,111 @@
+package joshua.oop.callcenter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public class CallCenter {
+    private static CallCenter instance;
+
+    /* We have 3 levels of employees: respondents, managers, directors. */
+    private final int LEVELS = 3;
+
+    /* Initialize with 10 respondents, 4 managers, and 2 directors. */
+    private final int NUM_RESPONDENTS = 10;
+    private final int NUM_MANAGERS = 4;
+    private final int NUM_DIRECTORS = 2;
+
+    /* List of employees, by level.
+     * employeeLevels[0] = respondents
+     * employeeLevels[1] = managers
+     * employeeLevels[2] = directors
+     */
+    List<List<Employee>> employeeLevels;
+
+    /* queues for each call’s rank */
+    List<List<Call>> callQueues;
+
+    protected CallCenter() {
+        employeeLevels = new ArrayList<List<Employee>>(LEVELS);
+        callQueues = new ArrayList<List<Call>>(LEVELS);
+
+        // Create respondents.
+        ArrayList<Employee> respondents = new ArrayList<Employee>(NUM_RESPONDENTS);
+        for (int k = 0; k < NUM_RESPONDENTS - 1; k++) {
+            respondents.add(new Respondent());
+        }
+        employeeLevels.add(respondents);
+
+        // Create managers.
+        ArrayList<Employee> managers = new ArrayList<Employee>(NUM_MANAGERS);
+        managers.add(new Manager());
+        employeeLevels.add(managers);
+
+        // Create directors.
+        ArrayList<Employee> directors = new ArrayList<Employee>(NUM_DIRECTORS);
+        directors.add(new Director());
+        employeeLevels.add(directors);
+    }
+
+    /* Get instance of singleton class. */
+    public static CallCenter getInstance() {
+        if (instance == null) {
+            instance = new CallCenter();
+        }
+        return instance;
+    }
+
+    /* Gets the first available employee who can handle this call. */
+    public Employee getHandlerForCall(Call call) {
+        for (int level = call.getRank().getValue(); level < LEVELS - 1; level++) {
+            List<Employee> employeeLevel = employeeLevels.get(level);
+            for (Employee emp : employeeLevel) {
+                if (emp.isFree()) {
+                    return emp;
+                }
+            }
+        }
+        return null;
+    }
+
+    /* Routes the call to an available employee, or saves in a queue if no employee available. */
+    public void dispatchCall(Caller caller) {
+        Call call = new Call(caller);
+        dispatchCall(call);
+    }
+
+    /* Routes the call to an available employee, or saves in a queue if no employee available. */
+    public void dispatchCall(Call call) {
+    	/* Try to route the call to an employee with minimal rank. */
+        Employee emp = getHandlerForCall(call);
+        if (emp != null) {
+            emp.receiveCall(call);
+            call.setHandler(emp);
+        } else {
+	        /* Place the call into corresponding call queue according to its rank. */
+            call.reply("Please wait for free employee to reply");
+            callQueues.get(call.getRank().getValue()).add(call);
+        }
+    }
+
+    /* An employee got free. Look for a waiting call that he/she can serve. Return true
+     * if we were able to assign a call, false otherwise. */
+    public boolean assignCall(Employee emp) {
+        /* Check the queues, starting from the highest rank this employee can serve. */
+        for (int rank = emp.getRank().getValue(); rank >= 0; rank--) {
+            List<Call> que = callQueues.get(rank);
+
+            /* Remove the first call, if any */
+            if (que.size() > 0) {
+                Call call = que.remove(0);
+                if (call != null) {
+                    emp.receiveCall(call);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

src/main/java/joshua/oop/callcenter/Caller.java

@@ -0,0 +1,14 @@
+package joshua.oop.callcenter;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public class Caller {
+    private String name;
+    private int userId;
+
+    public Caller(int id, String nm) {
+        name = nm;
+        userId = id;
+    }
+}

src/main/java/joshua/oop/callcenter/Director.java

@@ -0,0 +1,10 @@
+package joshua.oop.callcenter;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public class Director extends Employee {
+    public Director() {
+        rank = Rank.Director;
+    }
+}

src/main/java/joshua/oop/callcenter/Employee.java

@@ -0,0 +1,66 @@
+package joshua.oop.callcenter;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public class Employee {
+    private Call currentCall = null;
+    protected Rank rank;
+
+    public Employee() {
+    }
+
+    /* Start the conversation */
+    public void receiveCall(Call call) {
+        currentCall = call;
+    }
+
+    /* the issue is resolved, finish the call */
+    public void callCompleted() {
+        if (currentCall != null) {
+			/* Disconnect the call. */
+            currentCall.disconnect();
+
+			/* Free the employee */
+            currentCall = null;
+        }
+
+		/* Check if there is a call waiting in queue */
+        assignNewCall();
+    }
+
+    /*
+     * The issue has not been resolved. Escalate the call, and assign a new call
+     * to the employee.
+     */
+    public void escalateAndReassign() {
+        if (currentCall != null) {
+			/* escalate call */
+            currentCall.incrementRank();
+            CallCenter.getInstance().dispatchCall(currentCall);
+
+			/* free the employee */
+            currentCall = null;
+        }
+
+		/* assign a new call */
+        assignNewCall();
+    }
+
+    /* Assign a new call to an employee, if the employee is free. */
+    public boolean assignNewCall() {
+        if (!isFree()) {
+            return false;
+        }
+        return CallCenter.getInstance().assignCall(this);
+    }
+
+    /* Returns whether or not the employee is free. */
+    public boolean isFree() {
+        return currentCall == null;
+    }
+
+    public Rank getRank() {
+        return rank;
+    }
+}

src/main/java/joshua/oop/callcenter/Manager.java

@@ -0,0 +1,10 @@
+package joshua.oop.callcenter;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public class Manager extends Employee {
+    public Manager() {
+        rank = Rank.Manager;
+    }
+}

src/main/java/joshua/oop/callcenter/Rank.java

@@ -0,0 +1,20 @@
+package joshua.oop.callcenter;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public enum Rank {
+    Responder(0),
+    Manager(1),
+    Director(2);
+
+    private int value;
+
+    private Rank(int v) {
+        value = v;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/joshua/oop/callcenter/Respondent.java

@@ -0,0 +1,10 @@
+package joshua.oop.callcenter;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public class Respondent extends Employee {
+    public Respondent() {
+        rank = Rank.Responder;
+    }
+}

src/main/java/joshua/oop/cardgame/BlackJackCard.java

@@ -0,0 +1,45 @@
+package joshua.oop.cardgame;
+
+/**
+ * @author Joshua.Jiang on 2016/6/2.
+ */
+public class BlackJackCard extends Card {
+
+    public BlackJackCard(int c, Suit s) {
+        super(c, s);
+    }
+
+    public int value() {
+        if (isAce()) { // Ace
+            return 1;
+        } else if (isFaceCard()) { // Face card
+            return 10;
+        } else { // Number card
+            return faceValue;
+        }
+    }
+
+    public int minValue() {
+        if (isAce()) { // Ace
+            return 1;
+        } else {
+            return value();
+        }
+    }
+
+    public int maxValue() {
+        if (isAce()) { // Ace
+            return 11;
+        } else {
+            return value();
+        }
+    }
+
+    public boolean isAce() {
+        return faceValue == 1;
+    }
+
+    public boolean isFaceCard() {
+        return faceValue >= 11 && faceValue <= 13;
+    }
+}