Hacker News Reader

Comment by JoachimSchipper | Hacker News Reader

Even with plain C, you can just iterate backwards:

    for (i = ctr_size(container); i > 0; i--)
        if (!predicate(container, i - 1))
            ctr_remove(container, i - 1);

View on HN

Use the goes-to-zero operator.

  for (i = container.size; i-->0;)
    if(deletep(container, i))
      container.remove(i);

Reminds me of something :)

    for (i = ctr_size(container); i--; )
        if (!predicate(container, i))
            ctr_remove(container, i);

That's arguably better. Nitpick: start at ctr_size(container) - 1. [Feel free to edit your post, and I'll just delete this one.]

Nope. The decrement is occurring in the test, so it occurs after the initialization and before the first iteration.

  filter predicate xs

Haskell, I assume. Two things really make Haskell shine when it comes to problems like this: 1) higher-order list operations -- you're not iterating through indices, so there is no possibility for off-by-one errors, and 2) immutability -- your code takes a new list with the undesirable elements removed; you can't remove elements of a structure at the same time you're iterating through it.

I always love the problems on SPOJ where they give you the number of cases up front, because in Haskell you can almost always throw out that value. Your map function knows when the list is out of elements.

Yeah, I was thinking Haskell, but any functional language will do. Problems like the one in the blog post really make you appreciate them.

The snippet I posted can easily be made into a generic function<T> that takes a collection<T> and a predicate<T>. For example, the Apache Commons library offers such a function for Java, so where available the code comes down to the fairly similar

  CollectionUtils.filter(collection, predicate);

Of course aside from being a bit more verbose, predicate needs to be an object (often a singleton), because you can't pass around functions.

It's not as concise as Haskell, but the addition of FP capabilities to C# make it a lot more pleasant as a practical language than it was in earlier days.

var filteredCollection = collection.Where(x => predicate(x));

As far as I remember you can write that as

  var filteredCollection = collection.Where(predicate);

I agree that C# is a fundamentally usable language.

l = [i for i in l if predicate(i)]

  while(container.Size > 0)
    container.Remove(0);

No need for variables.

  container.clear();

No need for looping :)

Yeah sure, :) , but I meant for those other cases when there are no Clear() method. :)

Reply on news.ycombinator.com