Skip to content
Related Articles

Related Articles

Count ways to remove objects such that exactly M equidistant objects remain
  • Difficulty Level : Medium
  • Last Updated : 27 Apr, 2021

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 <bits/stdc++.h>
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




<script>
 
// Javascript program for the above approach
 
// Function to count the number of ways of
// removing objects such that after removal,
// exactly M equidistant objects remain
function waysToRemove( n, m)
{
    // Store the resultant
    // number of arrangements
    var ans = 0;
 
    // Base Case: When only
    // 1 object is left
    if (m == 1) {
 
        // Print the result and return
        document.write( n);
        return;
    }
 
    // Iterate until len <= n and increment
    // the distance in each iteration
    for (var d = 0; d >= 0; d++) {
 
        // Total length if adjacent
        // objects are d distance apart
        var len = m + (m - 1) * d;
 
        // If len > n
        if (len > n)
            break;
 
        // Update the number of ways
        ans += (n - len) + 1;
    }
 
    // Print the result
    document.write( ans);
}
 
// Driver Code
var N = 5, M = 3;
waysToRemove(N, M);
 
</script>
Output: 
4

 

Time Complexity: O(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
Recommended Articles
Page :