思考问题

Question

我必须编写一个函数，如果数组中的每个整数都是唯一的（不同的），它将返回true。所以，我已经尝试纠正我的for循环/我的if语句，并且我已经尝试运行我编写的测试。但是，对具有多次出现的整数的字符串的测试仍然失败。我已经查看了我的代码，但我仍然找不到问题。

#include "in.h"

int in(int input[], int size)
{
   for (int i = 0; i < size - 1; i++)
   {
      for (int j = i + 1; j < size; j++)
      {
         if (input[i] == input[j])
         {
            return 0;
         }
      }
   }

   return 1;
}

以下是我的测试用例：

#include "in.h"
#include "checkit.h"

void in_tests(void)
{
   int input[3] = {2, 4, 5};
   int answer;

   answer = in(input, 3);
   checkit_int(answer, 1);

   int input1[4] = {1, 3, 4, 1};
   int answer1;

   answer1 = in(input1, 4);
   checkit_int(answer, 0);
}

int main()
{
   in_tests();

   return 0;
}

Answer 1

没有排序，O（n ²）：

j以i + 1开头。

int IsDiff(int array[], int count)
{
    int i,j;
    for (i=0; i<count; i++)
    {
        for (j=i+1;j<count;j++)
        {
            if (array[i] == array[j])
                return 0;
        }
    }
    return 1;
}

Answer 2

如果空间不是问题，那么我们可以使用哈希表来获得O（n）解决方案。开始将数组的每个元素存储在哈希表中。在插入元素时，检查它是否已经存在于哈希表中（花费O（1）时间。）如果元素已经存在，则立即返回false，否则迭代直到数组结束并返回true。 / p>

Answer 3

实际上，这不是你的功能不起作用的原因。主要原因是因为目前你正在检查是否有任何一对DONT匹配，如果你想看看所有元素是否匹配，但是你想做相反的事情会很好，所以你想检查相反的，如果有任何一对DOES比赛。所以首先改变你的if

if(input[i] == input[j]) return false;

如果一对相等，那么你就知道你的测试已经失败了，所以不需要检查其余的对，只需在那里返回false。

唯一要做的就是整理你的循环，这样你只需要遍历每一对，而不是将一个值与它的自我进行比较。要做到这一点，将for循环改为：

for(int i =0; i<size-1; i++)
   for(int j=i+1; j<size; j++)

然后如果你到达函数的末尾，则表示没有匹配的对，所以只返回true;

Answer 4

O（n ^ 2）以及..但我添加了这个使代码更容易理解的函数......

int unique(int input[], int value,int size){
    int times=0;
    for (int i = 0; i < size; i++)
    {
        if(input[i]==value){
             times++;
             if(times==2)
                return 0;
        }
    }  
    return 1;
}

int in(int input[], int size)
{
   int x, answer;

   for (int i = 0; i < size; i++)
   {  
      if(!unique(input,input[i],size))
          return 0;
   }
   return 1;
}

Answer 5

你非常接近，试试这个：

#include "in.h"

int in(int input[], int size)
{
   int answer = 1;

   for (int i = 0; i < size-1; i++)
   {  
      for (int j = i+1; j < size; j++)  //check everything above your current 
                                        //value because you have already checked 
                                        //below it.
      {
         if (input[i] == input[j])
         {
            answer = 0;                  //If any are not unique you
            break;                       //should exit immediately to save time

         }
      }
      if (answer == 0)
          break
   }
   return answer;
}

Answer 6

这是我的尝试（尽管非常简单和低效）：

#include <stdio.h>

int uniq_int(int arr [], int size)
{        
    int i, j;

    for (i = 0; i < size; i++) 
        for (j = i + 1; j < size; j++)
            if (arr[i] == arr[j])
                return 0;

    return 1;
}


int main()
{
    int arr [] = {1, 2, 4, 3, 5};

    (uniq_int(arr, 5)) ? printf("Unique!\n") : printf("Not...\n");
    /* the above can be written more traditionally like this:
    if (uniq_int(arr, 5) != 0)
    {
        printf("Unique!\n");
    }
    else
    {
        printf("Not...\n");
    }
    */

    return 0;
}

这将从第一个开始比较数组的每个成员与其余成员并将它与下一个进行比较，依此类推，直到内循环结束。

然后我们再次启动外部循环，但这次我们将数组的第二个元素与之后的元素进行比较。

一旦找到匹配项，函数将返回，并且不需要比较其他元素。否则外部循环将继续，直到最后一个元素，一旦到达它将退出并返回1，这意味着每个成员都是唯一的。

它的复杂度为O（n ^ 2），因为在最坏的情况下，每个成员处理该集合两次。

Answer 7

思考问题

假设你有一个这样的数组：int array[] = { 3, 1, 4, 8, 2, 6, 7, 7, 9, 6 };

如果从第一个元素开始，则需要与集合中的其余元素进行比较;所以3需要与1,4,3 ......等进行比较。

如果3是唯一的，你现在需要转到1并查看其余的元素，但下次你不需要担心3;所以你正在考虑的值（让我们称之为V）需要是array [0]到array [N-1]中的每一个，其中N是array的大小（在我们的案例中10）;

但是如果我们将自己想象在数组的中间，我们会注意到，当前一个元素是中考虑的值时，我们已经将前面的元素与当前元素进行了比较。所以我们可以忽略“背后”我们的任何元素;这意味着比较必须每次都要考虑当前值的INDEX（让我们称之为k）并将其与从NEXT索引开始并到达数组末尾的值进行比较;所以我们10的数组的伪代码看起来像这样：

int is_a_set(int array[]) 
{
   for ( k = 0; k < 10-1 ; k++ ) { /* value under consideration */
      v = array[k]; 
      for ( m = k+1 ; m < 10; m++ ) { /* compared to the remaining array starting
                                     * starting from the next element */
           if ( v == array[m] ) { /* we found a value that matches, no need to 
                                   * to continue going, we can return from this function
                                   */
                 return true; 
           }
      }
   }
   return false;
}

现在您可以使用以下内容：

if ( is_a_set(my_array) ) {

}

您应该可以使用它来计算代码的其余部分:-)

注意：具有唯一元素的集合称为set，因此我将函数命名为is_a_set

HINTS：将数组（10）的大小转换为参数或某种变量

如果数组中的每个整数都不同，如何编写一个返回true的函数？

7 个答案:

思考问题