Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Maximum number of people that can be killed with strength P

  • Difficulty Level : Medium
  • Last Updated : 05 May, 2022

There are infinite people standing in a row, indexed from 1. A person having index i has strength of i2. You have strength P and the task is to tell what is the maximum number of people you can kill with strength P
You can only kill a person with strength X if P ≥ X and after killing him, your strength decreases by X

Examples: 

Input: P = 14 
Output:
Explaination: First person will have strength 12 = 1 which is < P 
P gets reduced to 13 after the first kill. 
Second kill, P = 13 – 22 = 9 
Third kill, P = 9 – 32 = 0

Input: P = 58 
Output:

Naive approach: Check every single kill starting from 1 until the strength P is greater than or equal to the strength of the person being killed.

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum number of people that can
// be killed
int maxPeople(int p)
{
    int tmp = 0, count = 0;
 
    // Loop will break when the ith person cannot be killed
    for (int i = 1; i * i <= p; i++) {
        tmp = tmp + (i * i);
        if (tmp <= p)
            count++;
        else
            break;
    }
    return count;
}
 
// Driver code
int main()
{
    int p = 14;
    cout << maxPeople(p);
 
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)

C




// C implementation of the approach
#include <stdio.h>
 
// Function to return the maximum number of people that can
// be killed
int maxPeople(int p)
{
    int tmp = 0, count = 0;
 
    // Loop will break when the ith person cannot be killed
    for (int i = 1; i * i <= p; i++) {
        tmp = tmp + (i * i);
        if (tmp <= p)
            count++;
        else
            break;
    }
    return count;
}
 
// Driver code
int main()
{
    int p = 14;
    printf("%d", maxPeople(p));
 
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)

Java




// Java implementation of the approach
import java.util.*;
 
class GFG {
    // Function to return the maximum number of people that
    // can be killed
    static int maxPeople(int p)
    {
        int tmp = 0, count = 0;
 
        // Loop will break when the ith person cannot be
        // killed
        for (int i = 1; i * i <= p; i++) {
            tmp = tmp + (i * i);
            if (tmp <= p)
                count++;
            else
                break;
        }
        return count;
    }
 
    // Driver code
    public static void main(String args[])
    {
        int p = 14;
        System.out.println(maxPeople(p));
    }
}
 
// This code is contributed by Aditya Kumar (adityakumar129)

Python3




# Python3 implementation of the approach
 
from math import sqrt
 
# Function to return the maximum
# number of people that can be killed
def maxPeople(p) :
     
    tmp = 0; count = 0;
 
    # Loop will break when the ith person
    # cannot be killed
    for i in range(1, int(sqrt(p)) + 1) :
        tmp = tmp + (i * i);
        if (tmp <= p) :
            count += 1;
        else :
            break;
     
    return count;
 
 
# Driver code
if __name__ == "__main__" :
 
    p = 14;
    print(maxPeople(p));
     
# This code is contributed by AnkitRai01

C#




// C# implementation of the approach
using System;
 
class GFG
{
     
// Function to return the maximum
// number of people that can be killed
static int maxPeople(int p)
{
    int tmp = 0, count = 0;
 
    // Loop will break when the ith person
    // cannot be killed
    for (int i = 1; i * i <= p; i++)
    {
        tmp = tmp + (i * i);
        if (tmp <= p)
            count++;
        else
            break;
    }
    return count;
}
 
// Driver code
public static void Main()
{
    int p = 14;
    Console.WriteLine(maxPeople(p));
}
}
 
// This code is contributed by anuj_67..

Javascript




<script>
 
// javascript implementation of the approach
   
// Function to return the maximum
// number of people that can be killed
function maxPeople(p)
{
    var tmp = 0, count = 0;
 
    // Loop will break when the ith person
    // cannot be killed
    for (var i = 1; i * i <= p; i++)
    {
        tmp = tmp + (i * i);
        if (tmp <= p)
            count++;
        else
            break;
    }
    return count;
}
 
// Driver code
 
var p = 14;
document.write(maxPeople(p));
 
// This code is contributed by Amit Katiyar
 
</script>
Output
3

Time Complexity: O(sqrt(N)), where N is the initial strength.
Auxiliary Space: O(1)

Efficient approach: We can see if we kill ith person then we have already killed (i – 1)th person. This means it is a monotonic function f whose domain is the set of integers. Now we can apply binary search on this monotonic function in which instead of array lookup we are now looking for some x such that f(x) is equal to the target value. Time complexity reduces to O(Log(n)).

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
 
static constexpr int kN = 1000000;
 
// Function to return the maximum
// number of people that can be killed
int maxPeople(int p)
{
    // Storing the sum beforehand so that
    // it can be used in each query
    ll sums[kN];
    sums[0] = 0;
    for (int i = 1; i < kN; i++)
        sums[i] = (ll)(i * i) + sums[i - 1];
 
    // lower_bound returns an iterator pointing to the
    // first element greater than or equal to your val
    auto it = std::lower_bound(sums, sums + kN, p);
    if (*it > p) {
 
        // Previous value
        --it;
    }
 
    // Returns the index in array upto which
    // killing is possible with strength P
    return (it - sums);
}
 
// Driver code
int main()
{
    int p = 14;
    cout << maxPeople(p);
 
    return 0;
}

Java




// Java implementation of the approach
class GFG
{
 
static int kN = 1000000;
 
// Function to return the maximum
// number of people that can be killed
static int maxPeople(int p)
{
    // Storing the sum beforehand so that
    // it can be used in each query
    long []sums = new long[kN];
    sums[0] = 0;
    for (int i = 1; i < kN; i++)
        sums[i] = (long)(i * i) + sums[i - 1];
 
    // lower_bound returns an iterator pointing to the
    // first element greater than or equal to your val
    int it = lower_bound(sums, 0, kN, p);
    if (sums[it] > p)
    {
 
        // Previous value
        --it;
    }
 
    // Returns the index in array upto which
    // killing is possible with strength P
    return it;
}
private static int lower_bound(long[] a, int low,
                            int high, int element)
{
    while(low < high)
    {
        int middle = low + (high - low)/2;
        if(element > a[middle])
            low = middle + 1;
        else
            high = middle;
    }
    return low;
}
 
// Driver code
public static void main(String[] args)
{
    int p = 14;
    System.out.println(maxPeople(p));
}
}
 
/* This code is contributed by PrinciRaj1992 */

Python3




# Python3 implementation of the approach
kN = 1000000;
 
# Function to return the maximum
# number of people that can be killed
def maxPeople(p):
 
    # Storing the sum beforehand so that
    # it can be used in each query
    sums = [0] * kN;
    sums[0] = 0;
    for i in range(1, kN):
        sums[i] = (i * i) + sums[i - 1];
 
    # lower_bound returns an iterator
    # pointing to the first element
    # greater than or equal to your val
    it = lower_bound(sums, 0, kN, p);
    if (it > p):
 
        # Previous value
        it -= 1;
 
    # Returns the index in array upto which
    # killing is possible with strength P
    return it;
 
def lower_bound(a, low, high, element):
    while(low < high):
        middle = int(low + (high - low) / 2);
        if(element > a[middle]):
            low = middle + 1;
        else:
            high = middle;
    return low;
 
# Driver code
if __name__ == '__main__':
    p = 14;
    print(maxPeople(p));
 
# This code contributed by Rajput-Ji

C#




// C# implementation of the approach
using System;    
     
public class GFG
{
 
static int kN = 1000000;
 
// Function to return the maximum
// number of people that can be killed
static int maxPeople(int p)
{
    // Storing the sum beforehand so that
    // it can be used in each query
    long []sums = new long[kN];
    sums[0] = 0;
    for (int i = 1; i < kN; i++)
        sums[i] = (long)(i * i) + sums[i - 1];
 
    // lower_bound returns an iterator pointing to the
    // first element greater than or equal to your val
    int it = lower_bound(sums, 0, kN, p);
    if (it > p)
    {
 
        // Previous value
        --it;
    }
 
    // Returns the index in array upto which
    // killing is possible with strength P
    return it;
}
private static int lower_bound(long[] a, int low,
                            int high, int element)
{
    while(low < high)
    {
        int middle = low + (high - low)/2;
        if(element > a[middle])
            low = middle + 1;
        else
            high = middle;
    }
    return low;
}
 
// Driver code
public static void Main(String[] args)
{
    int p = 14;
    Console.WriteLine(maxPeople(p));
}
}
 
// This code has been contributed by 29AjayKumar

Javascript




<script>
// Javascript implementation of the approach
 
const kN = 1000000;
 
// Function to return the maximum
// number of people that can be killed
function maxPeople(p)
{
    // Storing the sum beforehand so that
    // it can be used in each query
    let sums = new Array(kN);
    sums[0] = 0;
    for (let i = 1; i < kN; i++)
        sums[i] = (i * i) + sums[i - 1];
 
    // lower_bound returns an iterator pointing to the
    // first element greater than or equal to your val
    let it = lower_bound(sums, 0, kN, p);
    if (it > p) {
 
        // Previous value
        --it;
    }
 
    // Returns the index in array upto which
    // killing is possible with strength P
    return it;
}
 
function lower_bound(a, low, high, element)
{
    while(low < high)
    {
        let middle = low + parseInt((high - low)/2);
        if(element > a[middle])
            low = middle + 1;
        else
            high = middle;
    }
    return low;
}
 
// Driver code
    let p = 14;
    document.write(maxPeople(p));
 
</script>
Output
3

Time Complexity: O(Log(n))

More Efficient Approach : 
We can do the same problem in time complexity O(logn) and Space Complexity in O(1). Start your binary search by considering the value of low as 0 and high as 10^15. We will calculate the mid-value and according to mid, we will change the position of low and high. 

Below is the implementation of the above approach. 

C++




// C++ implementation of the approach
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
     
// Helper function which returns the sum
// of series (1^2 + 2^2 +...+ n^2)
long squareSeries(long n)
{
    return(n * (n + 1) * (2 * n + 1)) / 6;
}
 
// maxPeople function which returns
// appropriate value using Binary Search
// in O(logn)
long maxPeople(long n)
{
     
    // Set the lower and higher values
    long low = 0;
    long high = 1000000L;
    long ans = 0L;
     
    while (low <= high)
    {
         
        // Calculate the mid using
        // low and high
        long mid = low + ((high - low) / 2);
        long value = squareSeries(mid);
 
        // Compare value with n
        if (value <= n)
        {
            ans = mid;
            low = mid + 1;
        }
        else
        {
            high = mid - 1;
        }
    }
     
    // Return the ans
    return ans;
}
 
// Driver code
int main()
{
    long p = 14;
     
    cout<<maxPeople(p);
    return 0;
}
 
 
// This code contributed by shikhasingrajput

Java




// Java implementation of the approach
class GFG{
     
// Helper function which returns the sum
// of series (1^2 + 2^2 +...+ n^2)
static long squareSeries(long n)
{
    return(n * (n + 1) * (2 * n + 1)) / 6;
}
 
// maxPeople function which returns
// appropriate value using Binary Search
// in O(logn)
static long maxPeople(long n)
{
     
    // Set the lower and higher values
    long low = 0;
    long high = 1000000L;
    long ans = 0L;
     
    while (low <= high)
    {
         
        // Calculate the mid using
        // low and high
        long mid = low + ((high - low) / 2);
        long value = squareSeries(mid);
 
        // Compare value with n
        if (value <= n)
        {
            ans = mid;
            low = mid + 1;
        }
        else
        {
            high = mid - 1;
        }
    }
     
    // Return the ans
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    long p = 14;
     
    System.out.println(maxPeople(p));
}}
 
// This code is contributed by 29AjayKumar

Python3




# Python3 implementation of the approach
 
# helper function which returns the sum
# of series (1^2 + 2^2 +...+ n^2)
def squareSeries(n):
    return (n*(n+1)*(2*n+1))//6
 
# maxPeople function which returns
# appropriate value using Binary Search
# in O(logn)
 
def maxPeople(n):
 
    # Set the lower and higher values
    low = 0
    high = 1000000000000000
    while low<=high:
 
        # calculate the mid using
        # low and high
 
        mid = low + ((high-low)//2)
        value = squareSeries(mid)
 
        #compare value with n
        if value<=n:
            ans = mid
            low = mid+1
        else:
            high = mid-1
 
    # return the ans
    return ans
 
if __name__=='__main__':
    p=14
    print(maxPeople(p))
 
# This code is contributed bu chaudhary_19
# (* Mayank Chaudhary)

C#




// C# implementation of the approach
using System;
 
class GFG{
     
// Helper function which returns the sum
// of series (1^2 + 2^2 +...+ n^2)
static long squareSeries(long n)
{
    return(n * (n + 1) * (2 * n + 1)) / 6;
}
 
// maxPeople function which returns
// appropriate value using Binary Search
// in O(logn)
static long maxPeople(long n)
{
     
    // Set the lower and higher values
    long low = 0;
    long high = 1000000L;
    long ans = 0L;
     
    while (low <= high)
    {
         
        // Calculate the mid using
        // low and high
        long mid = low + ((high - low) / 2);
        long value = squareSeries(mid);
 
        // Compare value with n
        if (value <= n)
        {
            ans = mid;
            low = mid + 1;
        }
        else
        {
            high = mid - 1;
        }
    }
     
    // Return the ans
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    long p = 14;
     
    Console.Write(maxPeople(p));
}}
 
// This code is contributed by shivanisinghss2110

Javascript




<script>
// Javascript implementation of the approach
 
// Helper function which returns the sum
// of series (1^2 + 2^2 +...+ n^2)
function squareSeries(n)
{
    return Math.floor((n * (n + 1) * (2 * n + 1)) / 6);
}
 
// maxPeople function which returns
// appropriate value using Binary Search
// in O(logn)
function maxPeople(n)
{
 
    // Set the lower and higher values
    let low = 0;
    let high = 1000000;
    let ans = 0;
      
    while (low <= high)
    {
          
        // Calculate the mid using
        // low and high
        let mid = low + Math.floor((high - low) / 2);
        let value = squareSeries(mid);
  
        // Compare value with n
        if (value <= n)
        {
            ans = mid;
            low = mid + 1;
        }
        else
        {
            high = mid - 1;
        }
    }
      
    // Return the ans
    return ans;
}
 
// Driver code
let p = 14;
 
document.write(maxPeople(p));
 
// This code is contributed by avanitrachhadiya2155
</script>
Output
3

Time Complexity: O(Log(n)) 
Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!