Gleiche Elemente in einem unsortierten Array

Question

Ich mache ein Programm, um festzustellen, ob ein Array mit 5 Karten (Benutzereingabe) einen bestimmten Handwert hat. Paar, zwei Paare, drei von einer Art, gerade, volles Haus, vier einer Art (alle Kartenwerte sind 2-9, keine Bildkarten, keine Farbe). Ich versuche das zu tun, ohne das Array zu sortieren. Ich verwende diese derzeit durch das Array zu suchen und zu identifizieren, wenn zwei Elemente miteinander

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

Enthält dieser Code-Abschnitt gleich sind nur beurteilen, ob die ersten beiden Elemente gleich sind, oder wird es wahr zurück, wenn zwei Elemente sind gleich? Wenn die eingegebene Hand 2,3,2,4,5 wäre, würde dies falsch zurückkehren, wobei 2,2,3,4,5 wahr werden würde? Wenn ja, wie sehe ich, ob zwei Elemente unabhängig von der Reihenfolge gleich sind, ohne das Array zu sortieren?

bearbeiten: bitte verzeihen Sie die Tippfehler, ich verlasse den ursprünglichen Post intakt, um keine Verwirrung zu schaffen.

Ich habe nicht versucht, den Code zu kompilieren, für die Aufzeichnung.

Answer 1

Es wird auch nicht:

1. i < array wird nicht funktionieren, array ist ein Array kein int. Sie benötigen etwas wie int arraySize als zweites Argument für die Funktion.
2. Auch wenn Sie das dann reparieren; array[i]==aray[i+1] verursacht undefiniertes Verhalten, weil Sie auf 1 nach dem Ende des Arrays zugreifen. Verwenden Sie die For-Loop-Bedingung i < arraySize - 1.
3. Wenn Sie beide dieser Dinge beheben, dann was Sie überprüfen, ist, wenn 2 aufeinander folgende Karten gleich sind, die nur funktionieren, wenn das Array sortiert ist.

---

Wenn Sie schräges Art wirklich das Array (die mit std::sort so einfach sein würde), dann können Sie dies tun:

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; 
} 

Dieser Algorithmus ist tatsächlich die Bucket Sort genannt und wirklich noch ist das Sortieren das Array, es tut es einfach nicht an Ort und Stelle.

Answer 2

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

Diese Schleife wird nur zwei benachbarte Werten vergleichen, so wird die Schleife für die Array-return false [] = {2,3,2,4,5}.

Sie benötigen eine verschachtelte for-Schleife:

#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 ------

Wie Ben sagte, sollte ich die Funktion erwähnen oben wird nur die erste Instanz finden 2 übereinstimmende Karten, aber es kann nicht zählen, wie viele Karten übereinstimmen oder ob verschiedene Karten passen. Sie können etwas wie unten tun, um die Anzahl der übereinstimmenden Karten im unsortierten Array zu zählen und diese Werte in einem separaten Array zu speichern. Es ist unordentlicher als die Implementierung oben:

#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

Kennen Sie die Bedeutung von Rückschlüsselwort?return bedeutet, dass das Ende der Funktion erreicht wird. In Ihrem Code, wenn zwei benachbarte Werte gleich sind, wird die Funktion sofort beendet. wenn Sie für andere Gleichstellungsmöglichkeiten Überprüfung fortsetzen wollen, dann verwenden Sie keine Rückkehr, aber Sie können in einem Array-Indizes gleicher Werte speichern

#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

Sie eine std::unordered_set für eine O(n) Lösung verwenden:

#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; 
}