[C++] Wie oft kommt ein Element in einem Array vor?

[Grammaton]

Servus zusammen,

ich habe ein Array mit 10 Feldern und möchte nun prüfen wie oft ein Element darin auftaucht, allerdings hab ich immer falsche Ansätze um das Problem zu lösen, mein letzter Versuch:

#include <iostream>
using namespace std;

int main(){
    
int i,n,counter[10],count=0;
double eingabe;

int feld[]={11,11,13,14,13,14,15,12,12,11};


for(i=0;i<10;i++){

for(n=0;n<10;n++){
                    cout << "i:" << i << "-- n:" << n << endl;
                    
                    
                    if(feld[i]==feld[n]){count+=1;}
                    
                    }
counter[i]=count;
count=0;

} 



for(i=0;i<10;i++){
                  
                  cout << feld[i] << ": " << counter[i] << "-x" << endl;
                  
                  }



}

haut auch nich so ganz hin, könnte mir bitte jemand helfen?

[Blackdonut]

Da ich diese Zeile "cout << "i:" << i << "-- n:" << n << endl;" nicht verstehe weiß ich nicht genau, was du willst. Deshalb hab ich mal 2 Möglichkeiten mit Lösungsvorschlag.
1. Du willst wissen, wie oft eine beliebige Zahl im Array vorkommt.
int feld[]={10 Zahlen}
int suchzahl;
int counter = 0;
for (int i = 0; i>10; i++)
{
if (feld[i] == suchzahl)
counter++;
}

2. Du willst von jeder Zahl wissen, wie oft sie vorkommt.
Ich bin jetzt zu faul mir den Code zu überlegen, aber ich würde mal vorschlagen, du erstellst das normale Array mit den Zahlen und dazu ein zweidimensionales Array, mit 2 Zeilen und genauso viel Spalten wie das andere Array hat.
Du durchläufst in einer for-Schleife das erste Array. Bei jedem Element durchsuchst du die erste Zeile deines zweidimensionalen Arrays und schaust, ob es diese Zahl schon gibt. Wenn ja, erhöst du den Zähler, der in der zweiten Zeile darunter steht, um eins. Wenn es die Zahl noch nicht gibt, gehst du zum nächsten leeren Feld im zweidimensionalen Array und schreibst die Zahl in Zeile 1. In Zeile zwei kannst du dann die Häufigkeit schreiben, also 1.

[hergipotter]

Weiß zwar nicht wieso du immer die Schleifenvariablen ausgeben lässt aber sonst passt das doch, wenn ich deinen Code ausprobiere kommt das am Schluss raus:

11: 3-x
11: 3-x
13: 2-x
14: 2-x
13: 2-x
14: 2-x
15: 1-x
12: 2-x
12: 2-x
11: 3-x

Könntest jetzt höchstens noch die mehrfachen Einträge nur einmal ausgeben lassen.

[user710]

Servus zusammen,

ich habe ein Array mit 10 Feldern und möchte nun prüfen wie oft ein Element darin auftaucht, [...]

So geht man das Problem an:
* Gehe das Problem erst im Kopf durch (das gerade ist triviale Logik!)
* Du solltest das Problem so Allgemein wie möglich lösen.
--> Algo in Funktion, Klasse auslagern, Templates, STL-Stil

Also hier ist mal eine Musterlösung, wenn du die Anzahl eines Elements in irgendeinem zusammenhängenden Datenstapel zählen möchtest:

#include <iostream>

using namespace std;

template<class TIter, class TValue>
int count_multiple(TIter begin, TIter end, TValue compare) {
    int count = 0;
    while (begin != end) {
        if (*begin++ == compare)
            count++;
    }
    return count;
}

template<class TIter, class TValue, class TFunc>
int count_multiple(TIter begin, TIter end, TValue compare, TFunc equals) {
    int count = 0;
    while (begin != end) {
        if (equals(*begin++, compare))
            count++;
    }
    return count;
}

int main(int argc, char **argv) {
    // without func
    int array[] = {1,1,1,2,3,4,5,6,7,8};
    int multiple_count = 0;

	multiple_count = count_multiple(array, array+9, 1);
    cout << multiple_count << endl;

    multiple_count = 0;

    // with func
    multiple_count = count_multiple(array, array+9, 1, [](int a,int b) { return a == b; });
    cout << multiple_count << endl;

    return 0;
}

Für dich eine Todo-Liste:
* Studieren von komplexen Algos
* Templates anschauen
* STL anschauen

Ich hoffe du bist dann in der Lage einen Algorithmus zu erstellen, der die Anzahl von mehrfachen Einträgen zählt. Das glaube ich hast du nämlich gemeint, aber nicht so formuliert :P

[Imonbln]

Abgesehen von der Musterlösung, kann es hilfreich sein die Elemente erstmals zu sortieren.
das hätte den Vorteil das in diesen fall einfacher zählen kannst, denn die gleichen liegen Hintereinander und wenn du etwas Pointermagic machst beim zahlen der Anderen Elemente nicht mehr das ganze Array durchsuchen musst.

Das Hängt aber ein wenig von der Aufgabenstellung ab, ob sich das lohnt.

[user710]

Naja, einen Quicksort zu implementieren wird um einiges schwieriger sein.. Außer er nutzt die STL Aber selbst wenn er die STL nutzen würde, gibt es effizientere Lösungen für das Problem.

[Jodocus_]

So geht man das Problem an:
* Gehe das Problem erst im Kopf durch (das gerade ist triviale Logik!)
* Du solltest das Problem so Allgemein wie möglich lösen.
--> Algo in Funktion, Klasse auslagern, Templates, STL-Stil

Also hier ist mal eine Musterlösung, wenn du die Anzahl eines Elements in irgendeinem zusammenhängenden Datenstapel zählen möchtest:

#include <iostream>

using namespace std;

template<class TIter, class TValue>
int count_multiple(TIter begin, TIter end, TValue compare) {
    int count = 0;
    while (begin != end) {
        if (*begin++ == compare)
            count++;
    }
    return count;
}

template<class TIter, class TValue, class TFunc>
int count_multiple(TIter begin, TIter end, TValue compare, TFunc equals) {
    int count = 0;
    while (begin != end) {
        if (equals(*begin++, compare))
            count++;
    }
    return count;
}

int main(int argc, char **argv) {
    // without func
    int array[] = {1,1,1,2,3,4,5,6,7,8};
    int multiple_count = 0;

	multiple_count = count_multiple(array, array+9, 1);
    cout << multiple_count << endl;

    multiple_count = 0;

    // with func
    multiple_count = count_multiple(array, array+9, 1, [](int a,int b) { return a == b; });
    cout << multiple_count << endl;

    return 0;
}

Für dich eine Todo-Liste:
* Studieren von komplexen Algos
* Templates anschauen
* STL anschauen

Ich hoffe du bist dann in der Lage einen Algorithmus zu erstellen, der die Anzahl von mehrfachen Einträgen zählt. Das glaube ich hast du nämlich gemeint, aber nicht so formuliert :P

Mit std::map kann man das Problem mit allgemeinen Typen in 3 Zeilen lösen. :S

[user710]

Ja, das Problem mit einem SortedDictionary anzugehen ist wohl das vernünftigste. Das war auch mein Gedanke, der TS sollte aber von alleine darauf kommen