How to compare two Dictionaries in C#

Question

I have two Generic Dictionaries.Both have same keys.But values can be different.I want to compare 2nd dictionary with 1st dictionary .If there are differences between values

Answer 1

In recent C# versions you can try

        public static Dictionary<TK, TV> ValueDiff<TK, TV>(this Dictionary<TK, TV> dictionary,
            Dictionary<TK, TV> otherDictionary)
        {
            IEnumerable<(TK key, TV otherValue)> DiffKey(KeyValuePair<TK, TV> kv)
            {
                var otherValue = otherDictionary[kv.Key];
                if (!Equals(kv.Value, otherValue))
                {
                    yield return (kv.Key, otherValue);
                }
            }

            return dictionary.SelectMany(DiffKey)
                .ToDictionary(t => t.key, t => t.otherValue, dictionary.Comparer);
        }

I am not sure that SelectManyis always the fastest solution, but it is one way to only select the relevant items and generate the resulting entries in the same step. Sadly C# does not support yield return in lambdas and while I could have constructed single or no item collections, I choose to use an inner function.

Oh and as you say that the keys are the same, it may be possible to order them. Then you could use Zip

        public static Dictionary<TK, TV> ValueDiff<TK, TV>(this Dictionary<TK, TV> dictionary,
            Dictionary<TK, TV> otherDictionary)
        {
            return dictionary.OrderBy(kv => kv.Key)
                .Zip(otherDictionary.OrderBy(kv => kv.Key))
                .Where(p => !Equals(p.First.Value, p.Second.Value))
                .ToDictionary(p => p.Second.Key, p => p.Second.Value, dictionary.Comparer);
        }

Personally I would tend not to use Linq, but a simple foreach like carlosfigueira and vanfosson:

        public static Dictionary<TK, TV> ValueDiff2<TK, TV>(this Dictionary<TK, TV> dictionary,
            Dictionary<TK, TV> otherDictionary)
        {
            var result = new Dictionary<TK, TV>(dictionary.Count, dictionary.Comparer);
            foreach (var (key, value) in dictionary)
            {
                var otherValue = otherDictionary[key];
                if (!Equals(value, otherValue))
                {
                    result.Add(key, otherValue);
                }
            }

            return result;
        }

Answer 2

You should be able to join them on their keys and select both values. Then you can filter based on whether the values are the same or different. Finally, you can convert the collection to a dictionary with the keys and second values.

  var compared = first.Join( second, f => f.Key, s => s.Key, (f,s) => new { f.Key, FirstValue = f.Value, SecondValue = s.Value } )
                      .Where( j => j.FirstValue != j.SecondValue )
                      .ToDictionary( j => j.Key, j => j.SecondValue );

Using a loop shouldn't be too bad either. I suspect that they would have similar performance characteristics.

  var compared = new Dictionary<string,object>();
  foreach (var kv in first)
  {
      object secondValue;
      if (second.TryGetValue( kv.Key, out secondValue ))
      {
            if (!object.Equals( kv.Value, secondValue ))
            {
                compared.Add( kv.Key, secondValue );
            }
      }
  }

Answer 3

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 namespace algorithms
{
    public class Program
    {
        public static void Main(string[] args)
        {
            callAnnagrams();
            //callArrayChunkingStr();
            //callFizzBussStr();
            //callMaxChars();
            //callRevNumber();
            //string value = "Acheck";
            //Console.WriteLine("value" + value.IsStartWithA());
            //callPalindromeStringMethods();
            //callRevStringMethods();

        }
        public static void callRevStringMethods()
        {
            Console.WriteLine("Hello World!");
            string revString = RevStrings.RevString("You cannot convert an array of strings to an array of characters by just calling a method like ToCharArray");
            Console.WriteLine("reverse string " + revString);

            string revString2 = RevStrings.RevString2("You cannot convert an array of strings to an array of characters by just calling a method like ToCharArray");
            Console.WriteLine("reverse string2 " + revString2);

            string revString3 = RevStrings.RevString3("You cannot convert an array of strings to an array of characters by just calling a method like ToCharArray");
            Console.WriteLine("reverse string3 " + revString3);

            string revString4 = RevStrings.RevString4("You cannot convert an array of strings to an array of characters by just calling a method like ToCharArray");
            Console.WriteLine("reverse string4 " + revString4);

        }
        public static void callPalindromeStringMethods()
        {
            Console.WriteLine("Hello World!");
            bool blPalindrome = Palindrome.PalindromeString("abba");
            Console.WriteLine("string is Palindrome" + blPalindrome);
            bool blPalindrome1 = Palindrome.PalindromeString("dfasdf");
            Console.WriteLine("string is Palindrome" + blPalindrome1);
        }

        public static void callRevNumber()
        {

            Console.WriteLine("reversed -1123.567 value" + RevNumbers.RevNumber3(-1123.567));
            Console.WriteLine("reversed 1123.567 value" + RevNumbers.RevNumber3(1123.567));
            Console.WriteLine("reversed -1123.567" + RevNumbers.RevNumber2(-1123.567));
            Console.WriteLine("reversed 234 value" + RevNumbers.RevNumber(234));
            Console.WriteLine("reversed -234 value" + RevNumbers.RevNumber(-234));           

        }

        public static void callMaxChars()
        {
            //MaxChar.MaxCharsWithASCII("rwersfsdfsdfsdf");
            //MaxChar.MaxCharsWithASCII("testtestttettssssssssssstest");
            MaxChar.MaxCharsWithDictionary("testtestttettssssssssssstest");

        }
        public static void callFizzBussStr()
        {
            FizzBuss.FizzBussStr();
        }
        public static void callArrayChunkingStr()
        {
            int[] numArray = new int[] { 1, 3, 5, 6, 7, 8, 8,9 };
            ArrayList anum=new ArrayList { 'a','b','c','d','e' };
            ArrayChunking.ArrayChunkingStr2(anum, 3);
            Console.WriteLine();
            anum = new ArrayList { 1, 2, 3, 4, 5, 6, 7, 8,9 };
            ArrayChunking.ArrayChunkingStr2(anum, 2);
            Console.WriteLine();
            numArray = new int[] { 1, 2, 3, 4, 5 };
            ArrayChunking.ArrayChunkingStr(numArray, 10);
        }
        public static void callAnnagrams()
        {
            Annagram.Annagrams("this is a valid string ", "sa i hits daliv gnirts");
            Annagram.Annagrams("this is a valid string ", "ssdfasdfad dsfasdf453 $ ,fgdaliv gnirts");
            Annagram.Annagrams("string $ ONE ,", "snigtr # neo");

        }
    }
    public static class StringMethods
    {
        public static bool IsStartWithA(this string s)
        {
            return s.StartsWith('A');
        }
    }
    public class RevStrings
    {
        public static string RevString(string str)
        {
            var charArry = str.ToCharArray();
            Array.Reverse(charArry);
            return new string(charArry);
        }
        public static string RevString2(string str)
        {
            string revString = "";
            foreach( char c in str)
            {
                revString = c + revString;
            }

            return revString;
        }

        //no change to the order of the words
        public static string RevString3(string str)
        {
            string[] strArray = str.Split(' ');

            string revString = "";
            foreach (string s in strArray)
            {
                var charArray = s.ToCharArray();
                Array.Reverse(charArray);

                string reString = (strArray.Length > 1) ? new string(charArray) +" " : new string(charArray) + string.Empty;
                revString +=  reString;

            }

            return revString;
        }
        public static string RevString4(string str)
        {
            string[] strArray = str.Split(' ');

            string revString = "";
            foreach (string s in strArray)
            {
                string revWord = "";
                foreach(char c in s)
                {
                    revWord = c + revWord;
                }
                revString += revWord + " ";
            }

            return revString;
        }

    }

    public class Palindrome
    {
        public static bool PalindromeString(string str)
        {
            if (RevStrings.RevString3(str).ToUpper() == str.ToUpper())
                return true;
            else
                return false;
        }
    }

    public class RevNumbers
    {
        public static int RevNumber(int number)
        {
            string revStringNumber = RevStrings.RevString2(number.ToString().Replace("-", ""));

            Int32 num = Int32.Parse(revStringNumber) * Math.Sign(number);
            return num;
        }
        public static double RevNumber2(double number)
        {         
            string revStringNumber = RevStrings.RevString2(number.ToString().Replace("-", ""));
            double num = Convert.ToDouble(revStringNumber) * Math.Sign(number); 

            return num;
        }
        public static double RevNumber3(double number)
        {
            string[] strArray = number.ToString().Replace("-", "").Split('.');
            string revString = "";
            int i = 0;

            foreach (string s in strArray)
            {
                var charArray = s.ToCharArray();
                Array.Reverse(charArray);
                string reString = new string(charArray);
                if (i + 1 < strArray.Length && strArray[i].Length > 0)
                    revString += reString + ".";
                else
                    revString += reString;
                i++;
            }
            double num = Convert.ToDouble(revString.ToString().Replace("-", "")) * Math.Sign(number);

            return num;


        }


    }

    public class MaxChar
    {
        public static void MaxCharsWithASCII(string str)
        {
            int i = 0, l, max;
            int ascii;
            l = str.Length;
            int[] ch_freq = new int[255];

            for (i = 0; i < 255; i++)
            {
                ch_freq[i] = 0;
            }

            i = 0;
            while(i<l)
            {
                ascii = (int)str[i];
                ch_freq[ascii] += 1;

                i++;
            }

            max = 0;
            for(i=0; i<255; i++)
            {
                if (i != 32)
                {
                    if (ch_freq[i] > ch_freq[max])
                        max = i;
                }
            }
            Console.Write("The Highest frequency of character '{0}' is appearing for number of times : {1} \n\n", (char)max, ch_freq[max]);

        }
        public static void MaxCharsWithDictionary(string str)
        {
            int i = 0, l, max;
            l = str.Length;
            Dictionary<int, int> char_freq = new Dictionary<int, int>();

            i = 0;
            while (i < l)
            {
                if(!(char_freq.ContainsKey((int)str[i])))
                    char_freq.Add((int)str[i], 1);               
                else
                    char_freq[(int)str[i]]= char_freq[str[i]]+1;
                i++;
            }

            max = 0;
            for (i = 0; i < char_freq.Count; i++)
            {

                    if (char_freq[str[i]] > char_freq[str[max]])
                        max = i;

            }
            Console.Write("The Highest frequency of character '{0}' is appearing for number of times : {1} \n\n",(char)str[max], char_freq[str[max]]);

        }
        public static Dictionary<int,int> MaxCharsWithReturnDictionary(string str)
        {
            int i = 0, l, max;
            l = str.Length;
            Dictionary<int, int> char_freq = new Dictionary<int, int>();

            i = 0;
            while (i < l)
            {
                if (!(char_freq.ContainsKey((int)str[i])))
                    char_freq.Add((int)str[i], 1);
                else
                    char_freq[(int)str[i]] = char_freq[str[i]] + 1;
                i++;
            }

            max = 0;
            for (i = 0; i < char_freq.Count; i++)
            {

                if (char_freq[str[i]] > char_freq[str[max]])
                    max = i;

            }
            return char_freq;
        }

    }

    public class FizzBuss
    {
        public static void FizzBussStr()
        {
            double num =Convert.ToDouble(Console.ReadLine());
            for (int i = 1; i <= num; i++)
            {
                if ((i % 3 == 0) && (i % 5 == 0)) //by both
                    Console.WriteLine("FizzBuzz");
                else if (i % 3 == 0)  //by 3
                    Console.WriteLine("Fizz");
                else if( i % 5 == 0) //by 5
                    Console.WriteLine("Buzz");
                else Console.WriteLine(i);
            }

        }
    }

    public class ArrayChunking
    {
        public static ArrayList ArrayChunkingStr2(ArrayList intArray, int chunk)
        {
            ArrayList arrList = new ArrayList();

            int len = intArray.Count;
            int div = len / chunk;
            int howManyChunks = (len % chunk) > 0 ? div + 1 : div;
            int chkInc = 0;
            for (int chkk = 0; chkk < howManyChunks; chkk++)
            {
                ArrayList arr = new ArrayList();
                for (int i = 0; i < chunk; i++)
                {
                    if ((i + chkInc) < len)
                    {
                        arr.Insert(i, intArray[i + chkInc]);
                    }
                }
                chkInc += chunk;
                arrList.Add(arr);
            }

            if (howManyChunks > 0)
            {
                //Console.Write("[");
                string disarr = "[";
                for (int j = 0; j < howManyChunks; j++)
                {
                    //Console.Write("[");
                    disarr += "[";

                    ArrayList x = (ArrayList)arrList[j];
                    string dis = "";
                    for (int i = 0; i < x.Count; i++)
                    {
                        dis += x[i].ToString() + ",";
                    }
                    dis = dis.TrimEnd(',');
                    disarr += dis + "],";
                    //Console.Write(disarr);
                }
                disarr = disarr.TrimEnd(',');
                //Console.Write("]");
                disarr += "]";
                Console.Write(disarr);
            }
            return arrList;
        }
        public static ArrayList ArrayChunkingStr(int[] intArray,int chunk)
        {
            ArrayList arrList = new ArrayList();

            int len = intArray.Length;
            int div = len / chunk;
            int howManyChunks = (len % chunk) > 0 ? div + 1: div;
            int chkInc = 0;
            for(int chkk=0; chkk < howManyChunks; chkk++)
            {
                ArrayList arr = new ArrayList();
                for (int i = 0; i < chunk; i++)
                {
                    if ((i + chkInc) < len)
                    {
                        arr.Insert(i,intArray[i + chkInc]);
                    }
                }
                chkInc += chunk;
                arrList.Add(arr);
            }

            if (howManyChunks > 0)
            {
                //Console.Write("[");
                string disarr = "[";
                for (int j = 0; j < howManyChunks; j++)
                {
                    //Console.Write("[");
                    disarr += "[";

                    ArrayList x = (ArrayList)arrList[j];
                    string dis = "";
                    for (int i = 0; i < x.Count; i++)
                    {
                        dis += x[i].ToString() + ",";
                    }
                    dis = dis.TrimEnd(',');
                    disarr += dis + "],";
                    //Console.Write(disarr);
                }
                disarr = disarr.TrimEnd(',');
                //Console.Write("]");
                disarr += "]";
                Console.Write(disarr);
            }
            return arrList;
        }
    }

    public class Annagram
    {
        public static bool Annagrams(string str1, string str2)
        {

            str1 = Regex.Replace(str1.ToLower(), "[^a-zA-Z0-9]+", "", RegexOptions.Compiled);
            str2 = Regex.Replace(str2.ToLower(), "[^a-zA-Z0-9]+", "", RegexOptions.Compiled);

            Dictionary<int, int> str1Dic = MaxChar.MaxCharsWithReturnDictionary(str1.ToLower());

            Dictionary<int, int> str2Dic = MaxChar.MaxCharsWithReturnDictionary(str2.ToLower());
            if (str1Dic.Count != str2Dic.Count)
            {
                Console.WriteLine("strings are not annagrams");
                return false;
            }
            else
            {
                if (!(str1Dic.Keys.All(str2Dic.ContainsKey)))
                {
                    Console.WriteLine("strings are not annagrams");
                    return false;
                }
                else
                {
                    var dict3 = str2Dic.Where(entry => str1Dic[entry.Key] != entry.Value)
                            .ToDictionary(entry => entry.Key, entry => entry.Value);
                    if (dict3.Count > 0)
                    {
                        Console.WriteLine("strings are not annagrams");
                        return false;
                    }
                    else
                    {
                        Console.WriteLine("strings are  annagrams");
                        return true;
                    }
                }


            }

        }
    }
}

Answer 4

var diff1 = d1.Except(d2);
var diff2 = d2.Except(d1);
return diff1.Concat(diff2);

Edit: If you sure all keys are same you can do:

var diff = d2.Where(x=>x.Value != d1[x.Key]).ToDictionary(x=>x.Key, x=>x.Value);

Answer 5

You mentioned that both dictionaries have the same keys, so if this assumption is correct, you don't need anything fancy:

        foreach (var key in d1.Keys)
        {
            if (!d1[key].Equals(d2[key]))
            {
                d3.Add(key, d2[key]);
            }
        }

Or am I misunderstanding your problem?

Answer 6

 public class SentenceCapitalization
{
    public static string SentenceCapitalizations(string str)
    {
        string[] strArray = str.Split(' ');//split words
        string capString = "";
        string capStr = "";
        foreach (string s in strArray)
        {
            if (s.Length > 0 && s != string.Empty)
            {
                capStr = s[0].ToString().ToUpper();
                capString += capStr + s.Remove(0, 1) +" ";
            }
        }
        return capString.TrimEnd();
    }
}
public class Step
{
    public static void Steps(int num)
    {
        for (int row = 1; row <= num; row++)
        {
            string str = "";
            for (int col = 1; col <= num; col++)
            {
                if (row == col || row > col)
                    str += "#";
                else if (row < col)
                    str += " ";

            }
            Console.WriteLine(str);

        }

    }
    public static void RevSteps(int num)
    {
        int count = 0;
        for (int row = 1; row <= num; row++)
        {
            string str = "";
            for (int col = 1; col <= num; col++)
            {
                count = num - row;
                if(col> count)
                {
                    str += "#";
                }
                else 
                    str += " ";

            }
            Console.WriteLine(str);

        }

    }

}
public class Pyramid
{
    public static void PyramidSteps()
    {
        Console.Write("enter number for Pyramid steps: ");
        int num = (int) Math.Round(Convert.ToDecimal(Console.ReadLine()));
        int rows = num;
        int cols = num + (num - 1);
        int emptyLCols, emptyRCols;
        for (int row = 1; row <= rows; row++)
        {
            string str = "";
            emptyLCols = rows - row;
            emptyRCols = rows + row;
            for (int col = 1; col <= cols; col++)
            {
                if(col<=emptyLCols || col>=emptyRCols)
                    str += " ";                    
                else 
                    str += "#";
            }
            Console.WriteLine(str);
        }

    }

}
public class vowels
{
    public static void Vowels()
    {
        Console.Write("enter String: ");
        string vowelStr = Console.ReadLine().ToLower();
        int count = 0;


        for(int i=0; i < vowelStr.Length; i++)
        {
            char c = vowelStr[i];
            if ("aeiou".Contains(c))
            {
                count++;
            }
        }
        Console.WriteLine("total vowels...."+count);
    }

}

public class SpiralMatrix
{
    public static void SpiralMatrixs()
    {
        Console.Write("enter number for SpiralMatrixs: ");
        int num = (int)Math.Round(Convert.ToDecimal(Console.ReadLine()));
        int[,] arr = new int[num,num];

        int startColumn=0, startRow=0, endColumn=num-1, endRow=num-1;
        int counter = 1;
       for(int k=0; (startColumn < endColumn && startRow <= endRow) && k<num; k++)
        {
            for(int i= startColumn; i <= endColumn; i++)
            {
                arr[startRow, i] = counter;
                counter++;
            }
            startRow++;
            for (int i = startRow; i <= endRow; i++)
            {
                arr[i, endColumn] = counter;
                counter++;
            }
            endRow--;
            startColumn++;
            k++;
        }



    }
}

public class Sorting
{
    public static int RecFactorials(int num)
    {
        if (num == 0)
            return 1;
        else
            return num * RecFactorials(num - 1);
    }
    public static int[] BubbleSort(int[] array)
    {
        for(int partIndex=array.Length-1; partIndex > 0; partIndex--)
        {
            for(int i=0; i < partIndex; i++)
            {
                if(array[i]> array[i + 1])
                {
                    Swap(array, i, i + 1);
                }
            }                
        }
        return array;
    }
    public static int[] SelectionSort(int[] array)
    {
        for (int partIndex = array.Length - 1; partIndex > 0; partIndex--)
        {
            int largeIndexAt = 0;
            for(int i = 1; i <= partIndex; i++)
            {
                if (array[i] > array[largeIndexAt])
                {
                    largeIndexAt = i;
                }

            }
            Swap(array, largeIndexAt, partIndex);
        }
        return array;
    }
    public static int[] InsertionSort(int[] array)
    {
        for (int partIndex = 0; partIndex < array.Length ; partIndex++)
        {
            int currUnsort = array[partIndex];
            int i = 0;
            for ( i = partIndex; i >0 && array[i-1] > currUnsort; i--)
            {
                array[i] = array[i - 1];

            }
            array[i] = currUnsort;
        }
        return array;
    }
    public static void Swap(int[] arr, int i, int j)
    {
        int arrPre = arr[j];
        arr[j] = arr[i];
        arr[i] = arrPre; 
    }
}
public class Lists
{
    public static void SortList()
    {
        List<int> lsArray = new List<int>();
        for(int i=0; i < 16; i++)
        {
            lsArray.Add(i);
            LogList(lsArray);
        }
        LogList(lsArray);

        for(int i=10; i>0; i--)
        {
            lsArray.RemoveAt(i-1);
            LogList(lsArray);
        }
        lsArray.TrimExcess();
        LogList(lsArray);
        Console.ReadLine();
    }
    public static void LogList(List<int> ls)
    {
        Console.WriteLine("count: {0}, Capacity:{1}", ls.Count, ls.Capacity);
    }
    public static void ApiMembers()
    {
        var list = new List<int>() { 1, 0, 5, 3, 4 };
        list.Sort();

        int binarySearch = list.BinarySearch(5);

        list.Reverse();

        ReadOnlyCollection<int> readonlylist = list.AsReadOnly();

        readonlylist.Reverse();
        int count=list.Count();
        var listCustomers = new List<Customer>
        {
            new Customer{BirthDate=new DateTime(1988,08,12), Name="name1"},
            new Customer{BirthDate=new DateTime(1978,08,04), Name="name2"},
            new Customer{BirthDate=new DateTime(1978,09,04), Name="name3"},
            new Customer{BirthDate=new DateTime(1988,08,12), Name="name1"},
            new Customer{BirthDate=new DateTime(1998,08,12), Name="name1"},
            new Customer{BirthDate=new DateTime(1888,08,12), Name="name1"}
        };

        listCustomers.Sort((left, right) =>
        {
            if (left.BirthDate > right.BirthDate)
                return 1;
            if (right.BirthDate > left.BirthDate)
                return -1;
            return 0;
        });

    }
}
public class Customer
{
    public DateTime BirthDate;
    public string Name;
}

public class SingleLinkedList<T>
{
    public Node<T> Head { get; private set; }
    public Node<T> Tail { get; private set; }
    public int Count { get; private set; }
    private bool IsEmpty => Count == 0;
    public void AddFirst(T value)
    {
        AddFirst(new Node<T>(value));
    }

    private void AddFirst(Node<T> linkedListNode)
    {
        //save off the current head
        Node<T> tmp = Head;
        Head = linkedListNode;
        Head.Next = tmp;
        Count++;
        if(Count==1)
        { Tail = Head; }
    }

    public void RemoveFirst()
    {
        if(IsEmpty)
        {
            throw new InvalidOperationException();
        }
        Head = Head.Next;
        if (Count == 1)
            Tail = null;
        Count--;
    }
    public void RemoveLast()
    {
        if (IsEmpty)
        {
            throw new InvalidOperationException();
        }
        if(Count==1)
        {
            Head = Tail = null;
        }
        else
        {
            //find the penultimate node
            var current = Head;
            while (current.Next != Tail)
            {
                current = current.Next;

            }
            current.Next = null;
            Tail = current;
        }
        Count--;
    }
    public void AddLast(T value)
    {
        AddLast(new Node<T>(value));

    }

    private void AddLast(Node<T> node)
    {
        if (IsEmpty)
        {
            Head = node;
            Tail = node;
        }
        else
        {
            Tail.Next = node;
            Tail = node;
        }
        Tail = node;
        Count++;
    }

}
public class Node<T>
{

    public T Value { get; set; }
    public Node<T> Next { get; set; }

    public Node(T value)
    {
        this.Value = value;
    }



}
 public static void RevSteps(int num)
    {
        int count = 0;
        for (int row = 1; row <= num; row++)
        {
            string str = "";
            for (int col = 1; col <= num; col++)
            {
                count = num - row;
                if(col> count)
                {
                    str += "#";
                }
                else 
                    str += " ";

            }
            Console.WriteLine(str);

        }

    }
    public static void plusMinus()
    {
        int n = Convert.ToInt32(Console.ReadLine());

        int[] arr = Array.ConvertAll(Console.ReadLine().Split(' '), arrTemp => Convert.ToInt32(arrTemp))
        ;
        plusMinus(arr);
    }
    static void plusMinus(int[] arr)
    {
        int count = arr.Length;
        decimal pC = 0, bC = 0, zC = 0;
        for (int i = 0; i < count; i++)
        {
            if (arr[i] > 0)
            {//positive
                pC++;
            }
            else if (arr[i] < 0)
            {
                bC++;
            }
            else if (arr[i] == 0)
            {
                zC++;
            }

        }
        Console.WriteLine((pC / count).ToString("N6"));
        Console.WriteLine((bC / count).ToString("N6"));
        Console.WriteLine((zC / count).ToString("N6"));

    }