added Predict the Winner (medium)

Author: minhyeong-joe

Medium/PredictWinner/README.md

@@ -0,0 +1,32 @@
+
+# Predict the Winner
+[Leetcode Link](https://leetcode.com/problems/predict-the-winner/)
+
+## Problem:
+
+Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins.
+
+Given an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score.
+
+## Example:
+
+```
+Input: [1, 5, 2]
+Output: False
+Explanation: Initially, player 1 can choose between 1 and 2. 
+If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2). 
+So, final score of player 1 is 1 + 2 = 3, and player 2 is 5. 
+Hence, player 1 will never be the winner and you need to return False.
+```
+```
+Input: [1, 5, 233, 7]
+Output: True
+Explanation: Player 1 first chooses 1. Then player 2 have to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.
+Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.
+```
+
+## Note:
+
+- `1 <= length of the array <= 20`.
+- Any scores in the given array are non-negative integers and will not exceed `10,000,000`.
+- If the scores of both players are equal, then player 1 is still the winner.

Medium/PredictWinner/solution.py

@@ -0,0 +1,26 @@
+from typing import List
+
+class Solution:
+ def PredictTheWinner(self, nums: List[int]) -> bool:
+ score = self.minMax(nums, 0, len(nums)-1, 1)
+ return score >= 0
+
+
+ def minMax(self, nums: List[int], start, end, turn = 1) -> int:
+ # print(nums[start:end+1])
+ if start == end:
+ # print("base case:", turn*nums[start])
+ return turn * nums[start]
+ pickLeft = turn * nums[start] + self.minMax(nums, start+1, end, -turn)
+ # print("left:", pickLeft)
+ pickRight = turn * nums[end] + self.minMax(nums, start, end-1, -turn)
+ # print("right:", pickRight)
+ return turn * max(turn * pickLeft, turn * pickRight)
+ 
+
+
+
+# test driver
+sol = Solution()
+nums = [1, 5, 233, 7]
+print("Output:", sol.PredictTheWinner(nums))

README.md

@@ -64,6 +64,7 @@ Languages used: Java and Python
  - [Reverse Substrings Between Each Pair of Parentheses](Medium/ReverseSubstringsBetweenParentheses)
  - [Asteroid Collision](Medium/AsteroidCollision)
  - [Surrounded Regions](Medium/SurroundedRegions)
+ - [Predict the Winner](Medium/PredictWinner)
 - Hard
  - [Maximum Score Words Formed by Letters](Hard/MaximumScoreWords)
  - [Reducing Dishes](Hard/ReducingDishes)