c массив вопрос

Question

У меня есть такой массив:

int sayilar[10] = {5,6,2,1,4,2,5,5,5,2};

Теперь я хочу получить такой результат, как: 2 найденных дубликата, 5 = 4 раза, 2 = 3 раза.

Не могу понять, как это сделать. Вот мой код, он не работает правильно:

#include <stdio.h>

int main()
{
    int sayilar[10]={5,6,2,1,4,2,5,5,5,2};
    int i,j;
    int matris[5][2];

    int ar[5];

    int temp=0;
    int tempX;
    int k=0;

    for(i=0; i<10; i++)
    {
        for(j=i+1; j<10; j++)
        {
            if(sayilar[j]==sayilar[i])
            {
                if(temp==0)
                {
                    matris[k][0] = sayilar[j];
                    matris[k][1] = 1;
                    temp=1;
                } else
                {
                    matris[k][1]++;
                }
            }
        }
        if(temp!=0)
        k++;
        temp=0;
    }

    printf("%d %d",matris[0][0],matris[0][1]+1);
}

Answer 1

Знаете ли вы что-нибудь о числах в массиве?

Если вы знаете, например, что все они будут между 1 и 10, то вы можете просто создать массив размером 10, который будет содержатьколичество для каждого числа.

Примерно так (не проверено)

int sayilar[] = {5,6,2,1,4,2,5,5,5,2};
int counts[10] = {};

for( int i=0; i<10; ++i)
{
    ++counts[sayilar[i]-1];
}

// Now the 'counts' array has:
// counts[0] == 1     - indicating one '1' found
// counts[1] == 3     - indicating three '2' found
// counts[2] == 0     - indicating zero '3' found
// etc.

Если у вас нет никаких гарантий относительно того, какие значения могут быть в sayilar, тогда сортировка сначалавероятно, лучший вариант, как уже упоминали другие.Проверьте qsort , который отсортирует ваш массив на месте.

Answer 2

Я думаю, вы должны проверить, что sayilar[i] не находится в matris перед выполнением вложенного цикла.

for(i=0; i<10; i++)
{
    int found = 0;
    for (int l=0; l<k; l++)
    {
       if (matris[l][0] == sayilar[i]) { found = 1; break; }
    }

    if (!found) 
    {
        for(j=i+1; j<10; j++)
        {
            //...

Если вам нужно более продвинутое решение, вы можете отсортировать массив, который имеет сложность O (nlogn), а не просто перебирать отсортированный массив ... Просто для вдохновения.

Answer 3

В идеале вы хотели бы сделать это за один проход, а не использовать вложенные циклы. Лучший способ - использовать некую структуру отображения, где ключ карты - это значение, которое вы рассчитываете, а значение карты - это число вхождений для этого значения.

В этом конкретном примере проще всего было бы создать одномерный массив, индекс которого соответствует рассчитываемому вами значению. Пример:

int sayilar[10]={5,6,2,1,4,2,5,5,5,2};  
size_t counts[10] = {0};
size_t dups = 0;
...
for (i = 0; i < 10; i++)
{
  /**
   * Add one to the value of counts[k], where k == sayilar[i]
   */
  counts[sayilar[i]]++;

  /**
   * If the count is equal to 2, add one to the value
   * of dups.  We use == 2 instead of > 1 so that we
   * only count unique duplicates.  
   */
  if (counts[sayilar[i]] == 2)
  {
    dups++;
  }
}

Так как этот цикл выполняется, counts обновляется следующим образом:

counts[5] = 1;
counts[6] = 1;
counts[2] = 1;
counts[1] = 1;
counts[4] = 1;
counts[2] = 2; dups = 1;
counts[5] = 2; dups = 2;
counts[5] = 3;
counts[5] = 4;
counts[2] = 3;

К сожалению, этот подход не очень хорошо масштабируется, если вы отслеживаете очень широкий диапазон значений или значений, которые не являются целыми числами.

Языки, такие как C ++ и Java, предоставляют встроенный тип данных карты, который обычно строится поверх некоторой сбалансированной древовидной структуры, такой как красно-черное дерево, которое на превышает излишнего для этой конкретной проблемы. ,

Answer 4

Если бы я писал это, я бы сделал это в два этапа.

Во-первых, я зациклился бы над массивом и посчитал бы экземпляры каждого:

int counts[5] = { 0,0,0,0,0 };

for ( int i=0 ; i < 10 ; ++i ) {
   counts[ sayilar[i] - 1 ] += 1;
}

Далее, я зациклился бы на поиске дубликатов:

for( int i=0 ; i < 5 ; ++i ) {
   if ( counts[i] > 1 ) {
      printf("Duplicate found: %d with %d instances\n", i+1, counts[i] );
   }
}

Такой подход делает его более читабельным.