public static bool LeastCommonBit(this BitArray bits)
{
var t = bits.Cast <bool>().Count(b => b);
var f = bits.Cast <bool>().Count(b => !b);
return(t < f);
}
public static void RightShift_Hidden(string label, BitArray bits)
{
_ = label;
Assert.All(bits.Cast <bool>(), bit => Assert.False(bit));
bits.RightShift(1);
Assert.All(bits.Cast <bool>(), bit => Assert.False(bit));
}
public static BitArray[] Divise(BitArray plainTextBitArray, BitArray[] plainText64BitFragments)
{
plainText64BitFragments[0] = new BitArray(plainTextBitArray.Cast <bool>().ToArray().Take(64).ToArray());
for (int i = 1; i < plainTextBitArray.Length / 64; i++)
{
plainText64BitFragments[i] = new BitArray(plainTextBitArray.Cast <bool>().ToArray().Take((i + 1) * 64).Skip(i * 64).ToArray());
}
return(plainText64BitFragments);
}
public IEnumerable <int> Count(int input)
{
CheckInput(input);
int positive = 0;
List <int> result = new List <int>();
BitArray b = new BitArray(new byte[] { (byte)input });
int[] bits = b.Cast <bool>().Select(bit => bit ? 1 : 0).ToArray();
foreach (var item in bits)
{
if (item == 1)
{
positive += 1;
}
}
result.Add(positive);
for (int i = 0; i < bits.Length; i++)
{
if (bits[i] == 1)
{
result.Add(i);
}
}
return(result);
}
private int getRandomDiff()
{
int coeff = 1;
int maxDiff = 8;
int maxRnd = (int)Math.Pow(2, maxDiff) - 1;
BitArray b = new BitArray(new byte[] { (byte)Math.Floor((double)(rnd.Next(0, maxRnd) / coeff)) });
IEnumerable <bool> casted = b.Cast <bool>();
for (int i = 0; i < casted.Count(); i++)
{
if (casted.ElementAt(i))
{
if (i != 0)
{
int sign = (rnd.Next(0, 1) == 0) ? 1 : -1;
return(sign * (i + 1) * coeff);
}
else
{
return((i + 1) * coeff);
}
}
}
return(this.rnd.Next(-8, 8));
}
public static int HammingDistance(byte[] bytesOfString1, byte[] bytesOfString2)
{
var result = CalcXor(bytesOfString1, bytesOfString2);
BitArray bb = new BitArray(result);
var countOfBits = bb.Cast <bool>().Where(x => x).Count(); // alternative to ExtractBitsFromByte(bytesOfString1[i], i);
//for (int i = 0; i < bytesOfString1.Length ; i++) // loop on bytes
//{
// if ((bytesOfString1[i] ^ bytesOfString2[i]) != 0 )
// {
// int[] bitArrayOfString1 = ExtractBitsFromByte(bytesOfString1[i], i);
// int[] bitArrayOfString2 = ExtractBitsFromByte(bytesOfString2[i], i);
// for (int j = 0; j < bitArrayOfString1.Length; j++) // loop on bits
// {
// if ((bitArrayOfString1[j] ^ bitArrayOfString2[j]) != 0)
// {
// counter++;
// }
// }
// }
//}
return(countOfBits);
}
/// <summary>
/// Save a record to a free buffer space. The thread will loop until
/// there is a free space
/// </summary>
/// <param name="record">the record to be saved</param>
/// <returns>the index of buffer that the record is saved to;
/// -1 if not found</returns>
public int SaveRecordToBuffer(dynamic record)
{
int index = -1;
bool isFound = false;
// Wait for free buffer index
SpinWait.SpinUntil(() => bufferSpaceAvailable.
Cast <bool>().Contains(true));
// Look for any available index
// The while loop is to prevent two or multiple possible writer
// Waiting at the same time and race for the same space.
while (isFound == false)
{
for (int i = 0; i < Constant.BUFFER_NUMBER; i++)
{
// Lock the buffer index
lock (bufferLock[i])
{
if (bufferSpaceAvailable[i])
{
index = i;
// Save record onto buffer
RecordBuffer[i] = record;
// Mark buffer space as unavailable
bufferSpaceAvailable[i] = false;
isFound = true;
break;
}
}
}
}
return(index);
}
public static int solution(int number)
{
// Create a bit array
var bitArray = new BitArray(new[] { number });
// Cast it to an int array that is reversed
var bits = bitArray.Cast <bool>().Select(bit => bit ? 1 : 0).ToArray().Reverse();
var maximalGap = 0;
var runningGap = 0;
var started = false;
foreach (var bit in bits)
{
if (started && bit == 0)
{
runningGap++;
}
if (bit == 1)
{
// Only start if iterated over al leading zeros
started = true;
// Check if the last gap is larger than the previous
if (runningGap > maximalGap)
{
maximalGap = runningGap;
}
runningGap = 0;
}
}
return(maximalGap);
}
private IEnumerable <bool> GetSymbolBits(char symbol)
{
var symbolBytes = BitConverter.GetBytes(symbol);
var symbolBits = new BitArray(symbolBytes);
return(symbolBits.Cast <bool>().ToList());
}
public object Run(string input)
{
const int diskSize = 35651584;
string disk = input;
while (disk.Length < diskSize)
{
disk += '0' + string.Concat(disk.ToCharArray().Reverse().Select(c => c == '0' ? '1' : '0').ToArray());
}
var data = new BitArray(disk.Substring(0, diskSize).Select(b => b == '1').ToArray());
do
{
var checksum = new BitArray(data.Length / 2);
for (int i = 0; i < data.Length; i += 2)
{
checksum[i >> 1] = (data[i] == data[i + 1]);
}
data = checksum;
}while (data.Length % 2 == 0);
return(string.Concat(data.Cast <bool>().Select(b => b ? '1' : '0')));
}
public static void Main(string[] args)
{
Console.WriteLine("Advent Of Code 2016, day 5");
const string input = "abbhdwsy";
var counter = 0;
var sb = new StringBuilder(8);
for (int i = 0; counter < 8 && i < int.MaxValue; i++)
{
var subInput = $"{input}{i}";
var md5 = CryptoHelper.GetMd5Hash(subInput);
if (!md5.StartsWith("00000"))
{
continue;
}
sb.Append(md5[5]);
counter++;
}
Console.WriteLine($"The first door password is {sb}");
sb = new StringBuilder(new string(' ', 8));
var mem = new BitArray(8, false);
for (int i = 0; i < int.MaxValue; i++)
{
var subInput = $"{input}{i}";
var md5 = CryptoHelper.GetMd5Hash(subInput);
if (!md5.StartsWith("00000"))
{
continue;
}
var position = md5[5] - '0';
if (position > 7)
{
continue;
}
var c = md5[6];
if (!mem.Get(position))
{
sb[position] = c;
mem.Set(position, true);
if (mem.Cast <bool>().All(s => s))
{
break;
}
}
}
Console.WriteLine($"The second door password is {sb}");
}
public byte[] GetBytesFromImage(Bitmap img)
{
var bmp = new Bitmap(img, 200, 200);
var bits = new BitArray(200 * 200);
for (int y = 0; y < bmp.Height; y++)
{
for (int x = 0; x < bmp.Width; x++)
{
if (bmp.GetPixel(x, y).R > 127)
{
bits.Set(y * 200 + x, true);
}
else
{
bits.Set(y * 200 + x, false);
}
}
}
byte[] data = new byte[5000];
new BitArray(bits.Cast <bool>().Reverse().ToArray()).CopyTo(data, 0);
var reverse = new List <byte>();
reverse.AddRange(data);
reverse.Reverse();
return(reverse.ToArray());
}
public static void VerifyReadNamedBitList_KeyUsage_OneByte(AsnEncodingRules ruleSet)
{
// KeyUsage ::= BIT STRING {
// digitalSignature (0),
// nonRepudiation (1),
// keyEncipherment (2),
// dataEncipherment (3),
// keyAgreement (4),
// keyCertSign (5),
// cRLSign (6),
// encipherOnly (7),
// decipherOnly (8) }
X509KeyUsageExtension kuExt = new X509KeyUsageExtension(
X509KeyUsageFlags.KeyCertSign | X509KeyUsageFlags.CrlSign,
critical: false);
BitArray expected = new BitArray(7);
expected.Set(6, true);
expected.Set(5, true);
AsnReader reader = new AsnReader(kuExt.RawData, ruleSet);
BitArray actual = reader.ReadNamedBitList();
Assert.Equal(expected.Cast <bool>(), actual.Cast <bool>());
}
public static IEnumerable <object[]> GenerateTheoryParameters(int maxParNum)
{
var res = new List <object[]>();
for (int i = 0; i < System.Math.Pow(2, 7); i++)
{
BitArray b = new BitArray(new int[] { i });
var bits = b.Cast <bool>().Take(7).ToList();
//if (!bits[3] || bits[4] || !bits[5]) continue; // Disable cases generation
var strings = new[] {
bits[0] ? "VOID " : "RESULT", // 0
bits[1] ? "SYNC " : "ASYNC ", // 1
bits[2] ? "CREATE" : "START ", // 2
bits[3] ? "SEQUEN" : "PARALL", // 3
bits[4] ? "LAST " : "ALL ", // 4
bits[5] ? "CANCEL" : "NO_CAN", // 5
bits[6] ? "NAMED " : "NO_NAM", // 6
};
for (int j = 0; j < maxParNum + 1; j++)
{
res.Add(strings.Cast <object>().ToList().Transform(ss => { ss.Add(j); }).ToArray());
//res.Add(strings.Cast<object>().ToList().Transform(ss => { ss.Add("oka"); ss.Add(j); }).ToArray());
}
}
return(res);
}
List <BitArray> Crossover(BitArray individual1, BitArray individual2, double Pc)
{
List <BitArray> newIndividuals = new List <BitArray>();
double crossoverProb = rand.NextDouble();
if (crossoverProb <= Pc)
{
int crossIndex = rand.Next(0, individual1.Length - 1);
newIndividuals.Add(new BitArray(individual1.Cast <bool>().Take(crossIndex).Concat(individual2.Cast <bool>().Skip(crossIndex).Take(individual1.Length)).ToArray()));
newIndividuals.Add(new BitArray(individual2.Cast <bool>().Take(crossIndex).Concat(individual1.Cast <bool>().Skip(crossIndex).Take(individual1.Length)).ToArray()));
//Console.WriteLine("Crossover {0}", crossIndex);
//Console.WriteLine("before");
//DisplayBitArray(individual1);
//DisplayBitArray(individual2);
//Console.WriteLine("after");
//DisplayBitArray(newIndividuals[0]);
//DisplayBitArray(newIndividuals[1]);
}
else
{
newIndividuals.Add(individual1);
newIndividuals.Add(individual2);
}
return(newIndividuals);
}
public static void ReadNamedBitList_BitArray_7993Bits(AsnEncodingRules ruleSet)
{
string inputHex;
if (ruleSet == AsnEncodingRules.CER)
{
inputHex = "A580038203E8" + new string('0', 2000) + "03020780" + "0000";
}
else
{
inputHex = "858203E907" + new string('0', 1998) + "80";
}
byte[] inputData = inputHex.HexToByteArray();
AsnReader reader = new AsnReader(inputData, ruleSet);
BitArray actual = reader.ReadNamedBitList(new Asn1Tag(TagClass.ContextSpecific, 5));
Assert.False(reader.HasData);
BitArray expected = new BitArray(7993);
expected.Set(7992, true);
Assert.Equal(expected.Cast <bool>(), actual.Cast <bool>());
}
public static void Main(string[] args)
{
bool exit = false;
while (!exit)
{
Console.WriteLine("Inserisci l'intero da convertire");
int intToCheck = int.Parse(Console.ReadLine());
var byteArray = BitConverter.GetBytes(intToCheck);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(byteArray);
Console.WriteLine("Test");
}
BitArray b = new BitArray(byteArray);
int[] bits = b.Cast <bool>().Select(bit => bit ? 1 : 0).ToArray();
Console.WriteLine("Intero convertito in: \n");
for (int i = 0; i < bits.Length; i++)
{
Console.WriteLine(bits[i] + "\n");
}
string exitChar = Console.ReadLine();
exit = exitChar == "y";
}
}
private static BitArray Concat(BitArray left, BitArray right)
{
var result = left.Cast <bool>().ToList();
result.AddRange(right.Cast <bool>());
return(new BitArray(result.ToArray()));
}
private static int Score(BitArray data)
{
return(data
.Cast <bool>()
.Select((b, i) => new { V = b ? 1 : 0, I = i })
.Select(a => a.V * (1 << a.I))
.Sum());
}
public decimal GetUtilizationratio()
{
decimal result = 0;
int setBits = bloomArray.Cast <bool>().Count(item => item);
result = setBits * 100 / BloomArraySize;
return(result);
}
public static IEnumerable <bool> AsEnumerable(this BitArray array)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
return(array.Cast <bool>());
}
public static IEnumerable <byte> GetBits(this BitArray source)
{
var result =
from bit in source.Cast <bool>()
select Convert.ToByte(bit);
return(result);
}
private static IEnumerable <char> FromBitArray(BitArray array)
{
var arrBools = array.Cast <bool>();
var arrBytes = arrBools.Batch(2)
.Select(z => Map(z.First(), z.Last()));
return(arrBytes);
}
private static string DumpBitArrayRepresentation(BitArray bitArray)
{
if (bitArray == null)
{
return(null);
}
return(DumpArrayRepresentation(bitArray.Cast <bool>().ToArray()));
}
private byte[] CombineDataoffsetReservedControlbits()
{
BitArray combined = new BitArray(baDataOffset.Cast <bool>().Concat(baReserved.Cast <bool>()).Concat(baControlBits.Cast <bool>()).ToArray());
byte[] binary = new byte[(int)Math.Ceiling((double)combined.Length / 8)];
combined.CopyTo(binary, 0);
return(binary);
}
public void Write(byte value)
{
var bits = new BitArray(new byte[] { value });
foreach (var b in bits.Cast <bool>())
{
Write(b);
}
}
public BitVisualizer(int intBitValue)
{
var intermediateRepresentation = new BitArray(new[] { intBitValue });
_bitValues = intermediateRepresentation
.Cast <bool>()
.Select(b => (b ? 1 : 0))
.ToArray();
}
public static BitArray Join(BitArray plainTextBitArray, BitArray[] plainText64BitFragments)
{
plainTextBitArray = plainText64BitFragments[0];
for (int i = 1; i < plainText64BitFragments.Length; i++)
{
plainTextBitArray = new BitArray((plainTextBitArray.Cast <bool>().ToArray().Concat(plainText64BitFragments[i].Cast <bool>().ToArray())).ToArray());
}
return(plainTextBitArray);
}
//Función que transforma la salida a un byte.
private byte FormatoSalida(bool[] parametro)
{
BitArray bits = new BitArray(parametro);
var reversed = new BitArray(bits.Cast <bool>().Reverse().ToArray());
byte[] bytes = new byte[1];
reversed.CopyTo(bytes, 0);
return(bytes[0]);
}
public string ToDigitString()
{
var builder = new StringBuilder();
foreach (var bit in imageInBits.Cast <bool>())
{
builder.Append(bit ? "1" : "0");
}
return(builder.ToString());
}
