Unless this problem was rewritten since your comment I have to say this is not even close to one of the hardest ones to understand on this site. But I know exactly what you mean in general. Basically if the description is too heavy with complex math jargon just try skipping to the examples or reading the discussion section.

Well, yes, they can be hard to comprehend sometimes. Consider it practice for the kinds of requirements documents you’ll get :)

C++ solution :

int toys(vector<int> w) {
    sort(w.begin(), w.end());
    int i=0, count=0, base;
    while(i!=w.size())
    {
        count++;
        base = w[i];
        while(i!=w.size() && w[i]<=base+4)
            i++;
        if (i==w.size())    break;
    }
    return count;
}

I think this one was very easy.

how can you think in that way here the remaining two aRE LEFT so you considered each as a unit it isnt same right for all testcases

thank heavens for this comment.

1 Unit is the cost of each toy

Thanks for the clarification.

wow, this is really good.

import sys

def toys(w):
    w = set(w)
    a = 0
    while len(w) >0:
        z = min(w)
        a += 1
        w = list(filter(lambda x: x > z + 4, w))
    return a
    
    # Complete this function

if __name__ == "__main__":
    n = int(input().strip())
    w = list(map(int, input().strip().split(' ')))
    result = toys(w)
    print(result)

another way

I like this too, but time complexity of set operations might be something to consider.

https://wiki.python.org/moin/TimeComplexity

Appears that set difference in Python is O(n).

Pretty much what I did, but I think my syntax is worth a look; it seems more Pythonic to me.

def toys(w):
    ws = set(w)
    ct = 0
    while ws:
        mw = min(ws)
        ws -= set(range(mw, mw+5))
        ct += 1
    return ct

input()
w = [int(s) for s in input().split()]
print(toys(w))

Simple and Elegant!!

amazing!

Inefficient, since you're adding 4 every loop iteration when you only need to add it when the p value changes.

This can be accomplished more efficiently, with respect to both time and space complexity!

This is exactly the same algorithm I worked out in Python. Simple, yet effective.

This is not correct solution, Please check your code

nice algo

This can be done in O(n). Check out counting sort.

my program is not working with this solution so can u help pleasee !!!!!

it works! thanks for your insight :) below a scala implementation. just input toys weight array and done.

def totalCost(toys_list:List[Int]):Int={
    def toBuyToys(arr:List[Int],ref:Int,acc:Int):Int= arr match{
      case Nil => acc
      case x :: xs =>{
        if(x>=ref && x<=(ref+4))
          toBuyToys(xs,ref,acc)
        else
          toBuyToys(xs,x,acc+1)
      }
    }
   val toys_sorted = toys_list.sorted
   toBuyToys(toys_sorted,toys_sorted.head,1)
  }
  println(totalCost(toy_list))

Java 8

    static int toys(int[] w) {
        Arrays.sort(w);
        int count = 1;
        int curr = w[0] + 4;
        for (int i = 1; i < w.length; i++) {
            if (w[i] > curr) {
                count++;
                curr = w[i] + 4;
            }
        }
        return count;
    }