Count of different straight lines with total n points with m collinear

There are ‘n’ points in a plane out of which ‘m points are collinear. How many different straight lines can form?
Examples: 

Input : n = 3, m = 3
Output : 1
We can form only 1 distinct straight line
using 3 collinear points

Input : n = 10, m = 4
Output : 40

Number of distinct Straight lines = ⁿC₂ – ^mC₂ + 1 
How does this formula work?
Consider the second example above. There are 10 points, out of which 4 collinear. A straight line will be formed by any two of these ten points. Thus forming a straight line amounts to selecting any two of the 10 points. Two points can be selected out of the 10 points in ⁿC₂ ways.
Number of straight line formed by 10 points when no 2 of them are co-linear = ¹⁰C₂…..…(i) 
Similarly, the number of straight lines formed by 4 points when no 2 of them are co-linear = ⁴C₂….(ii)
Since straight lines formed by these 4 points are same, straight lines formed by them will reduce to only one. 
Required number of straight lines formed = ¹⁰C₂– ⁴C₂ + 1 = 45 – 6 + 1 = 40 

Implementation of the approach is given as: 

C++

// CPP program to count number of straight lines
// with n total points, out of which m are
// collinear.
#include <bits/stdc++.h>

using namespace std;

// Returns value of binomial coefficient
// Code taken from https://goo.gl/vhy4jp
int nCk(int n, int k)
{

    int C[k+1];
    memset(C, 0, sizeof(C));

    C[0] = 1;  // nC0 is 1

    for (int i = 1; i <= n; i++)
    {

        // Compute next row of pascal triangle
        // using the previous row
        for (int j = min(i, k); j > 0; j--)

            C[j] = C[j] + C[j-1];
    }

    return C[k];
}


/* function to calculate number of straight lines
   can be formed */
int count_Straightlines(int n,int m)
{

    return (nCk(n, 2) - nCk(m, 2)+1);

}


/* driver function*/
int main()
{

    int n = 4, m = 3 ;
    cout << count_Straightlines(n, m);
    return 0;

}

Java

// Java program to count number of straight lines
// with n total points, out of which m are
// collinear.
import java.util.*;
import java.lang.*;

public class GfG  {

    // Returns value of binomial coefficient
    // Code taken from https://goo.gl/vhy4jp
    public static int nCk(int n, int k)
    {
        int[] C = new int[k + 1];

        C[0] = 1; // nC0 is 1

        for (int i = 1; i <= n; i++)  {

            // Compute next row of pascal triangle
            // using the previous row
            for (int j = Math.min(i, k); j > 0; j--)
                C[j] = C[j] + C[j - 1];
        }

        return C[k];
    }


    /* function to calculate number of straight lines
    can be formed */
    public static int count_Straightlines(int n, int m)
    {
        return (nCk(n, 2) - nCk(m, 2) + 1);
    }


    // Driver function
    public static void main(String argc[])
    {
        int n = 4, m = 3;
        System.out.println(count_Straightlines(n, m));
    }

    // This code is contributed by Sagar Shukla
}

Python

# Python program to count number of straight lines
# with n total points, out of which m are
# collinear.

# Returns value of binomial coefficient
# Code taken from https://goo.gl/vhy4jp
def nCk(n, k):

    C = [0]* (k+1)

    C[0] = 1 # nC0 is 1

    for i in range(1, n+1):

        # Compute next row of pascal triangle
        # using the previous row
        j = min(i, k)

        while(j>0):

            C[j] = C[j] + C[j-1]
            j = j - 1

    return C[k]

#function to calculate number of straight lines
# can be formed
def count_Straightlines(n, m):

    return (nCk(n, 2) - nCk(m, 2)+1)

# Driven code
n = 4
m = 3
print( count_Straightlines(n, m) );

# This code is contributed by "rishabh_jain".

C#

// C# program to count number of straight
// lines with n total points, out of
// which m are collinear.
using System;

public class GfG {

    // Returns value of binomial coefficient
    // Code taken from https://goo.gl/vhy4jp
    public static int nCk(int n, int k)
    {
        int[] C = new int[k + 1];

        // nC0 is 1
        C[0] = 1;

        for (int i = 1; i <= n; i++)
        {

            // Compute next row of pascal triangle
            // using the previous row
            for (int j = Math.Min(i, k); j > 0; j--)
                C[j] = C[j] + C[j - 1];
        }

        return C[k];
    }


    // Function to calculate number of
    // straight lines can be formed
    public static int count_Straightlines(int n, int m)
    {
        return (nCk(n, 2) - nCk(m, 2) + 1);
    }


    // Driver Code
    public static void Main(String []args)
    {
        int n = 4, m = 3;
        Console.WriteLine(count_Straightlines(n, m));
    }


}

// This code is contributed by vt_m.

PHP

<?php
// PHP program to count number of straight lines
// with n total points, out of which m are
// collinear.

// Returns value of binomial coefficient
function nCk($n, $k)
{
    $C = array_fill(0, $k + 1, NULL);

    $C[0] = 1; // nC0 is 1

    for ($i = 1; $i <= $n; $i++)
    {

        // Compute next row of pascal triangle
        // using the previous row
        for ($j = min($i, $k); $j > 0; $j--)
            $C[$j] = $C[$j] + $C[$j-1];
    }
    return $C[$k];
}


// function to calculate
// number of straight lines
// can be formed
function count_Straightlines($n, $m)
{

    return (nCk($n, 2) - nCk($m, 2) + 1);

}

// Driver Code
$n = 4;
$m = 3;
echo(count_Straightlines($n, $m));

// This code is contributed
// by Prasad Kshirsagar
?>

Javascript

<script>
    // Javascript program to count number of straight
    // lines with n total points, out of
    // which m are collinear.

    // Returns value of binomial coefficient
    // Code taken from https://goo.gl/vhy4jp
    function nCk(n, k)
    {

        let C = new Array(k+1);
        C.fill(0);

        C[0] = 1;  // nC0 is 1

        for (let i = 1; i <= n; i++)
        {

            // Compute next row of pascal triangle
            // using the previous row
            for (let j = Math.min(i, k); j > 0; j--)

                C[j] = C[j] + C[j-1];
        }

        return C[k];
    }


    /* function to calculate number of straight lines
       can be formed */
    function count_Straightlines(n,m)
    {
        return (nCk(n, 2) - nCk(m, 2)+1);
    }

    let n = 4, m = 3 ;
    document.write(count_Straightlines(n, m));

    // This code is contributed by divyesh072019.
</script>

Output: 

4

Time Complexity: O(max(n,m)) 
Auxiliary Space: O(1)

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above