How can I automatically create variables according to a loop?

I'm not quite sure what that block of code is doing, so I'll just address your last example. First, avoid using ArrayList. You can store any object in it, but you can't easily tell what type of object is stored in it. When you get the values back out, you have to unbox them. It's a pain to use.

Instead, use a List<T> where T is a string in your sample.

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

Group your original array by values using LINQ (letters in your case), then store the count of any values that occur at least twice. (I modified your sample collection to have more duplicates.)

There's another built in method called string.Join, which takes a collection, flattens it out to a single string, and separates all the elements of the collection by some other string (" - " here).

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)"

It sounds like you might be looking for a Dictionary<T, int>. You didn't mention what type of items are contained in the array, so you'll want to swap out the T with whatever that type is.

A quick and dirty implementation might look something like this:

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

This sounds like CS homework, so I'm assuming that's probably what you're looking for, but if this is for production, I'd be tempted to do it with LINQ.

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

Once you've got your dictionary, it's just a matter of checking for items with more than one as the value. You can do that by looping through, either with a foreach or, again, with LINQ.

This is another super quick implementation, and you might want to do it differently. But this would capture the gist of it.

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

Another feasible approach would be to make use of a HashSet<>, which only allows one instance of any given object at a time.

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

Here, I loop through each item and add it to a buffer HashSet<>. If that returns false, it means it's already been added, so it's a duplicate. At that point, I append it to yet a second HashSet<>, which would be your result. I chose this over a List<> for the result because I assume you don't want duplicate reports in that, in the event of an item showing up in the array more than two times. But either works, aside from that.

Your item class:

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

Now in we fill in some list of items and process it:

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

Output:

FirstItem 2