# Maximize ropes of consecutive length possible by connecting given ropes

Given an array **A[ ]** of size **N **where each array element represents the length of a rope, the task is to find the number of ropes of consecutive length that can be created by connecting given ropes starting from length **1**.

**Examples :**

Input:N = 5, A[ ] = {1, 2, 7, 1, 1}

Output:5Explanation:

Length | Ropes

1 | [1]

2 | [1, 1]

3 | [1, 2]

4 | [1, 2, 1]

5 | [1, 2, 1, 1]

InputN = 5, A = {1, 3, 2, 4, 2}Output:12

**Approach:** This problem can be solved by using the fact that if we are able to create ropes of range **[1, K] **lengths and there is a rope left of length **L** such that **(L <=** **K+1)** then we can create ropes of range** [1, K+L]** by adding **L** length rope to each rope of the range **[max(1, K-L+1), K]**. So to solve the problem, first, sort the array and then traverse the array and check each time if the current element is less than or equal to the maximum consecutive length we have obtained + 1. If found to be true, add that element to maximum consecutive length. Otherwise, return the answer.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find maximized count` `// of ropes of consecutive length` `int` `maxConsecutiveRopes(` `int` `ropes[], ` `int` `N)` `{` ` ` `// Stores the maximum count` ` ` `// of ropes of consecutive length` ` ` `int` `curSize = 0;` ` ` `// Sort the ropes by their length` ` ` `sort(ropes, ropes + N);` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// If size of the current rope is less` ` ` `// than or equal to current maximum` ` ` `// possible size + 1, update the` ` ` `// range to curSize + ropes[i]` ` ` `if` `(ropes[i] <= curSize + 1) {` ` ` `curSize = curSize + ropes[i];` ` ` `}` ` ` `// If a rope of size (curSize + 1)` ` ` `// cannot be obtained` ` ` `else` ` ` `break` `;` ` ` `}` ` ` `return` `curSize;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Input` ` ` `int` `N = 5;` ` ` `int` `ropes[] = { 1, 2, 7, 1, 1 };` ` ` `// Function Call` ` ` `cout << maxConsecutiveRopes(ropes, N);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to find maximized count` ` ` `// of ropes of consecutive length` ` ` `static` `int` `maxConsecutiveRope(` `int` `ropes[], ` `int` `N)` ` ` `{` ` ` `// Stores the maximum count` ` ` `// of ropes of consecutive length` ` ` `int` `curSize = ` `0` `;` ` ` `// Sort the ropes by their length` ` ` `Arrays.sort(ropes);` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) {` ` ` `// If size of the current rope is less` ` ` `// than or equal to current maximum` ` ` `// possible size + 1, update the` ` ` `// range to curSize + ropes[i]` ` ` `if` `(ropes[i] <= curSize + ` `1` `) {` ` ` `curSize = curSize + ropes[i];` ` ` `}` ` ` `// If a rope of size (curSize + 1)` ` ` `// cannot be obtained` ` ` `else` ` ` `break` `;` ` ` `}` ` ` `return` `curSize;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `// Input` ` ` `int` `N = ` `5` `;` ` ` `int` `ropes[] = { ` `1` `, ` `2` `, ` `7` `, ` `1` `, ` `1` `};` ` ` `// Function Call` ` ` `System.out.println(` ` ` `maxConsecutiveRope(ropes, N));` ` ` `}` `}` |

## Python3

`# Python3 program for the above approach` `# Function to find maximized count` `# of ropes of consecutive length` `def` `maxConsecutiveRopes(ropes, N):` ` ` `# Stores the maximum count` ` ` `# of ropes of consecutive length` ` ` `curSize ` `=` `0` ` ` `# Sort the ropes by their length` ` ` `ropes ` `=` `sorted` `(ropes)` ` ` `# Traverse the array` ` ` `for` `i ` `in` `range` `(N):` ` ` ` ` `# If size of the current rope is less` ` ` `# than or equal to current maximum` ` ` `# possible size + 1, update the` ` ` `# range to curSize + ropes[i]` ` ` `if` `(ropes[i] <` `=` `curSize ` `+` `1` `):` ` ` `curSize ` `=` `curSize ` `+` `ropes[i]` ` ` `# If a rope of size (curSize + 1)` ` ` `# cannot be obtained` ` ` `else` `:` ` ` `break` ` ` `return` `curSize` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Input` ` ` `N ` `=` `5` ` ` `ropes ` `=` `[ ` `1` `, ` `2` `, ` `7` `, ` `1` `, ` `1` `]` ` ` `# Function Call` ` ` `print` `(maxConsecutiveRopes(ropes, N))` ` ` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` ` ` `// Function to find maximized count` `// of ropes of consecutive length` `static` `int` `maxConsecutiveRope(` `int` `[] ropes, ` `int` `N)` `{` ` ` ` ` `// Stores the maximum count` ` ` `// of ropes of consecutive length` ` ` `int` `curSize = 0;` ` ` `// Sort the ropes by their length` ` ` `Array.Sort(ropes);` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < N; i++)` ` ` `{` ` ` ` ` `// If size of the current rope is less` ` ` `// than or equal to current maximum` ` ` `// possible size + 1, update the` ` ` `// range to curSize + ropes[i]` ` ` `if` `(ropes[i] <= curSize + 1)` ` ` `{` ` ` `curSize = curSize + ropes[i];` ` ` `}` ` ` `// If a rope of size (curSize + 1)` ` ` `// cannot be obtained` ` ` `else` ` ` `break` `;` ` ` `}` ` ` `return` `curSize;` `}` `// Driver code` `public` `static` `void` `Main ()` `{` ` ` ` ` `// Input` ` ` `int` `N = 5;` ` ` `int` `[] ropes = { 1, 2, 7, 1, 1 };` ` ` `// Function Call` ` ` `Console.WriteLine(maxConsecutiveRope(ropes, N));` `}` `}` `// This code is contributed by souravghosh0416` |

## Javascript

`<script>` `// Javascript program for the above approach` `// Function to find maximized count` `// of ropes of consecutive length` `function` `maxConsecutiveRopes(ropes, N)` `{` ` ` `// Stores the maximum count` ` ` `// of ropes of consecutive length` ` ` `let curSize = 0;` ` ` `// Sort the ropes by their length` ` ` `ropes.sort((a, b) => a - b)` ` ` `// Traverse the array` ` ` `for` `(let i = 0; i < N; i++) {` ` ` `// If size of the current rope is less` ` ` `// than or equal to current maximum` ` ` `// possible size + 1, update the` ` ` `// range to curSize + ropes[i]` ` ` `if` `(ropes[i] <= curSize + 1) {` ` ` `curSize = curSize + ropes[i];` ` ` `}` ` ` `// If a rope of size (curSize + 1)` ` ` `// cannot be obtained` ` ` `else` ` ` `break` `;` ` ` `}` ` ` `return` `curSize;` `}` `// Driver Code` `// Input` `let N = 5;` `let ropes = [ 1, 2, 7, 1, 1 ];` `// Function Call` `document.write(maxConsecutiveRopes(ropes, N));` `// This contributed by _saurabh_jaiswal` `</script>` |

**Output:**

5

**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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.