如何在 C# 中比较两个字典
Posted
技术标签:
【中文标题】如何在 C# 中比较两个字典【英文标题】：How to compare two Dictionaries in C# 【发布时间】：2012-03-21 18:51:38 【问题描述】：我有两个通用字典。两者都有相同的键，但它们的值可以不同。我想将第二本词典与第一本词典进行比较。如果它们的值之间存在差异，我想将这些值存储在单独的字典中。
1st Dictionary
------------
key Value
Barcode 1234566666
Price 20.00
2nd Dictionary
--------------
key Value
Barcode 1234566666
Price 40.00
3rd Dictionary
--------------
key Value
Price 40
谁能给我最好的算法来做到这一点？我写了一个算法，但它有很多循环。我正在寻求一个简短而有效的想法，例如使用 LINQ 查询表达式或 LINQ lambda 表达式的解决方案。我正在使用带有 C# 的 .NET Framework 3.5。我发现了一些关于 Except() 方法的信息，但不幸的是我无法理解该方法发生了什么。如果有人能解释建议的算法，那就太好了。
【问题讨论】：
如果一个键出现在第一个字典中而第二个字典中没有，或者反之亦然，你想做什么？ 不...实际上键的名称和数量必须相同。我在使用算法之前通过 iscontains() 方法进行检查。提前致谢。 【参考方案1】：如果您已经检查过密钥是否相同，则可以使用：
var dict3 = dict2.Where(entry => dict1[entry.Key] != entry.Value)
.ToDictionary(entry => entry.Key, entry => entry.Value);
为了解释，这将：
遍历dict2 中的键/值对
对于每个条目，在 dict1 中查找值并过滤掉两个值相同的任何条目
从剩余的条目（即 dict1 值不同的条目）组成字典，方法是从每对中获取键和值，就像它们出现在 dict2 中一样。
请注意，这避免了依赖 KeyValuePair<TKey, TValue> 的相等性 - 可能可以依赖它，但我个人觉得这更清楚。 （当您为字典键使用自定义相等比较器时，它也可以工作 - 尽管您也需要将其传递给 ToDictionary。）
【讨论】：
【参考方案2】：尝试：
dictionary1.OrderBy(kvp => kvp.Key)
.SequenceEqual(dictionary2.OrderBy(kvp => kvp.Key))
【讨论】：
这是与价值观比较吗？这是返回一个集合还是布尔值。 我尝试了几种不同的选项，其中 Dictionary 键是一个字符串，这个选项似乎是迄今为止最快的。【参考方案3】：检查任何差异，
dic1.Count == dic2.Count && !dic1.Except(dic2).Any();
以下代码返回所有不同的值
dic1.Except(dic2)
【讨论】：
你能解释一下吗？:) @Thabo：如果字典大小相同并且第一个中没有元素，第二个中没有元素，则它们是等效的。第二行直接返回所有在第一行而不在第二行的元素 “.Except()”从何而来？我用 OrderedDictionary 尝试了这个并得到：错误 CS1061 'OrderedDictionary' 不包含 'Except' 的定义，并且找不到接受“OrderedDictionary”类型的第一个参数的可访问扩展方法“Except”（您是否缺少 using 指令还是程序集参考？） @RichardB Linq。在文件顶部添加using System.Linq;，然后重试。【参考方案4】：
你提到两个字典有相同的键，所以如果这个假设是正确的，你不需要任何花哨的东西：
foreach (var key in d1.Keys)
if (!d1[key].Equals(d2[key]))
d3.Add(key, d2[key]);
还是我误解了你的问题？
【讨论】：
你应该这样做!d1[key].Equals(d2[key])
哎呀...这很简单..我不这么认为，但有人怀疑它的性能很好。因为我总是喜欢避免 Order n 操作。
您缺少!，因为您想要不同的值，而不是相等的值。
@Thabo 是的，这接近 O(n) 操作。由于它必须至少比较所有值一次，因此 O(n) 几乎可以达到最低限度。【参考方案5】：
假设两个字典有相同的键，最简单的方法是
var result = a.Except(b).ToDictionary(x => x.Key, x => x.Value);
编辑
注意a.Except(b) 给出的结果与b.Except(a) 不同：
a.Except(b): Price 20
b.Except(a): Price 40
【讨论】：
如果两个字典中的键顺序不同怎么办？这样可行吗？ @Thabo 是的。但请注意，a.Except(b) 给出的结果与b.Except(a) 不同。【参考方案6】：
var diff1 = d1.Except(d2);
var diff2 = d2.Except(d1);
return diff1.Concat(diff2);
编辑：如果您确定所有键都相同，您可以这样做：
var diff = d2.Where(x=>x.Value != d1[x.Key]).ToDictionary(x=>x.Key, x=>x.Value);
【讨论】：
虽然这不会产生字典，但会产生IEnumerable<KeyValuePair<K,V>>
首先我们不能有字典，但对于第二个我会更新我的答案。【参考方案7】：
您应该能够在它们的键上加入它们并选择两个值。然后您可以根据值是否相同或不同进行过滤。最后，您可以将集合转换为包含键和第二个值的字典。
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 );
使用循环也不应该太糟糕。我怀疑它们具有相似的性能特征。
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 );
【讨论】：
【参考方案8】：在最近的 C# 版本中你可以尝试
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);
我不确定SelectMany是否总是最快的解决方案，但它是一种只选择相关项目并在同一步骤中生成结果条目的方法。遗憾的是，C# 不支持 lambdas 中的 yield return，虽然我可以构建单个或不构建项目集合，但我选择使用内部函数。
哦，正如你所说，钥匙是一样的，也许可以订购它们。然后你可以使用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);
我个人倾向于不使用 Linq，而是使用简单的 foreach，例如 carlosfigueira 和 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;
【讨论】：
来自问题：如果值之间存在差异，我想将这些值存储在单独的字典中 @TheodorZoulias 我一定是累了；我重写了我的答案。我来这里谷歌搜索，似乎根本没有读过这个问题。对不起！【参考方案9】：将对象转换为字典，然后按照集合概念减去它们，结果项应该为空，以防它们相同。
public static IDictionary<string, object> ToDictionary(this object source)
var fields = source.GetType().GetFields(
BindingFlags.GetField |
BindingFlags.Public |
BindingFlags.Instance).ToDictionary
(
propInfo => propInfo.Name,
propInfo => propInfo.GetValue(source) ?? string.Empty
);
var properties = source.GetType().GetProperties(
BindingFlags.GetField |
BindingFlags.GetProperty |
BindingFlags.Public |
BindingFlags.Instance).ToDictionary
(
propInfo => propInfo.Name,
propInfo => propInfo.GetValue(source, null) ?? string.Empty
);
return fields.Concat(properties).ToDictionary(key => key.Key, value => value.Value); ;
public static bool EqualsByValue(this object source, object destination)
var firstDic = source.ToFlattenDictionary();
var secondDic = destination.ToFlattenDictionary();
if (firstDic.Count != secondDic.Count)
return false;
if (firstDic.Keys.Except(secondDic.Keys).Any())
return false;
if (secondDic.Keys.Except(firstDic.Keys).Any())
return false;
return firstDic.All(pair =>
pair.Value.ToString().Equals(secondDic[pair.Key].ToString())
);
public static bool IsAnonymousType(this object instance)
if (instance == null)
return false;
return instance.GetType().Namespace == null;
public static IDictionary<string, object> ToFlattenDictionary(this object source, string parentPropertyKey = null, IDictionary<string, object> parentPropertyValue = null)
var propsDic = parentPropertyValue ?? new Dictionary<string, object>();
foreach (var item in source.ToDictionary())
var key = string.IsNullOrEmpty(parentPropertyKey) ? item.Key : $"parentPropertyKey.item.Key";
if (item.Value.IsAnonymousType())
return item.Value.ToFlattenDictionary(key, propsDic);
else
propsDic.Add(key, item.Value);
return propsDic;
originalObj.EqualsByValue(messageBody); // will compare values.
source of the code
【讨论】：
【参考方案10】：如果您需要对两者进行全面比较（想想维恩图结果），假设给定键至少出现在其中一个字典中，则给定键有四个离散结果
public enum KeyCompareResult
ValueEqual,
NotInLeft,
NotInRight,
ValueNotEqual,
要获取字典中的所有键，请使用dictionary.Keys。要获取任一字典中的键集，请使用 Enumerable.Union，它将组合这些集并过滤掉重复项。
假设您想要一些更通用的方法，那么您可以将比较写为
public IEnumerable<KeyValuePair<TKey, KeyCompareResult>> GetDifferences<TKey, TValue>(
IDictionary<TKey, TValue> leftDict,
IDictionary<TKey, TValue> rightDict,
IEqualityComparer<TValue> comparer = null)
var keys = leftDict.Keys.Union(rightDict.Keys);
comparer ??= EqualityComparer<TValue>.Default;
return keys.Select(key =>
if (!leftDict.TryGetValue(key, out var left))
return KeyValuePair.Create<TKey, KeyCompareResult>(key, KeyCompareResult.NotInLeft);
else if (!rightDict.TryGetValue(key, out var right))
return KeyValuePair.Create<TKey, KeyCompareResult>(key, KeyCompareResult.NotInRight);
else if (!comparer.Equals(left, right))
return KeyValuePair.Create<TKey, KeyCompareResult>(key, KeyCompareResult.ValueNotEqual);
else
return KeyValuePair.Create<TKey, KeyCompareResult>(key, KeyCompareResult.ValueEqual);
);
除非您查看方法调用，否则左右区别并不明显，因此，您可能希望将方法结果选择为消息或其他更有意义的数据结构
var left = new Dictionary<int, string> 1, "one" , 2, "two" , 4, "four" ;
var right = new Dictionary<int, string> 1, "one" , 2, "A different value" , 3, "three" ;
GetDifferences(left, right, StringComparer.InvariantCulture)
.Display(); // or however you want to process the data
/*
Key Value
--- -------------
1 ValueEqual
2 ValueNotEqual
4 NotInRight
3 NotInLeft
*/
【讨论】：
【参考方案11】：将字典序列化为字符串：
var jsonSerializerSettings = new JsonSerializerSettings ContractResolver = new OrderedContractResolver() ;
var sourceHash = JsonConvert.SerializeObject(dictionary1, jsonSerializerSettings).GetHashCode();
var blobHash = JsonConvert.SerializeObject(dictionary2, jsonSerializerSettings).GetHashCode();
public class OrderedContractResolver : DefaultContractResolver
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
return base.CreateProperties(type, memberSerialization).OrderBy(p => p.PropertyName).ToList();
然后比较 HashCodes（或只是 json 字符串）。此代码强制参数以一致的顺序出现，因此如果您的字典包含乱序的相同值，它们应该返回相等。
此解决方案避免了将作为子集的字典与更大的字典进行比较的极端情况，该字典将在许多其他答案中返回相等。此解决方案对于非常大的字典或进行大量比较可能效率低下 - 但它很简单。
【讨论】：
【参考方案12】： 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 CustomerBirthDate=new DateTime(1988,08,12), Name="name1",
new CustomerBirthDate=new DateTime(1978,08,04), Name="name2",
new CustomerBirthDate=new DateTime(1978,09,04), Name="name3",
new CustomerBirthDate=new DateTime(1988,08,12), Name="name1",
new CustomerBirthDate=new DateTime(1998,08,12), Name="name1",
new CustomerBirthDate=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"));
【讨论】：
这段代码有什么作用？你能解释一下吗？ 他在问题中发布了不相关的代码。【参考方案13】： 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;
【讨论】：
一些语言来描述你的问题会很有帮助 发布了与实际问题无关的代码以上是关于如何在 C# 中比较两个字典的主要内容，如果未能解决你的问题，请参考以下文章