 GeeksforGeeks App
Open App Browser
Continue

# Count ways to remove objects such that exactly M equidistant objects remain

Given an integer N, representing objects placed adjacent to each other, the task is to count the number of ways to remove objects such that after their removal, exactly M objects are left and the distance between each adjacent object is equal.

Examples:

Input: N = 5, M = 3
Output: 4
Explanation:
Let the initial arrangement be A1 A2 A3 A4 A5.
The following arrangements are possible:

1. A1 A2 A3 _ _
2. _ A2 A3 A4 _
3. _ _ A3 A4 A5
4. A1_ A3_ A5

Therefore, the total count of possible arrangements is 4.

Input: N = 2, M = 1
Output: 2

Approach: The idea is based on the observation that an arrangement of M objects with D adjacent spaces takes (M + (M – 1) * D) length, say L. For this arrangement, there are (N – L + 1) options. Therefore, the idea is to iterate over D from 0 till L ≤ N and find the number of ways accordingly.
Follow the steps below to solve the problem:

• If the value of M is 1, then the number of possible arrangements is N. Therefore, print the value of N.
• Otherwise, perform the following steps:
• Initialize two variables, say ans to 0, to store the total number of required arrangements.
• Iterate a loop using a variable D. Perform the following steps:
• Store the total length required for the current value of D in a variable, say L as M + (M – 1) * D.
• If the value of L is greater than N, then break out of the loop.
• Otherwise, update the number of arrangements by adding the value (N – L + 1) to the variable ans.
• After completing the above steps, print the value of ans as the total number of arrangements.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count the number of ways of``// removing objects such that after removal,``// exactly M equidistant objects remain``void` `waysToRemove(``int` `n, ``int` `m)``{``    ``// Store the resultant``    ``// number of arrangements``    ``int` `ans = 0;` `    ``// Base Case: When only``    ``// 1 object is left``    ``if` `(m == 1) {` `        ``// Print the result and return``        ``cout << n;``        ``return``;``    ``}` `    ``// Iterate until len <= n and increment``    ``// the distance in each iteration``    ``for` `(``int` `d = 0; d >= 0; d++) {` `        ``// Total length if adjacent``        ``// objects are d distance apart``        ``int` `len = m + (m - 1) * d;` `        ``// If len > n``        ``if` `(len > n)``            ``break``;` `        ``// Update the number of ways``        ``ans += (n - len) + 1;``    ``}` `    ``// Print the result``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5, M = 3;``    ``waysToRemove(N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{` `// Function to count the number of ways of``// removing objects such that after removal,``// exactly M equidistant objects remain``static` `void` `waysToRemove(``int` `n, ``int` `m)``{``    ` `    ``// Store the resultant``    ``// number of arrangements``    ``int` `ans = ``0``;` `    ``// Base Case: When only``    ``// 1 object is left``    ``if` `(m == ``1``)``    ``{``        ` `        ``// Print the result and return``        ``System.out.println(n);``        ``return``;``    ``}` `    ``// Iterate until len <= n and increment``    ``// the distance in each iteration``    ``for``(``int` `d = ``0``; d >= ``0``; d++)``    ``{``        ` `        ``// Total length if adjacent``        ``// objects are d distance apart``        ``int` `len = m + (m - ``1``) * d;` `        ``// If len > n``        ``if` `(len > n)``            ``break``;` `        ``// Update the number of ways``        ``ans += (n - len) + ``1``;``    ``}` `    ``// Print the result``    ``System.out.println(ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``5``, M = ``3``;``    ` `    ``waysToRemove(N, M);``}``}` `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python3 program for the above approach` `# Function to count the number of ways of``# removing objects such that after removal,``# exactly M equidistant objects remain``def` `waysToRemove(n, m):` `    ``# Store the resultant``    ``# number of arrangements``    ``ans ``=` `0` `    ``# Base Case: When only``    ``# 1 object is left``    ``if` `(m ``=``=` `1``):``        ` `        ``# Print the result and return``        ``print``(n)``        ``return` `    ``d ``=` `0``    ` `    ``# Iterate until len <= n and increment``    ``# the distance in each iteration``    ``while` `d >``=` `0``:``        ` `        ``# Total length if adjacent``        ``# objects are d distance apart``        ``length ``=` `m ``+` `(m ``-` `1``) ``*` `d` `        ``# If length > n``        ``if` `(length > n):``            ``break` `        ``# Update the number of ways``        ``ans ``+``=` `(n ``-` `length) ``+` `1``        ` `        ``d ``+``=` `1` `    ``# Print the result``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``N ``=` `5``    ``M ``=` `3``    ` `    ``waysToRemove(N, M)` `# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``    ` `// Function to count the number of ways of``// removing objects such that after removal,``// exactly M equidistant objects remain``static` `void` `waysToRemove(``int` `n, ``int` `m)``{``    ` `    ``// Store the resultant``    ``// number of arrangements``    ``int` `ans = 0;` `    ``// Base Case: When only``    ``// 1 object is left``    ``if` `(m == 1)``    ``{``        ` `        ``// Print the result and return``        ``Console.Write(n);``        ``return``;``    ``}` `    ``// Iterate until len <= n and increment``    ``// the distance in each iteration``    ``for``(``int` `d = 0; d >= 0; d++)``    ``{``        ` `        ``// Total length if adjacent``        ``// objects are d distance apart``        ``int` `len = m + (m - 1) * d;` `        ``// If len > n``        ``if` `(len > n)``            ``break``;` `        ``// Update the number of ways``        ``ans += (n - len) + 1;``    ``}` `    ``// Print the result``    ``Console.Write(ans);``}`  `// Driver code``static` `void` `Main()``{``    ``int` `N = 5, M = 3;``    ``waysToRemove(N, M);``}``}` `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output:

`4`

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

My Personal Notes arrow_drop_up