Re: Removing multiple elements from array

[Ali Çehreli]

On 12/20/2013 04:47 PM, aldanor wrote:

> Is there an efficient method to remove elements with multiple
> (compile-time-unknown) indices from an array? I currently do 
something like
>
>          if (!index.empty)
>              foreach (i; index.sort.reverse)
>                  a = a.remove(i);

That's probably a bug, right? The indexes would probably become off as 
the array gets shorter.

> ... which looks a bit awkward.

I am sure others can come up with solutions but I can't think of a way 
of doing this Phobos right now. :)

Here is a range that does what you want (not very well tested ;) ):

import std.stdio;
import std.array;
import std.range;
import std.algorithm;

struct SkipIndexes(R, I)
{
    alias SortedIndexRange = typeof((I.init).sort.uniq);

    R range;
    SortedIndexRange indexes;
    size_t currentIndex;

    this(R range, I indexes, size_t currentIndex = 0)
    {
        this.range = range;
        this.indexes = indexes.sort.uniq;
        this.currentIndex = currentIndex;

        prime();
    }

    bool empty() const @property
    {
        return range.empty;
    }

    ElementType!R front() const @property
    {
        return range.front;
    }

    void prime()
    {
        while (!empty && !indexes.empty && (indexes.front == 
currentIndex)) {
            range.popFront();
            indexes.popFront();
            ++currentIndex;
        }
    }

    void popFront()
    {
        range.popFront();
        ++currentIndex;
        prime();
    }

    auto save() @property
    {
        return this;
    }

    void report() const
    {
        writeln(indexes);
        writeln(currentIndex);
    }
}

auto skipIndexes(R, I)(R range, I skipIndexes, size_t currentIndex = 0)
{
    return SkipIndexes!(R, I)(range, skipIndexes, currentIndex);
}

void main()
{
    auto arr = [ 0, 1, 2, 3, 4, 5 ];
    size_t[] badIndexes = [ 0, 1, 5 ];

    auto skipped = arr.skipIndexes(badIndexes);

    // skipped is a lazy range:
    assert(skipped.equal([ 2, 3, 4 ]));

    // arr is untouched at this point:
    assert(arr == [ 0, 1, 2, 3, 4, 5 ]);

    // To affect it, assign from .array of the lazy range:
    arr = skipped.array;
    assert(arr == [ 2, 3, 4 ]);
}

Ali