Related Articles
Pen Distribution Problem
• Difficulty Level : Medium
• Last Updated : 03 May, 2021

Given an integer N denoting the number of boxes in a pen, and two players P1 and P2 playing a game of distributing N pens among themselves as per the following rules:

• P1 makes the first move by taking 2X pens. (Initially, X = 0)
• P2 takes 3X pens.
• Value of X increases by 1 after each move.
• P1 and P2 makes move alternatively.
• If the current player has to take more pens than the number of pens remaining in the box, then they quit.
• The game will be over when both the players quit or when the box becomes empty.

The task to print the following details once the game is over:

1. The number of pens remaining in the box.
2. The number of pens collected by P1.
3. The number of pens collected by P2.

Examples:

Input: N = 22
Output:
Number of pens remaining in the box: 14
Number of pens collected by P1 : 5
Number of pens collected by P2 : 3
Explanation:

• Move 1: X = 0, P1 takes 1 pen from the box. Therefore, N = 22 – 1 = 21.
• Move 2: X = 1, P2 takes 3 pens from the box. Therefore, N = 21 – 3 = 18.
• Move 3: X = 2, P1 takes 4 pens from the box. Therefore, N = 18 – 4 = 14.
• Move 4: X = 3, P2 quits as 27 > 14.
• Move 5: X = 4, P1 quits as 16 > 14.
• Game Over! Both players have quit.

Input: N = 1
Output:
Number of pens remaining in the box : 0
Number of pens collected by P1 : 1
Number of pens collected by P2 : 0

Approach: The idea is to use Recursion. Follow the steps to solve the problem:

1. Define a recursive function:

Game_Move(N, P1, P2, X, Move, QuitP1, QuitP2)
where,
N : Total number of Pens
P1 : Score of P1
P2 : Score of P2
X : Initialized to zero
Move = 0 : P1’s turn
Move = 1 : P2’s turn
QuitP1 : Has P1 quit
QuitP2 : Has P2 quit

2. Finally, print the final values after the game has ended

Below is the implementation of the above-mentioned approach:

## C++

 `// C++ implementation of the``// above approach` `#include ``using` `namespace` `std;` `// N = Total number of Pens``// P1 : Score of P1``// P2 : Score of P2``// X : Initialized to zero``// Move = 0 : P1's turn``// Move = 1 : P2's turn``// QuitP1 : Has P1 quit``// QuitP2 : Has P2 quit` `// Recursive function to play Game``void` `solve(``int``& N, ``int``& P1, ``int``& P2, ``int``& X, ``bool` `Move,``           ``bool` `QuitP1, ``bool` `QuitP2)``{``    ``if` `(N == 0 or (QuitP1 and QuitP2)) {` `        ``// Box is empty, Game Over! or``        ``// Both have quit, Game Over!``        ``cout << ``"Number of pens remaining"``             ``<< ``" in the box: "` `<< N << endl;``        ``cout << ``"Number of pens collected"``             ``<< ``" by P1: "` `<< P1 << endl;``        ``cout << ``"Number of pens collected"``             ``<< ``" by P2: "` `<< P2 << endl;``        ``return``;``    ``}` `    ``if` `(Move == 0 and QuitP1 == ``false``) {` `        ``// P1 moves``        ``int` `req_P1 = ``pow``(2, X);` `        ``if` `(req_P1 <= N) {``            ``P1 += req_P1;``            ``N -= req_P1;``        ``}``        ``else` `{``            ``QuitP1 = ``true``;``        ``}``    ``}` `    ``else` `if` `(Move == 1 and QuitP2 == ``false``) {` `        ``// P2 moves``        ``int` `req_P2 = ``pow``(3, X);` `        ``if` `(req_P2 <= N) {``            ``P2 += req_P2;``            ``N -= req_P2;``        ``}``        ``else` `{``            ``QuitP2 = ``true``;``        ``}``    ``}` `    ``// Increment X``    ``X++;` `    ``// Switch moves between P1 and P2``    ``Move = ((Move == 1) ? 0 : 1);` `    ``solve(N, P1, P2, X, Move, QuitP1, QuitP2);``}` `// Function to find the number of``// pens remaining in the box and``// calculate score for each player``void` `PenGame(``int` `N)``{``    ``// Score of P1``    ``int` `P1 = 0;` `    ``// Score of P2``    ``int` `P2 = 0;` `    ``// Initialized to zero``    ``int` `X = 0;` `    ``// Move = 0, P1's turn``    ``// Move = 1, P2's turn``    ``bool` `Move = 0;` `    ``// Has P1 quit``    ``bool` `QuitP1 = 0;` `    ``// Has P2 quit``    ``bool` `QuitP2 = 0;` `    ``// Recursively continue the game``    ``solve(N, P1, P2, X, Move,``          ``QuitP1, QuitP2);``}` `// Driver Code``int` `main()``{``    ``int` `N = 22;``    ``PenGame(N);` `    ``return` `0;``}`

## Java

 `// Java implementation of the``// above approach``import` `java.util.*;``import` `java.lang.*;``public` `class` `GFG``{` `  ``// N = Total number of Pens``  ``// P1 : Score of P1``  ``// P2 : Score of P2``  ``// X : Initialized to zero``  ``// Move = 0 : P1's turn``  ``// Move = 1 : P2's turn``  ``// QuitP1 : Has P1 quit``  ``// QuitP2 : Has P2 quit` `  ``// Recursive function to play Game``  ``static` `void` `solve(``int` `N, ``int` `P1, ``int` `P2, ``int` `X,``                    ``int` `Move, ``boolean` `QuitP1, ``boolean` `QuitP2)``  ``{``    ``if` `(N == ``0` `|| (QuitP1 && QuitP2))``    ``{` `      ``// Box is empty, Game Over! or``      ``// Both have quit, Game Over!``      ``System.out.println(``"Number of pens remaining"``                         ``+ ``" in the box: "` `+ N);``      ``System.out.println(``"Number of pens collected"``                         ``+ ``" by P1: "` `+ P1);``      ``System.out.println(``"Number of pens collected"``                         ``+ ``" by P2: "` `+ P2);``      ``return``;``    ``}``    ``if` `(Move == ``0` `&& QuitP1 == ``false``)``    ``{` `      ``// P1 moves``      ``int` `req_P1 = (``int``)(Math.pow(``2``, X));``      ``if` `(req_P1 <= N)``      ``{``        ``P1 += req_P1;``        ``N -= req_P1;``      ``}``      ``else``      ``{``        ``QuitP1 = ``true``;``      ``}``    ``}``    ``else` `if` `(Move == ``1` `&& QuitP2 == ``false``)``    ``{` `      ``// P2 moves``      ``int` `req_P2 = (``int``)(Math.pow(``3``, X));``      ``if` `(req_P2 <= N)``      ``{``        ``P2 += req_P2;``        ``N -= req_P2;``      ``}``      ``else``      ``{``        ``QuitP2 = ``true``;``      ``}``    ``}` `    ``// Increment X``    ``X++;` `    ``// Switch moves between P1 and P2``    ``Move = ((Move == ``1``) ? ``0` `: ``1``);``    ``solve(N, P1, P2, X, Move, QuitP1, QuitP2);``  ``}` `  ``// Function to find the number of``  ``// pens remaining in the box and``  ``// calculate score for each player``  ``static` `void` `PenGame(``int` `N)``  ``{` `    ``// Score of P1``    ``int` `P1 = ``0``;` `    ``// Score of P2``    ``int` `P2 = ``0``;` `    ``// Initialized to zero``    ``int` `X = ``0``;` `    ``// Move = 0, P1's turn``    ``// Move = 1, P2's turn``    ``int` `Move = ``0``;` `    ``// Has P1 quit``    ``boolean` `QuitP1 = ``false``;` `    ``// Has P2 quit``    ``boolean` `QuitP2 = ``false``;` `    ``// Recursively continue the game``    ``solve(N, P1, P2, X, Move, QuitP1, QuitP2);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``int` `N = ``22``;``    ``PenGame(N);``  ``}``}` `// This code is contributed by jana_sayantan.`

## Python3

 `# Python3 implementation of the``# above approach` `# N = Total number of Pens``# P1 : Score of P1``# P2 : Score of P2``# X : Initialized to zero``# Move = 0 : P1's turn``# Move = 1 : P2's turn``# QuitP1 : Has P1 quit``# QuitP2 : Has P2 quit` `# Recursive function to play Game``def` `solve(N, P1, P2, X, Move,``          ``QuitP1, QuitP2):` `    ``if` `(N ``=``=` `0` `or` `(QuitP1 ``and` `QuitP2)):` `        ``# Box is empty, Game Over! or``        ``# Both have quit, Game Over!``        ``print``(``"Number of pens remaining in the box: "``, N)``        ``print``(``"Number of pens collected by P1: "``, P1)``        ``print``(``"Number of pens collected by P2: "``, P2)``        ``return``    ``if` `(Move ``=``=` `0` `and` `QuitP1 ``=``=` `False``):` `        ``# P1 moves``        ``req_P1 ``=` `int``(``pow``(``2``, X))` `        ``if` `(req_P1 <``=` `N):``            ``P1 ``+``=` `req_P1``            ``N ``-``=` `req_P1``        ``else``:``            ``QuitP1 ``=` `True``    ``elif` `(Move ``=``=` `1` `and` `QuitP2 ``=``=` `False``):` `        ``# P2 moves``        ``req_P2 ``=` `int``(``pow``(``3``, X))``        ``if` `(req_P2 <``=` `N):``            ``P2 ``+``=` `req_P2``            ``N ``-``=` `req_P2``        ``else``:``            ``QuitP2 ``=` `True` `    ``# Increment X``    ``X ``+``=` `1` `    ``# Switch moves between P1 and P2``    ``if``(Move ``=``=` `1``):``        ``Move ``=` `0``    ``else``:``        ``Move ``=` `1``    ``solve(N, P1, P2, X, Move, QuitP1, QuitP2)` `# Function to find the number of``# pens remaining in the box and``# calculate score for each player``def` `PenGame(N):` `    ``# Score of P1``    ``P1 ``=` `0` `    ``# Score of P2``    ``P2 ``=` `0` `    ``# Initialized to zero``    ``X ``=` `0` `    ``# Move = 0, P1's turn``    ``# Move = 1, P2's turn``    ``Move ``=` `False` `    ``# Has P1 quit``    ``QuitP1 ``=` `False` `    ``# Has P2 quit``    ``QuitP2 ``=` `False` `    ``# Recursively continue the game``    ``solve(N, P1, P2, X, Move,``          ``QuitP1, QuitP2)` `# Driver Code``N ``=` `22``PenGame(N)` `# This code is contributed by Dharanendra L V.`

## C#

 `// C# implementation of the``// above approach``using` `System;``class` `GFG {` `    ``// N = Total number of Pens``    ``// P1 : Score of P1``    ``// P2 : Score of P2``    ``// X : Initialized to zero``    ``// Move = 0 : P1's turn``    ``// Move = 1 : P2's turn``    ``// QuitP1 : Has P1 quit``    ``// QuitP2 : Has P2 quit` `    ``// Recursive function to play Game``    ``static` `void` `solve(``int` `N, ``int` `P1, ``int` `P2, ``int` `X,``                      ``int` `Move, ``bool` `QuitP1, ``bool` `QuitP2)``    ``{``        ``if` `(N == 0 || (QuitP1 && QuitP2)) {` `            ``// Box is empty, Game Over! or``            ``// Both have quit, Game Over!``            ``Console.WriteLine(``"Number of pens remaining"``                              ``+ ``" in the box: "` `+ N);``            ``Console.WriteLine(``"Number of pens collected"``                              ``+ ``" by P1: "` `+ P1);``            ``Console.WriteLine(``"Number of pens collected"``                              ``+ ``" by P2: "` `+ P2);``            ``return``;``        ``}` `        ``if` `(Move == 0 && QuitP1 == ``false``) {` `            ``// P1 moves``            ``int` `req_P1 = (``int``)(Math.Pow(2, X));` `            ``if` `(req_P1 <= N) {``                ``P1 += req_P1;``                ``N -= req_P1;``            ``}``            ``else` `{``                ``QuitP1 = ``true``;``            ``}``        ``}` `        ``else` `if` `(Move == 1 && QuitP2 == ``false``)``        ``{` `            ``// P2 moves``            ``int` `req_P2 = (``int``)(Math.Pow(3, X));` `            ``if` `(req_P2 <= N)``            ``{``                ``P2 += req_P2;``                ``N -= req_P2;``            ``}``            ``else``            ``{``                ``QuitP2 = ``true``;``            ``}``        ``}` `        ``// Increment X``        ``X++;` `        ``// Switch moves between P1 and P2``        ``Move = ((Move == 1) ? 0 : 1);``        ``solve(N, P1, P2, X, Move, QuitP1, QuitP2);``    ``}` `    ``// Function to find the number of``    ``// pens remaining in the box and``    ``// calculate score for each player``    ``static` `void` `PenGame(``int` `N)``    ``{``        ``// Score of P1``        ``int` `P1 = 0;` `        ``// Score of P2``        ``int` `P2 = 0;` `        ``// Initialized to zero``        ``int` `X = 0;` `        ``// Move = 0, P1's turn``        ``// Move = 1, P2's turn``        ``int` `Move = 0;` `        ``// Has P1 quit``        ``bool` `QuitP1 = ``false``;` `        ``// Has P2 quit``        ``bool` `QuitP2 = ``false``;` `        ``// Recursively continue the game``        ``solve(N, P1, P2, X, Move, QuitP1, QuitP2);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 22;``        ``PenGame(N);``    ``}``}` `// This code is contributed by chitranayal.`

## Javascript

 ``

Output:
```Number of pens remaining in the box: 14
Number of pens collected by P1: 5
Number of pens collected by P2: 3```

Time Complexity: O(Log(N))
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up