# Zliczanie takich samych elementów tablicy dwuwymiarowej

0

Znalazłem na forum coś takiego

``````string u = "";
var dict = new Dictionary<string, int>();

foreach (var i in powtFirmy)
if (dict.ContainsKey(i))
dict[i]++;
else
dict[i] = 1;

foreach (var p in dict)
if (p.Value == 1)
u = p.Key;

dict.Remove(u);

foreach (var d in dict)
Console.WriteLine("{0} wystepuje {1} razy", d.Key, d.Value);
``````

W jaki sposób to przerobić aby działało dla tablicy dwuwymiarowej 4x10?

0

#edit przecież twój kod działa dla 2d...

``````string[,] twoDimensionArray = new string[4, 10]
{
{ "abc","qwerty","year","abc","lol","year","abc","qwerty","year","7" },
{ "abc", "test","year","abc","lol","year","abc","qwerty","4", "test" },
{ "abc","qwerty","4","abc","lol","4","abc","qwerty","4","7" },
{ "abc","qwerty","4","abc","qwerty","4","abc","test","4","7" }
};

var dict = new Dictionary<string, int>();

foreach (var i in twoDimensionArray)
if (dict.ContainsKey(i))
dict[i]++;
else
dict[i] = 1;

foreach (var d in dict)
Console.WriteLine("{0} wystepuje {1} razy", d.Key, d.Value);
``````
``````abc wystepuje 12 razy
qwerty wystepuje 7 razy
year wystepuje 5 razy
lol wystepuje 3 razy
7 wystepuje 3 razy
test wystepuje 3 razy
4 wystepuje 7 razy
``````
0

a co jeśli mam tablice zadeklarowana w ten sposób, aby nie korzystał z string[,] tylko string[][]

``````            string[][] dane = new string[10][];

for (int i = 0; i < 10; i++)
{
dane[i] = new string[4];
}
``````

bo wtedy jak robie

``````var dict = new Dictionary<string, int>();

foreach (var i in dane)
if (dict.ContainsKey(i))
dict[i]++;
else
dict[i] = 1;

foreach (var d in dict)
Console.WriteLine("{0} wystepuje {1} razy", d.Key, d.Value);
``````

to wywala błąd:

``````Error	4	Argument 1: cannot convert from 'string[]' to 'string'
``````
0
``````public static Dictionary<string, int> StringOccurancesCounter(string[][] array_of_arrays)
{
var dict = new Dictionary<string, int>();

foreach (var array in array_of_arrays)
{
foreach (var element in array)
{
if (dict.ContainsKey(element))
{
dict[element]++;
}
else
{
dict[element] = 1;
}
}
}
return dict;
}

string[][] arr = new string[3][]
{
new string[5] { "word1", "word2", "word2", "word3", "word4"},
new string[3] { "word4", "word1", "word4"},
new string[5] { "word2", "word2", "word1", "word5", "word1" },
};

foreach (var d in StringOccurancesCounter(arr))
{
Console.WriteLine("{0} wystepuje {1} razy", d.Key, d.Value);
}
``````

Tobie o coś takiego chodziło?

``````var dict = new Dictionary<string, int>();

foreach (var element in array)
{
dict[element]++;
}
``````

Nie można tak zrobić (szczerze, to się zdziwiłem :D)

0

Dzięki wielkie...świetnie działa :P
Pewnie jeszcze nie jeden temat na dniach założe, bo mam dość rozbudowany program do napisania :P

@down
Ja osobiście wole to co wyżej, jest dla mnie bardziej zrozumiałe, a to co niżej już bardziej rozbudowane i jak dla mnie bardziej "zaawansowane" xD

1

Jeśli już korzystać z imperatywnego podejścia, to można to zwięźlej zapisać:

``````public static Dictionary<string, int> BetterStringOccurancesCounter(string[][] data)
{
var dict = new Dictionary<string, int>();
foreach (var array in data)
foreach (var element in array)
dict[element] = dict.ContainsKey(element) ? dict[element] + 1 : 1;

return dict;
}
``````

Ale zwięźlej byłoby:

``````var dict = data.SelectMany(s => s).GroupBy(x => x).ToDictionary(k => k.Key, v => v.Count());
``````

@WeiXiao, skąd to zdziwienie - jeśli danego klucza nie dodano do słownika, to go nie ma, a nie ma dowolną wartość.