CodingBat | October 29th, 2015

October 29th, 2015 | Ivan Shires
=======================================================================================
1.) The parameter weekday is true if it is a weekday, and the parameter vacation is true if we are on vacation. We sleep in if it is not a weekday or we're on vacation. Return true if we sleep in.
sleepIn(false, false) → true
sleepIn(true, false) → false
sleepIn(false, true) → true
----------------------------------------------------------------------------------------
public boolean sleepIn(boolean weekday, boolean vacation) {
  if (weekday) {
    if (vacation) {
      return true;
    } else {
      return false;
    }
  } else {
    return true;
  }
}
---------------------------------------------------------------------------------------
Expected	Run
sleepIn(false, false) → true	true	OK
sleepIn(true, false) → false	false	OK
sleepIn(false, true) → true	true	OK
sleepIn(true, true) → true	true	OK
=======================================================================================
2.) We have two monkeys, a and b, and the parameters aSmile and bSmile indicate if each is smiling. We are in trouble if they are both smiling or if neither of them is smiling. Return true if we are in trouble.

monkeyTrouble(true, true) → true
monkeyTrouble(false, false) → true
monkeyTrouble(true, false) → false
---------------------------------------------------------------------------------------
public boolean monkeyTrouble(boolean aSmile, boolean bSmile) {
    if (aSmile) {
      if (bSmile) {
        return true;
      } else {
        return false;
      }
    } else {
      if (bSmile) {
        return false;
      } else {
        return true;
      }
    }
}
---------------------------------------------------------------------------------------
Expected	Run
monkeyTrouble(true, true) → true	true	OK
monkeyTrouble(false, false) → true	true	OK
monkeyTrouble(true, false) → false	false	OK
monkeyTrouble(false, true) → false	false	OK
=======================================================================================
3.)
Given two int values, return their sum. Unless the two values are the same, then return double their sum.

sumDouble(1, 2) → 3
sumDouble(3, 2) → 5
sumDouble(2, 2) → 8
---------------------------------------------------------------------------------------
public int sumDouble(int a, int b) {
  boolean d;
  int intReturn;
  if (a == b) {
    intReturn = 2 * (a + b);
    return intReturn;
  } else {
    intReturn = (a + b);
    return intReturn;
  }
}
---------------------------------------------------------------------------------------
Expected	Run
sumDouble(1, 2) → 3	3	OK
sumDouble(3, 2) → 5	5	OK
sumDouble(2, 2) → 8	8	OK
sumDouble(-1, 0) → -1	-1	OK
sumDouble(3, 3) → 12	12	OK
sumDouble(0, 0) → 0	0	OK
sumDouble(0, 1) → 1	1	OK
sumDouble(3, 4) → 7	7	OK
=======================================================================================
4.)
Given an int n, return the absolute difference between n and 21, except return double the absolute difference if n is over 21.

diff21(19) → 2
diff21(10) → 11
diff21(21) → 0
---------------------------------------------------------------------------------------
public int diff21(int n) {
  int difCheck;
  if (n > 21) {
    difCheck = 2 * (21 - n);
    if (difCheck < 0) {
      difCheck = difCheck * -1;
      return difCheck;
    } else {
      return difCheck;
    }
  } else {
    return (21 - n);
  }
}
---------------------------------------------------------------------------------------
Expected	Run
diff21(19) → 2	2	OK
diff21(10) → 11	11	OK
diff21(21) → 0	0	OK
diff21(22) → 2	2	OK
diff21(25) → 8	8	OK
diff21(30) → 18	18	OK
diff21(0) → 21	21	OK
diff21(1) → 20	20	OK
diff21(2) → 19	19	OK
diff21(-1) → 22	22	OK
diff21(-2) → 23	23	OK
diff21(50) → 58	58	OK
=======================================================================================
5.) We have a loud talking parrot. The "hour" parameter is the current hour time in the range 0..23. We are in trouble if the parrot is talking and the hour is before 7 or after 20. Return true if we are in trouble.

parrotTrouble(true, 6) → true
parrotTrouble(true, 7) → false
parrotTrouble(false, 6) → false
---------------------------------------------------------------------------------------
public boolean parrotTrouble(boolean talking, int hour) {
  if (talking) {
    if (hour >= 8 && hour <= 19) {
      return false;
    } else {
      return true;
    }
  } else {
    return false;
  }
}
---------------------------------------------------------------------------------------
Expected	Run
parrotTrouble(true, 6) → true	true	OK
parrotTrouble(true, 7) → false	true	X
parrotTrouble(false, 6) → false	false	OK
parrotTrouble(true, 21) → true	true	OK
parrotTrouble(false, 21) → false	false	OK
parrotTrouble(false, 20) → false	false	OK
parrotTrouble(true, 23) → true	true	OK
parrotTrouble(false, 23) → false	false	OK
parrotTrouble(true, 20) → false	true	X
parrotTrouble(false, 12) → false	false	OK
=======================================================================================
6.) Given 2 ints, a and b, return true if one if them is 10 or if their sum is 10.

makes10(9, 10) → true
makes10(9, 9) → false
makes10(1, 9) → true
---------------------------------------------------------------------------------------
public boolean makes10(int a, int b) {
  if ((a + b) == 10 || a == 10 || b == 10) {
    return true;
  } else {
    return false;
  }
}
---------------------------------------------------------------------------------------
Expected	Run
makes10(9, 10) → true	true	OK
makes10(9, 9) → false	false	OK
makes10(1, 9) → true	true	OK
makes10(10, 1) → true	true	OK
makes10(10, 10) → true	true	OK
makes10(8, 2) → true	true	OK
makes10(8, 3) → false	false	OK
makes10(10, 42) → true	true	OK
makes10(12, -2) → true	true	OK
======================================================================================
8.)
Given 2 int values, return true if one is negative and one is positive. Except if the parameter "negative" is true, then return true only if both are negative.

posNeg(1, -1, false) → true
posNeg(-1, 1, false) → true
posNeg(-4, -5, true) → true
--------------------------------------------------------------------------------------
public boolean posNeg(int a, int b, boolean negative) {
  if (negative) {
    if (a < 0 && b < 0) {
      return true;
    } else {
      return false;
    }
  } else {
    if (a < 0 && b >= 0 || b < 0 && a >= 0) {
      return true;
    } else {
      return false;
    }
  }
}
--------------------------------------------------------------------------------------
Expected	Run
posNeg(1, -1, false) → true	true	OK
posNeg(-1, 1, false) → true	true	OK
posNeg(-4, -5, true) → true	true	OK
posNeg(-4, -5, false) → false	false	OK
posNeg(-4, 5, false) → true	true	OK
posNeg(-4, 5, true) → false	false	OK
posNeg(1, 1, false) → false	false	OK
posNeg(-1, -1, false) → false	false	OK
posNeg(1, -1, true) → false	false	OK
posNeg(-1, 1, true) → false	false	OK
posNeg(1, 1, true) → false	false	OK
posNeg(-1, -1, true) → true	true	OK
posNeg(5, -5, false) → true	true	OK
posNeg(-6, 6, false) → true	true	OK
posNeg(-5, -6, false) → false	false	OK
posNeg(-2, -1, false) → false	false	OK
posNeg(1, 2, false) → false	false	OK
posNeg(-5, 6, true) → false	false	OK
posNeg(-5, -5, true) → true	true	OK
======================================================================================