Question

我遇到了这个功能的问题。我已经测试过这个输入

输入：2 2 3 4 4

输出：3

到目前为止一切正常。但是当我有两个或更多数字处于这种特殊情况时：

输入：1 3 3 4

输出：4

我不断获得索引最大的数字。我真正想要的是那种情况下的输出（索引最小的数字）：

输出：1

这是我的代码：

int leastFreq (int v[] , int size)
{
  int i ;
  int count = 0;
  int repetitions = 0;
  int lower;

  for ( i = 0 ; i < size ; i ++)
  {
   if (v[i] != v[i+1])
   { 
     count --;
        if ( count < repetitions)
        {
          repetitions = count;
          lower = v[i];
        }
   }
   else 
   { count = 0 ;}  
  }
   return lower;
}

如何解决此问题？ （这是一个排序数组）

Answer 1

在此代码中，minnum将包含最小数字.a [0..size-1]

#include<stdio.h>
int main()
{   
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    scanf("%d",&a[i]);
    int min=65536;
    int minnum=a[0];

    int i,ct=1;
    for(i=1;i<=n-1;i++)
    {
        if(a[i]==a[i-1])
        {
            ct++;
        }
        else
        {
            if(ct<min)
            {
                min=ct;
                ct=1;
                minnum=a[i-1];
            }
        }
    }
    if(ct<min)
    {
        min=ct;
        ct=1;
        minnum=a[i-1];
    }
  printf("%d",minnum);
}

算法是       首先设置一个变量，该变量意味着出现一个数字到最大可能数。

然后继续检查相同的数字。当不平等发生时，2/2连续数字只检查数字的出现是否小于上一个数字的出现。

如果数字以1,1,1,2,2
等一系列相同的数字结尾，那么它也会被检查，因为它是必需的。

Answer 2

您的代码无法正常运行。它访问超出aray界限的数组。无论长度如何，它都支持相同条目的早期子阵列，因为计数并不是真正的计数。只有当子阵列的长度为1时，它才能低于-1。

这里的问题是你必须找到子阵列的长度，因为你做了最低限度的检查。您可以在相邻数组条目具有不同值时进行检查，但您必须确保捕获最后一个子数组。

下面的代码使用两个嵌套循环。外部while遍历子数组，内部while确定子数组：

int leastFreq(int v[], int size)
{
    int result;
    int min = size + 1;
    int i;

    if (size < 1) return 0;

    i = 0;
    while (i < size) {
        int start = i;
        int val = v[i];
        int count;

        i++;
        while (i < size && v[i] == val) i++;

        count = i - start;
        if (count < min) {
            result = val;
            min = count;
        }
    }

    return result;
}

这将找到最短的子阵列中的第一个。如果要查找最后一个，请将条件更改为(count <= min)。

数组中最不常见的数字

2 个答案: