Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Pen Distribution Problem

  • Difficulty Level : Hard
  • 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 <bits/stdc++.h>
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



<script>
// javascript program 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
  function solve(N, P1, P2, X,
                    Move, QuitP1, QuitP2)
  {
    if (N == 0 || (QuitP1 && QuitP2))
    {
 
      // Box is empty, Game Over! or
      // Both have quit, Game Over!
      document.write("Number of pens remaining"
                         + " in the box: " + N + "<br/>");
      document.write("Number of pens collected"
                         + " by P1: " + P1+ "<br/>");
      document.write("Number of pens collected"
                         + " by P2: " + P2+ "<br/>");
      return;
    }
    if (Move == 0 && QuitP1 == false)
    {
 
      // P1 moves
      let req_P1 = (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
      let req_P2 = (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
  function PenGame(N)
  {
 
    // Score of P1
    let P1 = 0;
 
    // Score of P2
    let P2 = 0;
 
    // Initialized to zero
    let X = 0;
 
    // Move = 0, P1's turn
    // Move = 1, P2's turn
    let Move = 0;
 
    // Has P1 quit
    let QuitP1 = false;
 
    // Has P2 quit
    let QuitP2 = false;
 
    // Recursively continue the game
    solve(N, P1, P2, X, Move, QuitP1, QuitP2);
  }
 
    // Driver Code
     
    let N = 22;
    PenGame(N);
 
</script>
 
 
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)

My Personal Notes
arrow_drop_up
Previous
Check if an array can be sorted by swapping pairs from indices consisting of unequal elements in another array
Next

N Queen Problem | Backtracking-3
Recommended Articles
Page :
Cake Distribution Problem
11, Nov 19
Chocolate Distribution Problem | Set 2
28, Dec 20
Secretary Problem (A Optimal Stopping Problem)
20, Oct 17
Transportation Problem | Set 7 ( Degeneracy in Transportation Problem )
03, Dec 19
Random number generator in arbitrary probability distribution fashion
06, Jun 13
Standard Normal Distribution (SND) - Java Program
22, Dec 17
Minimum and maximum number of N chocolates after distribution among K students
25, Oct 18
Distribution of a Number in Array within a Range
30, Jan 20
Converting Power Law Distribution to a Linear graph
15, Jul 20
Maximize sum of minimum and maximum of all groups in distribution
11, Jan 22
8 queen problem
22, Jun 09
The Knight's tour problem | Backtracking-1
14, Jul 11
Hungarian Algorithm for Assignment Problem | Set 1 (Introduction)
14, Jan 16
Frobenius coin problem
26, Feb 16
Word Break Problem | DP-32 | Set - 2
07, May 20
Josephus Problem Using Bit Magic
12, Jul 17
Maths behind number of paths in matrix problem
28, Feb 19
Number of stopping station problem
17, Nov 17
Josephus Problem | (Iterative Solution)
29, Aug 18
Problem of 8 Neighbours of an element in a 2-D Matrix
30, Nov 18
Travelling Salesman Problem implementation using BackTracking
10, Apr 19
21 Matchsticks Problem
14, Aug 19
Card Shuffle Problem | TCS Digital Advanced Coding Question
26, Jul 19
Sand Timer Flip Counting Problem
29, Aug 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
xor09
@xor09
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!