Replace bit in BitArray c#

Question

I am using this to convert a file into a BitArray:

public static byte[] GetBinaryFile(string filename)
{
    byte[] bytes;
    using (FileStream file = new FileStream(filename, FileMode.Open, FileAccess.Read))
    {
       bytes = new byte[file.Length];
       file.Read(bytes, 0, (int)file.Length);
    }
    return bytes;
}
var x=GetBinaryFile(@"path");
BitArray bits = new BitArray(x);

How do I replace a pattern of Bit in a BitArray?

let's suppose I have this pattern: 010101 and I want to change it with X — Ben
– Ben, Commented Jul 23, 2016 at 14:45
E.g I start reading and creating chunks of 10 bits, then if this pattern is in these chunks replace with X — Ben
– Ben, Commented Jul 23, 2016 at 14:48
A couple of questions - is X the same length as the pattern? And how big is the array? (ie do we need to be efficient?) — David E
– David E, Commented Jul 23, 2016 at 14:49
The array might be very big (but it won't happen very often) I would say the size will be around 50 Mb / file... X yeah — Ben
– Ben, Commented Jul 23, 2016 at 14:52

Ashkan S · Accepted Answer · 2016-07-23 15:46:32Z

0

you can use Set method to set special bit in the BitArray.

bits.Set(index, value);

value is a bool, which will translate to 0 and 1 in your bitarray

i.e: To set the 10th bit to 1 use

bits.Set(9, true);

edited Jul 23, 2016 at 15:46

answered Jul 23, 2016 at 15:38

Ashkan S

11.7k6 gold badges58 silver badges92 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Ashkan S Over a year ago

@DavidE sorry I don't understand what you are asking. I didn't write for using a replace method. Set method have 2 inputs, the first one is the index in the bit array. So if he wants to change the 10th bit to 1, he has to write bits.Set(9, true);

David E · Accepted Answer · 2016-07-23 16:45:20Z

The below code should work, using a basic two-pass algorithm to find match locations and then do the replacements.

Note that for 10MB files, it takes roughly 10 seconds on my semi-decent laptop. If you want it to go faster, you can implement it using byte arrays and masks instead of the clunky and not-so-powerful BitArray abstraction.

Even better, you could use unsafe code, where you can make use of pointers and much faster copying... But as it's a C# question and you're already using the BitArray abstraction, I thought I'd show you how it can be achieved as is.

    private static BitArray Replace(BitArray input, BitArray pattern, BitArray replacement)
    {
        var replacementPositions = GetReplacementPositions(input, pattern);
        return PerformReplacements(input, pattern.Length, replacement, replacementPositions);
    }

    private static List<int> GetReplacementPositions(BitArray input, BitArray pattern)
    {
        if (pattern.Length == 0) throw new Exception("Pattern cannot have 0 length");

        var matchIndicies = new List<int>();
        var maxCheckIndex = input.Length - pattern.Length;
        var i = 0;
        while (i <= maxCheckIndex)
        {
            if (MatchesAt(input, pattern, i))
            {
                matchIndicies.Add(i);
                i += pattern.Length;
                continue;
            }
            i++;
        }
        return matchIndicies;
    }

    private static bool MatchesAt(BitArray input, BitArray pattern, int index)
    {
        for (var j = 0; j < pattern.Length; j++)
        {
            if (input[index + j] != pattern[j]) return false;
        }
        return true;
    }

    private static BitArray PerformReplacements(BitArray input, int patternLength, BitArray replacement, List<int> replacementPositions)
    {
        var outLength = input.Length + replacementPositions.Count * (replacement.Length - patternLength);
        var output = new BitArray(outLength);

        var currentReadIndex = 0;
        var currentWriteIndex = 0;
        foreach (var matchPosition in replacementPositions)
        {
            var inputSubstringLength = matchPosition - currentReadIndex;

            CopyFromTo(input, output, currentReadIndex, inputSubstringLength, currentWriteIndex);

            currentReadIndex = matchPosition + patternLength;
            currentWriteIndex += inputSubstringLength;

            CopyFromTo(replacement, output, 0, replacement.Length, currentWriteIndex);
            currentWriteIndex += replacement.Length;
        }
        CopyFromTo(input, output, currentReadIndex, input.Length - currentReadIndex, currentWriteIndex);
        return output;
    }

    private static void CopyFromTo(BitArray from, BitArray to, int fromIndex, int fromLength, int toIndex)
    {
        for (var i = 0; i < fromLength; i++)
        {
            to.Set(toIndex + i, from.Get(fromIndex + i));
        }
    }

@Ben You make a BitArray from a byte[], no? So do you not need: BitArray value = new BitArray(new [] {xh}) ?

Collectives™ on Stack Overflow

Replace bit in BitArray c#

2 Answers 2

1 Comment

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related