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()); }