Nim Game

                                            
class Solution {
public:
    bool canWinNim(int n) {
        return n % 4 != 0;
    }
};

                                            
class Solution {
    public boolean canWinNim(int n) {
        return n % 4 != 0;
    }
}

                                            
class Solution(object):
    def canWinNim(self, n):
        """
        :type n: int
        :rtype: bool
        """
        return n % 4 != 0

                                            
bool canWinNim(int n) {
    return n % 4 != 0;
}

                                            
public class Solution {
    public bool CanWinNim(int n) {
        return n % 4 != 0;
    }
}

                                            
/**
 * @param {number} n
 * @return {boolean}
 */
var canWinNim = function(n) {
    return n % 4 !== 0;
};

                                            
function canWinNim(n: number): boolean {
    return n % 4 !== 0;
};

                                            
class Solution {
    /**
     * @param Integer $n
     * @return Boolean
     */
    function canWinNim($n) {
        return $n % 4 != 0;
    }
}

                                            
class Solution {
    func canWinNim(_ n: Int) -> Bool {
        return n % 4 != 0
    }
}

                                            
class Solution {
    fun canWinNim(n: Int): Boolean {
        return n % 4 != 0
    }
}

                                            
class Solution {
  bool canWinNim(int n) {
      return n % 4 != 0;
  }
}

                                            
func canWinNim(n int) bool {
    return n%4 != 0
}

                                            
# @param {Integer} n
# @return {Boolean}
def can_win_nim(n)
    return n % 4 != 0
end

                                            
object Solution {
    def canWinNim(n: Int): Boolean = {
        n % 4 != 0
    }
}

                                            
impl Solution {
    pub fn can_win_nim(n: i32) -> bool {
        n % 4 != 0
    }
}

                                            
(define/contract (can-win-nim n)
  (-> exact-integer? boolean?)
  (if (= (modulo n 4) 0)
      #f
      #t))

                                            
-spec can_win_nim(N :: integer()) -> boolean().
can_win_nim(N) ->
    N rem 4 /= 0.

                                            
defmodule Solution do
  @spec can_win_nim(n :: integer) :: boolean
  def can_win_nim(n) do
    rem(n, 4) != 0
  end
end

To solve this coding challenge, we need to determine whether you can win the game given a certain number of stones

n

when both players play optimally. This game exhibits patterns that make it possible to determine the winner using a simple modulo operation.

Explanation

In the Nim Game, if you start with 1, 2, or 3 stones, you will always win if you play optimally. This is because you can take all the stones on your first move. However, if you start with 4 stones, no matter how many stones you take (1, 2, or 3), your friend will always be left in a win position because they can remove the last stone. Thus, there's a pattern here:

If
n % 4 == 0

, you will lose because whatever move you make, your friend will always be able to adjust their count to bring the game back to another multiple of 4 after their turn.
If
n % 4 != 0

, you can win because you can always adjust your move to make the remaining stones a multiple of 4 for your friend, putting them in a losing position.

This leads to a very simple solution: determine if the number of stones

n

modulo 4 is zero. If it is, you lose; otherwise, you win. Here’s the detailed pseudocode:

Input Analysis :

Read the integer
n

, representing the number of stones.

Check Conditions :

If
n % 4 == 0

, then return
false

because you will lose.
Otherwise, return
true

because you can win.

Pseudocode Explanation with Comments

                                            
# Function to determine if the player can win the Nim game
function canWinNim(number_of_stones):

# Check if the number of stones is a multiple of 4
if number_of_stones modulo 4 equals 0:
# If true, return false as the player cannot win
return false
else:
# Otherwise, return true as the player can win
return true

Detailed Steps in Pseudocode:

Define the function
canWinNim

with
number_of_stones

as input.
Condition to check if
n

is a multiple of 4 :

Use the modulo operator to check if
number_of_stones % 4 == 0

.

Return Result Based on Condition :

If the result of the modulo operation is
0

, return
false

because it means the starting count of stones is such that the opponent can always adjust their strategy to win.
If the result of the modulo operation is not
0

, return
true

because it means you can make the first move in such a way that always leaves a multiple of 4 stones to your opponent after your turn, ensuring your win.

This pseudocode effectively captures the logic needed to solve the Nim Game problem optimally. It leverages the modulo operation to determine the outcome based on the initial number of stones, encapsulating the winning and losing conditions succinctly.