Skip to content
Related Articles

Related Articles

Permutations of n things taken r at a time with k things together
  • Difficulty Level : Basic
  • Last Updated : 08 Mar, 2021

Given n, r and K. The task is to find the number of permutations of n  different things taken r  at a time such that k  specific things always occur together.
Examples: 
 

Input : n = 8, r = 5, k = 2
Output : 960

Input : n = 6, r = 2, k = 2
Output : 2

 

Approach: 
 

  1. A bundle of k  specific things can be put in r places in (r – k + 1) ways .
  2. k specific things in the bundle can be arranged themselves into k! ways.
  3. Now (n – k) things will be arranged in (r – k) places in $n-k_{P_r-k}$  ways.

Thus, using the fundamental principle of counting, the required number of permutations will be: 
 

Permutations = k! \times (r-k+1) \times $n-k_{P_r-k}$
 



Below is the implementation of the above approach: 
 

C++




// CPP program to find the number of permutations of
// n different things taken r at a time
// with k things grouped together
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find factorial
// of a number
int factorial(int n)
{
    int fact = 1;
 
    for (int i = 2; i <= n; i++)
        fact = fact * i;
 
    return fact;
}
 
// Function to calculate p(n, r)
int npr(int n, int r)
{
    int pnr = factorial(n) / factorial(n - r);
 
    return pnr;
}
 
// Function to find the number of permutations of
// n different things taken r at a time
// with k things grouped together
int countPermutations(int n, int r, int k)
{
    return factorial(k) * (r - k + 1) * npr(n - k, r - k);
}
 
// Driver code
int main()
{
    int n = 8;
    int r = 5;
    int k = 2;
 
    cout << countPermutations(n, r, k);
 
    return 0;
}

Java




// Java program to find the number of permutations of
// n different things taken r at a time
// with k things grouped together
 
class GFG{
// Function to find factorial
// of a number
static int factorial(int n)
{
    int fact = 1;
 
    for (int i = 2; i <= n; i++)
        fact = fact * i;
 
    return fact;
}
 
// Function to calculate p(n, r)
static int npr(int n, int r)
{
    int pnr = factorial(n) / factorial(n - r);
 
    return pnr;
}
 
// Function to find the number of permutations of
// n different things taken r at a time
// with k things grouped together
static int countPermutations(int n, int r, int k)
{
    return factorial(k) * (r - k + 1) * npr(n - k, r - k);
}
 
// Driver code
public static void main(String[] args)
{
    int n = 8;
    int r = 5;
    int k = 2;
 
    System.out.println(countPermutations(n, r, k));
}
}
// this code is contributed by mits

Python3




# Python3 program to find the number of permutations of
# n different things taken r at a time
# with k things grouped together
 
# def to find factorial
# of a number
def factorial(n):
  
    fact = 1;
 
    for i in range(2,n+1):
        fact = fact * i;
 
    return fact;
  
 
# def to calculate p(n, r)
def npr(n, r):
  
    pnr = factorial(n) / factorial(n - r);
 
    return pnr;
  
 
# def to find the number of permutations of
# n different things taken r at a time
# with k things grouped together
def countPermutations(n, r, k):
  
    return int(factorial(k) * (r - k + 1) * npr(n - k, r - k));
  
 
# Driver code
n = 8;
r = 5;
k = 2;
 
print(countPermutations(n, r, k));
     
# this code is contributed by mits

C#




// C# program to find the number of
// permutations of n different things
// taken r at a time with k things
// grouped together
using System;
 
class GFG
{
     
// Function to find factorial
// of a number
static int factorial(int n)
{
    int fact = 1;
 
    for (int i = 2; i <= n; i++)
        fact = fact * i;
 
    return fact;
}
 
// Function to calculate p(n, r)
static int npr(int n, int r)
{
    int pnr = factorial(n) /
              factorial(n - r);
 
    return pnr;
}
 
// Function to find the number of
// permutations of n different
// things taken r at a time with
// k things grouped together
static int countPermutations(int n,
                             int r, int k)
{
    return factorial(k) * (r - k + 1) *
                    npr(n - k, r - k);
}
 
// Driver code
static void Main()
{
    int n = 8;
    int r = 5;
    int k = 2;
 
    Console.WriteLine(countPermutations(n, r, k));
}
}
 
// This code is contributed by mits

PHP




<?php
// PHP program to find the number
// of permutations of n different
// things taken r at a time
// with k things grouped together
 
// Function to find factorial
// of a number
function factorial($n)
{
    $fact = 1;
 
    for ($i = 2; $i <= $n; $i++)
        $fact = $fact * $i;
 
    return $fact;
}
 
// Function to calculate p(n, r)
function npr($n, $r)
{
    $pnr = factorial($n) /
           factorial($n - $r);
 
    return $pnr;
}
 
// Function to find the number of
// permutations of n different
// things taken r at a time
// with k things grouped together
function countPermutations($n, $r, $k)
{
    return factorial($k) * ($r - $k + 1) *
                   npr($n - $k, $r - $k);
}
 
// Driver code
$n = 8;
$r = 5;
$k = 2;
 
echo countPermutations($n, $r, $k);
 
// This code is contributed by mits
?>

Javascript




<script>
 
// JavaScript program to find the number of permutations of
// n different things taken r at a time
// with k things grouped together
 
// Function to find factorial
// of a number
function factorial(n)
{
    let fact = 1;
 
    for (let i = 2; i <= n; i++)
        fact = fact * i;
 
    return fact;
}
 
// Function to calculate p(n, r)
function npr(n, r)
{
    let pnr = Math.floor(factorial(n) / factorial(n - r));
 
    return pnr;
}
 
// Function to find the number of permutations of
// n different things taken r at a time
// with k things grouped together
 
function countPermutations(n, r, k)
{
    return factorial(k) * (r - k + 1) * npr(n - k, r - k);
}
 
// Driver code
    let n = 8;
    let r = 5;
    let k = 2;
 
    document.write(countPermutations(n, r, k));
 
// This code is contributed by Surbhi Tyagi.
 
</script>
Output: 
960

 

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 :