如何根據循環自動創建變量？

Question

我創建了一個程序來檢查一個項目在數組中重復多少次。

但是，對於每個重復至少兩次的項目，我想將其分配給一個變量。 我的問題是，我的列表有時可能更大或更小。 因此，我需要遍歷循環，如果找到了副本，則需要創建一個int類型的變量並為其指定重復次數。 我似乎記得在Java上讀過一些有關此的內容，但是我忘記了它的名稱，否則我很困惑。 請幫忙。 謝謝。

更新：我希望輸出是這樣的：

（A：20）-（B：114）-（C：50）-（W：0）

目前，我正在嘗試檢查

    string[] art = new string[] {"ABAR 200", "CDXE 500", "BKWR 250", "BTSQ 890", "DRTY 600"};
    string[] cd = new string[] {"A", "B"};

    int control = 0;

    //I will fill this in the first loop below with 
    //the first letter of each item in the art array
    ArrayList firstLetter = new ArrayList ();

    //this one gets filled after the second loop ends
    ArrayList numOfLetters = new ArrayList ();

    for(int k = 0; k < art.Length; k++){ //iterate 4 times, add 1st letter
        firstLetter.Add (art[k].Substring(0, 1));
    }

    for (int j = 0; j < art.Length; j++) { //iterate 4 times 
        //check how many times a letter repeats in 'art'
        while (firstLetter.Contains (art [j].Substring (0, 1))) {
            control++; //
    }
        numOfLetters.Add ("(" + art [j].Substring (0, 1) + " " + ":" + " " + 
                control + ")");
            control = 0;
        }
    print (numOfLetters[0]);

如果所有這些都沒有道理，那么我很樂意知道如何檢查一個數組列表中字母重復的次數。

I，E;

ArrayList ABCADAEF

我想知道如何檢查“ A”重復多少次

Answer 1

我不太確定該代碼塊在做什么，所以我只講最后一個例子。 首先，避免使用ArrayList 。 您可以在其中存儲任何object ，但不能輕易分辨出存儲在其中的對象類型 。 取回值時，必須將它們拆箱。 使用起來很痛苦。

而是使用List<T> ，其中T是示例中的string 。

List<string> letters = new List<string> {"A", "B", "C", "A", "D", "A", "E", "F"};

使用LINQ（用您的字母表示）將值按原始數組分組，然后存儲至少出現兩次的任何值的計數。 （我修改了您的樣本集合，使其具有更多重復項。）

還有另一個內置的方法，稱為string.Join ，該方法獲取一個集合，將其展平為單個字符串，然后用其他字符串（此處為" - " ）將集合的所有元素分開。

var letters = new List<string> {"B", "A", "C", "A", "A", "B", "A", "B"};

var repeats = letters.GroupBy(i => i)
                     .Where(g => g.Count() >= 2)
                     .ToDictionary(t => t.Key, t => t.Count());

var output = string.Join(" - ", repeats.OrderBy(x => x.Key)
                                       .Select(x => string.Format("({0} : {1})", x.Key, x.Value)));

// output: "(A : 4) - (B : 3)"

Answer 2

聽起來您可能正在尋找Dictionary<T, int> 。 您沒有提到數組中包含什么類型的項目，因此您想將T換成該類型的任何東西。

一個快速而骯臟的實現可能看起來像這樣：

Dictionary<object, int> dict = new Dictionary<object, int>();
object[] objs = new object[] { ... };

for (int v = 0; v < objs.Length; v++)
{
    object obj = objs[v];

    int count = dict.TryGet(obj, out count) ? count : 0;
    dict[obj] = count + 1;
}

這聽起來像CS作業，所以我假設這可能是您正在尋找的東西，但是如果這是用於生產，那么我很想用LINQ來做。

Dictionary<object, int> dict = objs.GroupBy(c => c)
                                   .ToDictionary(c => c.Key, c => c.Count());

獲取字典后，只需檢查值是否超過一個的項目即可。 您可以通過使用foreach或再次使用LINQ進行遍歷來實現。

這是另一種超級快速的實現，您可能想要以不同的方式進行。 但這將抓住要點。

foreach (var v in dict.ToList())
{
    if (v.Value < 2)
        dict.Remove(v.Key);
}

---

另一種可行的方法是利用HashSet<> ，它一次只允許任何給定對象的一個​​實例。

object[] objs = new object[] { ... };
HashSet<object> buffer = new HashSet<object>();
HashSet<object> repeated = new HashSet<object>();

foreach (var v in objs)
{
    if(!buffer.Add(v))
    {
        repeated.Add(v);
    }
}

在這里，我遍歷每一項並將其添加到緩沖區HashSet<> 。 如果返回false，則表示它已被添加，因此是重復項。 到那時，我將其附加到第二個HashSet<> ，這將是您的結果。 我選擇了List<>作為結果，因為我假設您不希望重復的報告，如果某項在數組中顯示兩次以上。 但是除此之外，任何一種都可以。

Answer 3

您的物品類別：

class YourItem
{
    public int ItemId { get; set; }
    public string ItemName { get; set; }
}

現在，我們填寫一些項目清單並進行處理：

// defining example item list
var items = new List<YourItem>() { 
    new YourItem() { ItemId = 1, ItemName = "FirstItem" }, 
    new YourItem() { ItemId = 1, ItemName = "FirstItem" }, 
    new YourItem() { ItemId = 2, ItemName = "SecondItem" } };

var groups = items.GroupBy(item => item.ItemId) // grouping your items by id (or how do you compare them?) to be able to count repetitions
    .Where(group => group.Count() > 1) // filtering out those that are not repeated
    .Select(group => new { Item = group.First(), Sum = group.Count() }); // selecting Item and Count for each group.

// processing the results
foreach (var group in groups)
{
    Console.WriteLine(group.Item.ItemName + " " + group.Sum);
}

輸出：

FirstItem 2