web-dev-qa-db-fra.com

Trouver des entiers en double dans un tableau et afficher leur nombre de fois

Je travaille sur un code qui affiche les entiers dupliqués d'un tableau avec le numéro de leur occurrence. Je ne suis pas autorisé à utiliser LINQ, juste un simple code. Je pense que je suis si proche mais confus quant à la façon d'obtenir une sortie correcte: 

class Program
{
    static void Main(string[] args)
    {              
        int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
        int count = 1;
        for (int i = 0; i < array.Length; i++)
        {
            for (int j = i; j < array.Length - 1 ; j++)
            {

               if(array[j] == array[j+1])
                  count = count + 1;
            }
            Console.WriteLine("\t\n " + array[i] + "occurse" + count);
            Console.ReadKey();
        }
    }
}
20
sunflower

Puisque vous ne pouvez pas utiliser LINQ, vous pouvez le faire avec des collections et des boucles:

static void Main(string[] args)
{              
    int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
    var dict = new Dictionary<int, int>();

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

    foreach(var pair in dict)
        Console.WriteLine("Value {0} occurred {1} times.", pair.Key, pair.Value);
    Console.ReadKey();
}
48
Reed Copsey

Utiliser Grouper par:

int[] values = new []{1,2,3,4,5,4,4,3};

var groups = values.GroupBy(v => v);
foreach(var group in groups)
    Console.WriteLine("Value {0} has {1} items", group.Key, group.Count());
15
user1968030

Jetons un coup d'oeil à un exemple plus simple. Disons que nous avons le tableau {0, 0, 0, 0}.

Que fera votre code?

Il cherchera d’abord à voir combien d’articles après le premier sont égaux. Il y a trois articles après le premier qui lui sont égaux.

Ensuite, il passe à l'élément suivant et recherche tous les éléments suivants qui le valent. Il y en a deux. Jusqu'ici, nous sommes à 5 et nous n'avons même pas encore fini (nous en avons encore un à ajouter), mais il n'y a que quatre éléments dans tout le tableau.

Clairement, nous avons un problème ici. Nous devons veiller à ce que lorsque nous avons recherché dans le tableau des doublons d'un élément donné, nous ne le recherchions plus pour le même élément. Bien qu’il y ait moyen de le faire, cette approche fondamentale s’annonce plutôt laborieuse.

Bien sûr, nous pouvons adopter différentes approches. Plutôt que de parcourir chaque élément et de rechercher d’autres éléments similaires, nous pouvons parcourir le tableau une fois , et ajouter un nombre de fois où nous avons trouvé ce caractère. L'utilisation d'une Dictionary facilite ceci:

var dictionary = new Dictionary<int, int>();

foreach (int n in array)
{
    if (!dictionary.ContainsKey(n))
        dictionary[n] = 0;
    dictionary[n]++;
}

Nous pouvons maintenant parcourir le dictionnaire et voir quelles valeurs ont été trouvées plus d'une fois:

foreach(var pair in dictionary)
    if(pair.Value > 1)
        Console.WriteLine(pair.Key);

Cela rend le code clair à lire, évidemment correct, et (en prime) beaucoup plus efficace que votre code, car vous pouvez éviter de parcourir la collection plusieurs fois.

6
Servy

Voici une réponse qui évite d’utiliser des dictionnaires. Étant donné que le PO a indiqué qu'il ne les connaissait pas, cela pourrait lui donner un aperçu de ce que font les dictionnaires.

L'inconvénient de cette réponse est que vous devez imposer une limite au nombre maximal dans le tableau et que vous ne pouvez pas avoir de nombre négatif. Vous n'utiliseriez jamais réellement cette version dans du code réel.

int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
int[] count = new int[13];

foreach(int number in array) {
    // using the index of count same way you'd use a key in a dictionary
    count[number]++;
}

foreach(int c in count) {
    int numberCount = count[c];
    if(numberCount > 0) {
        Console.WriteLine(c + " occurs " + numberCount + " times");
    }
}
3
Matt Greer

Ok j'ai modifié votre code. Cela devrait faire le travail:

class Program
{
    static void Main(string[] args)
    {
        int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };

        for (int i = 0; i < array.Length; i++)
        {
            int count = 0;
            for (int j = 0; j < array.Length; j++)
            {

                if (array[i] == array[j])
                    count = count + 1;
            }
            Console.WriteLine("\t\n " + array[i] + " occurs " + count + " times");
        }
        Console.ReadKey();
    }
}
3
Khurram Hassan

Vous avez fait une petite erreur en utilisant J au lieu de i ...

class Program
{
    static void Main(string[] args)
    {              
        int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
        int count = 1;
        for (int i = 0; i < array.Length; i++)
        {
            for (int j = i; j < array.Length - 1 ; j++)
            {
               if(array[i] == array[j+1])
                  count = count + 1;
            }
            Console.WriteLine("\t\n " + array[i] + "occurse" + count);
            Console.ReadKey();
        }
    }
}
1
Mayank Parmar

/ Ceci est la réponse qui vous aide à trouver les valeurs d'entiers dupliqués à l'aide de Forloop, qui ne renverra que les valeurs répétées en dehors de ses heures d'occurrences /

    public static void Main(string[] args)
    {
        //Array list to store all the duplicate values
        int[] ary = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
        ArrayList dup = new ArrayList();

        for (int i = 0; i < ary.Length; i++)
        {
            for (int j = i + 1; j < ary.Length; j++)
            {
                if (ary[i].Equals(ary[j]))
                {
                    if (!dup.Contains(ary[i]))
                    {
                        dup.Add(ary[i]);
                    }
                }
            }
        }
        Console.WriteLine("The numbers which duplicates are");
        DisplayArray(dup);
    }
    public static void DisplayArray(ArrayList ary)
    {
        //loop through all the elements
        for (int i = 0; i < ary.Count; i++)
        {
            Console.Write(ary[i] + " ");
        }
        Console.WriteLine();
        Console.ReadKey();
    }
1
G. Naveen
int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 7, 7, 8, 9, 7, 12, 12 };
Dictionary<int, int> duplicateNumbers = new Dictionary<int, int>();
int count=1;
for (int i = 0; i < array.Length; i++)
{
    count=1;
    if(!duplicateNumbers.ContainsKey(array[i]))
    {
        for (int j = i; j < array.Length-1; j++)
        {
            if (array[i] == array[j+1])
            {
                count++;                            
            }
        }
        if (count > 1)
        {
            duplicateNumbers.Add(array[i], count);
        }
    }
}
foreach (var num in duplicateNumbers)
{
    Console.WriteLine("Duplicate numbers, NUMBER-{0}, OCCURRENCE- {1}",num.Key,num.Value);
}
1
 class Program
{
    static void Main(string[] args)
    {
        int[] arr = { 2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12 };
        List<int> nums = new List<int>();
        List<int> count = new List<int>();
        nums.Add(arr[0]);
        count.Add(1);
        for (int i = 1; i < arr.Length; i++)
        {

            if(nums.Contains(arr[i]))
            {
                count[nums.IndexOf(arr[i])] += 1;
            }
            else
            {
                nums.Add(arr[i]);
                count.Add(1);
            }
        }

        for(int x =0; x<nums.Count;x++)
        {
            Console.WriteLine("number:"+nums[x] +"Count :"+ count[x]);
        }
        Console.Read();
    }
}
0
Rock

Je conviens que l'utilisation de Dictionary est une meilleure performance de temps d'exécution que les boucles for imbriquées (O (n) vs O (n ^ 2)). Cependant, pour adresser OP, voici une solution où une HashSet est utilisée pour empêcher de répéter le comptage des nombres entiers déjà comptés, tels que le nombre entier 5 dans l’exemple de tableau.

static void Main(string[] args)
{              
    int[] A = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };

    var set = new HashSet<int>();
    for (int i = 0; i < A.Length - 1; i++) {
        int count = 0;
        for (int j = i; j < A.Length - 1; j++) {
            if (A[i] == A[j + 1] && !set.Contains(A[i]))
                count++;
        }
        set.Add(A[i]);
        if (count > 0) {
            Console.WriteLine("{0} occurs {1} times", A[i], count + 1);
            Console.ReadKey();
        }
    }
}
0
Cesar Omiste

public static void Main (string [] args)

Int [] array = {10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12};

List<int> doneNumbers = new List<int>();


for (int i = 0; i < array.Length - 1; i++)

{

    if(!doneNumbers.Contains(array[i]))

    {

        int currentNumber = array[i];

        int count = 0;

        for (int j = i; j < array.Length; j++)

        {

            if(currentNumber == array[j])

            {

                count++;

            }

        }

        Console.WriteLine("\t\n " + currentNumber +" "+ " occurs " + " "+count + " "+" times");

        doneNumbers.Add(currentNumber);

        Console.ReadKey();
      }

   }

}

}

}

0

Il suffit d’utiliser le code ci-dessous, inutile d’utiliser un dictionnaire ou ArrayList.Hope, cela aide :)

public static void Main(string[] args)
{              
    int [] array =new int[]{10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12};
    Array.Sort(array);
    for (int i = 0; i < array.Length; i++)
    {
        int count = 1,k=-1;
        for (int j = i+1; j < array.Length; j++)
        {  

                if(array[i] == array[j])
                {
                    count++;
                    k=j-1;
                }
                else break;
        }
        Console.WriteLine("\t\n " + array[i] + "---------->" + count);            
        if(k!=-1)
            i=k+1;          
    }
}
0

// Cette méthode compte le nombre total d'éléments dupliqués dans un tableau.

public void DuplicateElementsInArray(int[] numbers)
    {
        int count = 0;

        for (int i = 0; i < numbers.Length; i++)
        {

            for (int j = i; j < numbers.Length - 1; j++)
            {
                if (numbers[i] == numbers[j+1])
                {                       
                    count++;
                    break;
                }                       
            }               
        }
        Console.WriteLine("Total number of duplicate elements found in the array is: {0}", count);
    }
0
Amit
 class Program
{
    static void Main(string[] args)
    {
        int[] arr = new int[] { 10, 20,20, 30, 10, 50 ,50,9};
        List<int> listadd = new List<int>();

        for (int i=0; i <arr.Length;i++)
        {
           int count = 0;
            int flag = 0;

            for(int j=0; j < arr.Length; j++)
            {
                if (listadd.Contains(arr[i]) == false)
                {


                    if (arr[i] == arr[j])
                    {
                        count++;
                    }

                } 

                else
                {
                    flag = 1;
                }

            }
            listadd.Add(arr[i]);
            if(flag!=1)
            Console.WriteLine("No of occurance {0} \t{1}", arr[i], count);
        }
        Console.ReadLine();

    }
}
0
Sujeet Kumar

Cette approche, corrigée, donnera le bon résultat (c'est très inefficace, mais ce n'est pas un problème si vous n'agrandissez pas de façon spectaculaire.)

int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
for (int i = 0; i < array.Length; i++)
{
    int count = 0;
    for (int j = 0; j < array.Length ; j++)
    {
       if(array[i] == array[j])
          count = count + 1;
    }
    Console.WriteLine("\t\n " + array[i] + " occurs " + count);
    Console.ReadKey();
}

J'ai compté 5 erreurs dans le code OP, notées ci-dessous.

int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
int count = 1;                                   // 1. have to put "count" in the inner loop so it gets reset
                                                 // 2. have to start count at 0
for (int i = 0; i < array.Length; i++)
{
    for (int j = i; j < array.Length - 1 ; j++)  // 3. have to cover the entire loop
                                                 // for (int j=0 ; j<array.Length ; j++)
    {
       if(array[j] == array[j+1])                // 4. compare outer to inner loop values
                                                 // if (array[i] == array[j])
          count = count + 1;
    }
    Console.WriteLine("\t\n " + array[i] + "occurse" + count);
                                                 // 5. It's spelled "occurs" :)
    Console.ReadKey();
}

Modifier  

Pour une meilleure approche, utilisez une Dictionary pour garder une trace des comptes. Cela vous permet de parcourir le tableau une seule fois et d’imprimer les comptes en double sur la console.

var counts = new Dictionary<int, int>();
int[] array = { 10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12 };
for (int i = 0; i < array.Length; i++)
{
    int currentVal = array[i];
    if (counts.ContainsKey(currentVal))
        counts[currentVal]++;
    else
        counts[currentVal] = 1;
}
foreach (var kvp in counts)
    Console.WriteLine("\t\n " + kvp.Key + " occurs " + kvp.Value);
0
McGarnagle
int copt = 1;
int element = 0;
int[] array = { 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5 };
for (int i = 0; i < array.Length; i++)
{
   for (int j = i + 1; j < array.Length - 1; j++)
   {
       if (array[i] == array[j])
       {
          element = array[i];
          copt++;
          break;
       }
   }
}

Console.WriteLine("the repeat element is {0} and it's appears {1} times ", element, copt);
Console.ReadKey();

// la sortie est l'élément est 3 et apparaît 9 fois

0
Jihed Jaoidi
public class Program
{
    public static void Main(string[] args)
    {
        int[] arr = new int[]{10, 5, 10, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12};

        int numberOfDuplicate = 0;
        int arrayLength = arr.Length;

        for(int i=0; i < arrayLength; i++)  
        {  
           for(int j = 1; j < arrayLength; j++)  
           {
               if(j < i && arr[j]==arr[i])
               {
                  break; 
               }
               else if(i != j && arr[i]==arr[j])
               {
                  Console.Write("duplicate : arr[{0}]={1}--arr[{2}]={3}\n",i,arr[i],j,arr[j]);
                  numberOfDuplicate++;
                  break;
               }
           }
        }

        Console.Write("Total duplicate element in an array 'arr' is {0}\n ",numberOfDuplicate);
    }
}
0
MRLilhare