Related Articles

Related Articles

Probability of collision between two trucks
  • Difficulty Level : Medium
  • Last Updated : 02 Dec, 2020

Given two strings S and T, where S represents the first lane in which vehicles move from left to right and T represents the second lane in which vehicles move from right to left. Vehicles can be of either B (bike), C (car) or T (truck). The task is to find the probability of collision between two trucks.

Examples:

Input: S = “TCCBCTTB”, T = “BTCCBBTT”
Output: 0.194444
Explanation:
Total collision = 7
Total accident = 36
Therefore, the probability can be calculated by 7/36 = 0.19444.

Input: S = “BTT”, T = “BTCBT”
Output: 0.25000

Illustration:



S = "TCCBCTTB", T = "BTCCBBTT"

Possible cases   | Accidents | Collision
-----------------------------------------       
TCCBCTTB         |           |
BTCCBBTT         |     8     |   1
                 |           |  
 TCCBCTTB        |           |
BTCCBBTT         |     7     |   2
                 |           |
  TCCBCTTB       |           |
BTCCBBTT         |     6     |   1
                 |           |
   TCCBCTTB      |           |
BTCCBBTT         |     5     |   0
                 |           |
    TCCBCTTB     |           |
BTCCBBTT         |     4     |   0
                 |           |
     TCCBCTTB    |           |
BTCCBBTT         |     3     |   0
                 |           |
      TCCBCTTB   |           |
BTCCBBTT         |     2     |   1
                 |           |
       TCCBCTTB  |           |
BTCCBBTT         |     1     |   1

Total number of accidents: 8+7+6+5+4+3+2+1=36
Total number of collision: 1+2+1+0+0+0+1+1=7
Probability: 7/36=0.19444

Approach: Follow the steps below to solve the problem:

  • Find the total number of favorable outcomes as the total number of collisions(accidents between trucks) and the total number of possible outcomes(total number of collisions) as the total number of accidents.
  • Initialize a variable answer equals to 0 to stores the count of collisions.
  • Count the number of trucks in the string T and store it in a variable count.
  • Iterate over the characters of the strings S and T simultaneously:
    • If S[i] is equal to ‘T’, increment answer by count.
    • If T[i] is equal to ‘T’, decrement the count by 1.
  • Now, calculate the total number of possible outcomes (total number of accidents). It is the sum of all the length of overlapping if keep shifting string a towards right or string b towards left by one unit.
  • Let the length of string be N and string b be M. Then, the total number of overlapping will be:
  • Find the probability as the ratio of count of the collisions and count of the accidents.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate total
// number of accidents
double count_of_accident(string a,
                         string b)
{
    // String size
    int n = a.size(), m = b.size();
 
    if (n > m)
        return (m * (m + 1)) / 2;
    else
        return (n * (n + 1))
                   / 2
               + (m - n) * n;
}
 
// Function to calculate count
// of all possible collision
double count_of_collision(string a,
                          string b)
{
    int n = a.size(), m = b.size();
 
    // Stores the count of collisions
    int answer = 0;
 
    // Total number of truck in lane b
    int count_of_truck_in_lane_b = 0;
    for (int i = 0; i < m; i++)
        if (b[i] == 'T')
            count_of_truck_in_lane_b++;
 
    // Count total number of collisions
    // while traversing the string a
    for (int i = 0; i < n && i < m; i++) {
        if (a[i] == 'T')
            answer
                += count_of_truck_in_lane_b;
 
        if (b[i] == 'T')
            count_of_truck_in_lane_b--;
    }
    return answer;
}
 
// Function to calculate the
// probability of collisions
double findProbability(string a,
                       string b)
{
    // Evaluate total outcome that is
    // all the possible accident
    double total_outcome
        = count_of_accident(a, b);
 
    // Evaluate favourable outcome i.e.,
    // count of collision of trucks
    double favourable_outcome
        = count_of_collision(a, b);
 
    // Print desired probabilty
    cout << favourable_outcome
                / total_outcome;
}
 
// Driver Code
int main()
{
    string S = "TCCBCTTB", T = "BTCCBBTT";
 
    // Function Call
    findProbability(S, T);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
 
class GFG
{
 
// Function to calculate total
// number of accidents
static int count_of_accident(String a,
                         String b)
{
    // String size
    int n = a.length(), m = b.length();
 
    if (n > m)
        return (m * (m + 1)) / 2;
    else
        return (n * (n + 1))
                   / 2
               + (m - n) * n;
}
 
// Function to calculate count
// of all possible collision
static double count_of_collision(String a,
                          String b)
{
    int n = a.length(), m = b.length();
 
    // Stores the count of collisions
    double answer = 0;
 
    // Total number of truck in lane b
    int count_of_truck_in_lane_b = 0;
    for (int i = 0; i < m; i++)
        if (b.charAt(i) == 'T')
            count_of_truck_in_lane_b++;
 
    // Count total number of collisions
    // while traversing the String a
    for (int i = 0; i < n && i < m; i++)
    {
        if (a.charAt(i) == 'T')
            answer
                += count_of_truck_in_lane_b;
 
        if (b.charAt(i) == 'T')
            count_of_truck_in_lane_b--;
    }
    return answer;
}
 
// Function to calculate the
// probability of collisions
static void findProbability(String a,
                       String b)
{
    // Evaluate total outcome that is
    // all the possible accident
    int total_outcome
        = count_of_accident(a, b);
 
    // Evaluate favourable outcome i.e.,
    // count of collision of trucks
    double favourable_outcome
        = count_of_collision(a, b);
 
    // Print desired probabilty
    System.out.printf("%4f",favourable_outcome
                / total_outcome);
}
 
// Driver Code
public static void main(String[] args)
{
    String S = "TCCBCTTB", T = "BTCCBBTT";
 
    // Function Call
    findProbability(S, T);
}
}
 
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
 
# Function to calculate total
# number of accidents
def count_of_accident(a, b):
     
    n = len(a)
    m = len(b)
     
    if (n > m):
        return (m * (m + 1)) / 2
    else:
        return ((n * (n + 1)) / 2 +
                (m - n) * n)
 
# Function to calculate count
# of all possible collision
def count_of_collision(a, b):
     
    # Size of string
    n = len(a)
    m = len(b)
 
    # Stores the count of collisions
    answer = 0
 
    # Total number of truck in lane b
    count_of_truck_in_lane_b = 0
     
    for i in range(0, m):
        if (b[i] == 'T'):
            count_of_truck_in_lane_b += 1
 
    # Count total number of collisions
    # while traversing the string a
    i = 0
    while (i < m and i < n):
        if (a[i] == 'T'):
            answer += count_of_truck_in_lane_b
        if (b[i] == 'T'):
            count_of_truck_in_lane_b -= 1
             
        i += 1
         
    return answer
 
# Function to calculate the
# probability of collisions
def findProbability(a, b):
     
    # Evaluate total outcome that is
    # all the possible accident
    total_outcome = count_of_accident(a, b);
 
    # Evaluate favourable outcome i.e.,
    # count of collision of trucks
    favourable_outcome = count_of_collision(a, b);
 
    # Print desired probabilty
    print(favourable_outcome / total_outcome)
  
# Driver Code 
if __name__ == "__main__" :
     
    S = "TCCBCTTB"
    T = "BTCCBBTT"
 
    # Function Call
    findProbability(S, T)
     
# This code is contributed by Virusbuddah_

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
 
class GFG
{
 
// Function to calculate total
// number of accidents
static int count_of_accident(String a,
                         String b)
{
    // String size
    int n = a.Length, m = b.Length;
 
    if (n > m)
        return (m * (m + 1)) / 2;
    else
        return (n * (n + 1))
                   / 2
               + (m - n) * n;
}
 
// Function to calculate count
// of all possible collision
static double count_of_collision(String a,
                          String b)
{
    int n = a.Length, m = b.Length;
 
    // Stores the count of collisions
    double answer = 0;
 
    // Total number of truck in lane b
    int count_of_truck_in_lane_b = 0;
    for (int i = 0; i < m; i++)
        if (b[i] == 'T')
            count_of_truck_in_lane_b++;
 
    // Count total number of collisions
    // while traversing the String a
    for (int i = 0; i < n && i < m; i++)
    {
        if (a[i] == 'T')
            answer
                += count_of_truck_in_lane_b;
 
        if (b[i] == 'T')
            count_of_truck_in_lane_b--;
    }
    return answer;
}
 
// Function to calculate the
// probability of collisions
static void findProbability(String a,
                       String b)
{
    // Evaluate total outcome that is
    // all the possible accident
    int total_outcome
        = count_of_accident(a, b);
 
    // Evaluate favourable outcome i.e.,
    // count of collision of trucks
    double favourable_outcome
        = count_of_collision(a, b);
 
    // Print desired probabilty
    Console.Write("{0:F4}", favourable_outcome
                / total_outcome);
}
 
// Driver Code
public static void Main(String[] args)
{
    String S = "TCCBCTTB", T = "BTCCBBTT";
 
    // Function Call
    findProbability(S, T);
}
}
 
 
// This code is contributed by sapnasingh4991

chevron_right


Output: 

0.194444

 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :