Question

我正在制作一个程序来识别5卡（用户输入）数组是否是某个手牌值。对，两对，三种，直，满屋，四种（所有卡值均为2-9，无面卡，无套装）。我试图这样做而不排序数组。我目前正在使用它来查看数组并确定两个元素是否彼此相等

bool pair(const int array[])
{
 for (int i = 0; i < array; i++)
 {
 if (array[i]==aray[i+1])
 {
    return true;
 }
 else 
    return false;
}

这部分代码是仅评估前两个元素是否相同，或者如果任何两个元素相同，它会返回true吗？ I.E如果输入的手是2,3,2,4,5，这将返回假，2,2,3,4,5会返回真实吗？如果是这样，如何在不对数组进行排序的情况下查看任何两个元素是否相等，无论顺序如何？

编辑：请原谅错别字，我原来的帖子完好无损，以免造成混淆。

我没有尝试编译代码，用于记录。

Answer 1

两者都不会：

i < array不起作用，array是一个数组而不是int。你需要int arraySize之类的东西作为函数的第二个参数。
即使你解决了这个问题; array[i]==aray[i+1]将导致未定义的行为，因为您将在数组末尾访问1。使用for循环条件i < arraySize - 1。
如果您修复了这两件事，那么您正在检查的是2张连续卡是否相等，只有在数组已排序时才会有效。

如果你真的无法对数组进行排序（使用std::sort这么容易），那么你可以这样做：

const int NumCards = 9; // If this is a constant, this definition should occur somewhere. 

bool hasPair(const int array[], const int arraySize) {

    int possibleCards[NumCards] = {0}; // Initialize an array to represent the cards. Set 
                                       // the array elements to 0.

    // Iterate over all of the cards in your hand.
    for (int i = 0; i < arraySize; i++) {

       int myCurrentCard = array[i]; // Get the current card number.
       // Increment it in the array.
       possibleCards[myCurrentCard] = possibleCards[myCurrentCard] + 1; 


       // Or the equivalent to the above in a single line. 

       possibleCards[array[i]]++; // Increment the card so that you 
                                  // count how many of each card is in your hand.
    }

    for (int i = 0; i < NumCards; ++i) {
        // If you want to check for a pair or above.
        if (possibleCards[i] >= 2) { return true; }
        // If you want to check for exactly a pair.
        if (possibleCards[i] == 2) { return true; }
    }
    return false;
}

这个算法实际上被称为Bucket Sort，并且实际上仍在对数组进行排序，它只是没有在适当的位置进行。

Answer 2

for (int i = 0; i < array; i++)
 {
 if (array[i]==aray[i+1])
 {
    return true;
 }
 else 
    return false;

此循环仅比较两个相邻的值，因此对于array [] = {2,3,2,4,5}，循环将返回false。

你需要一个嵌套的for循环：

#include <stdio.h>
#include <stdbool.h>
int main()
{
  int unsortedArray[] = {2,3,2,4,5};
  int size = 5;

  for(int i=0;i<size-1;i++)
  {  for(int j=i+1;j<size;j++)
      {   if(unsortedArray[i]==unsortedArray[j])
           {  printf("matching cards found\n");
              return 0;
            }
       }
    }   
    printf("matching cards not found\n");
    return 0;
}

---- EDIT ------

像Ben说的那样，我应该提一下上面的功能只能找到2张匹配卡的第一个实例，但它不能计算有多少张卡匹配，或者是否有不同的卡匹配。您可以执行类似下面的操作来计算unsortedArray中所有匹配卡的数量，并将这些值保存到单独的数组中。它比上面的实现更麻烦：

 #include <iostream>
 #include <stdio.h>
 #include <stdbool.h>

 #defin NUM_CARDS 52;

 using namespace std;

    int main()
    {
      int T;
      cin>>T;
      while(T--)
      {
      int N,i,j;
      cin>>N;
      int unsortedArray[N];
      for(int i=0;i<N;i++)
        cin>>unsortedArray[i];

      int count[NUM_CARDS]={0};
      int cnt = 0;

      for( i=0;i<N-1;i++)
      {     
        for( j=i+1;j<N;j++)
        {  if(unsortedArray[i]==-1)
              break;      
           if(unsortedArray[i]==unsortedArray[j])
           { 
              unsortedArray[j]=-1;
              cnt++;
           }
        }
           if(unsortedArray[i]!=-1)
           {  
              count[unsortedArray[i]]=cnt; //in case you need to store the number of each cards to
                                           // determine the poker hand.
              if(cnt==1)
               cout<<" 2 matching cards of "<<unsortedArray[i]<<" was found"<<endl;
              else if(cnt>=2)
               cout<<" more than 2 matching cards of "<<unsortedArray[i]<<" was found"<<endl;
              else
                cout<<" no matching cards of "<<unsortedArray[i]<<" was found"<<endl;

            cnt = 0;
            }
        }

Answer 3

你知道return关键字的含义吗？ return意味着到达函数的末尾，所以在你的代码中，如果两个相邻的值相等，它会立即退出函数;如果你想继续检查其他相等的可能性，那么不要使用return但你可以在数组中存储相等值的索引

    #include <iostream>
    using namespace std;


    int* CheckForPairs(int[], int, int&);

    int main()
    {

        int array[ ]= {2, 5, 5, 7, 7};

        int nPairsFound = 0;

        int* ptrPairs = CheckForPairs(array, 5, nPairsFound);


        for(int i(0); i < nPairsFound; i++)
        {
                cout << ptrPairs[i] << endl;

        }

        if(ptrPairs)
        {
           delete[] ptrPairs;
           ptrPairs = NULL;
         }

        return 0;
    }

    int* CheckForPairs(int array[] , int size, int& nPairsFound)
    {

        int *temp = NULL;
        nPairsFound = 0;
        int j = 0;

        for(int i(0); i < size; i++)
        {
            if(array[i] == array[i + 1])
                nPairsFound++;
        }

        temp = new int[nPairsFound];

        for(int i(0); i < size; i++)
            {
                if(array[i] == array[i + 1])
                {
                    temp[j] = i;
                    j++;
                }
            }

        return temp;
    }

Answer 4

您可以使用std::unordered_set作为O(n)解决方案：

#include <unordered_set>

using namespace std;

bool hasMatchingElements(const int array[], int arraySize) {
  unordered_set<int> seen;
  for (int i = 0; i < arraySize; i++) {
    int t = array[i];
    if (seen.count(t)) {
      return true;
    } else {
      seen.insert(t);
    }
  }
  return false;
}

未排序数组中的相等元素

4 个答案: