# Count ways to divide C in two parts and add to A and B to make A strictly greater than B

Given three integers **A, B** and **C**, the task is to count the number of ways to divide **C** into two parts and add to **A** and **B** such that **A is strictly greater than B**. **Examples:**

Input:A = 5, B = 3, C = 4Output:3

The possible values of A and B after dividing C are:

A = 7, B = 5 where C is divided into 2 and 2.

A = 8, B = 4 where C is divided into 3 and 1.

A – 9, B = 3 where C is divided into 4 and 0.Input:A = 3, B = 5, C = 5Output:2

**Approach:** On observing carefully, the following relation is formed for this problem.

- Let
**addA**and**addB**be added to**A**and**B**respectively. - Therefore,
**addA + addB = C**and it should satisfy the inequality**A + addA > B + addB**. - Now, since
**addB = C – addA**and put it in the inequality:

A + addA > B + (C - addA) or, 2addA > C + B - A or, 2addA >= C + B - A + 1 or, addA >= (C + B - A + 1) / 2

- Since
**addA**must be non negative,**addA = max(0, (C + B – A + 1) / 2)**. - The division should be ceiling division, thus we can rewrite as
**addA = max(0, (C + B – A + 2) / 2).** - Let this value be equal to
**minAddA**. Since all integer values**addA**from**[minAddA, C]**, satisfies the relation**A + addA > B + addB**, so the required number of ways is equal to**max(0, C – minAddA + 1)**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count the number of ways to divide` `// C into two parts and add to A and B such` `// that A is strictly greater than B` `int` `countWays(` `int` `A, ` `int` `B, ` `int` `C)` `{` ` ` `// Minimum value added to A to satisfy` ` ` `// the given relation` ` ` `int` `minAddA = max(0, (C + B - A + 2) / 2);` ` ` `// Number of different values of A, i.e.,` ` ` `// number of ways to divide C` ` ` `int` `count_ways = max(C - minAddA + 1, 0);` ` ` `return` `count_ways;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `A = 3, B = 5, C = 5;` ` ` `cout << countWays(A, B, C);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the above approach` `import` `java.util.*;` `class` `GFG{` ` ` `// Function to count the number of ways to divide` ` ` `// C into two parts and add to A and B such` ` ` `// that A is strictly greater than B` ` ` `static` `int` `countWays(` `int` `A, ` `int` `B, ` `int` `C)` ` ` `{` ` ` `// Minimum value added to A to satisfy` ` ` `// the given relation` ` ` `int` `minAddA = Math.max(` `0` `, (C + B - A + ` `2` `) / ` `2` `);` ` ` ` ` `// Number of different values of A, i.e.,` ` ` `// number of ways to divide C` ` ` `int` `count_ways = Math.max(C - minAddA + ` `1` `, ` `0` `);` ` ` ` ` `return` `count_ways;` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` `int` `A = ` `3` `, B = ` `5` `, C = ` `5` `;` ` ` ` ` `System.out.println(countWays(A, B, C));` ` ` `}` `}` `// This code is contributed by AbhiThakur` |

## Python3

`# Python3 implementation of the above approach` `# Function to count the number of ways to divide` `# C into two parts and add to A and B such` `# that A is strictly greater than B` `def` `countWays(A, B, C):` ` ` ` ` `# Minimum value added to A to satisfy` ` ` `# the given relation` ` ` `minAddA ` `=` `max` `(` `0` `, (C ` `+` `B ` `-` `A ` `+` `2` `) ` `/` `/` `2` `)` ` ` ` ` `# Number of different values of A, i.e.,` ` ` `# number of ways to divide C` ` ` `count_ways ` `=` `max` `(C ` `-` `minAddA ` `+` `1` `, ` `0` `)` ` ` ` ` `return` `count_ways` `# Driver code` `A ` `=` `3` `B ` `=` `5` `C ` `=` `5` `print` `(countWays(A, B, C))` `# This code is contributed by shivanisingh` |

## C#

`// C# implementation of the above approach` `using` `System;` ` ` `class` `GFG` `{` `// Function to count the number of ways to divide` `// C into two parts and add to A and B such` `// that A is strictly greater than B` `static` `int` `countWays(` `int` `A, ` `int` `B, ` `int` `C)` `{` ` ` `// Minimum value added to A to satisfy` ` ` `// the given relation` ` ` `int` `minAddA = Math.Max(0, (C + B - A + 2) / 2);` ` ` `// Number of different values of A, i.e.,` ` ` `// number of ways to divide C` ` ` `int` `count_ways = Math.Max(C - minAddA + 1, 0);` ` ` `return` `count_ways;` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `A = 3, B = 5, C = 5;` ` ` `Console.Write(countWays(A, B, C));` `}` `}` `// This code is contributed by shivanisinghss2110` |

## Javascript

`<script>` `// Javascript implementation of the above approach` `// Function to count the number of ways to divide` `// C into two parts and add to A and B such` `// that A is strictly greater than B` `function` `countWays(A, B, C)` `{` ` ` `// Minimum value added to A to satisfy` ` ` `// the given relation` ` ` `var` `minAddA = Math.max(0, parseInt((C + B - A + 2) / 2));` ` ` `// Number of different values of A, i.e.,` ` ` `// number of ways to divide C` ` ` `var` `count_ways = Math.max(C - minAddA + 1, 0);` ` ` `return` `count_ways;` `}` `// Driver code` `var` `A = 3, B = 5, C = 5;` `document.write( countWays(A, B, C));` `// This code is contributed by rutvik_56.` `</script>` |

**Output:**

2

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