Zählen die Anzahl der gleichen Werte in der Karte

ist dort jeder Befehl zählt die Anzahl der gleichen Werte in einer Karte?

wie:

map<int, string> m;
m[1] = "A";
m[22] = "A";
m[53] = "C";
m[12] = "A";
m[6] = "A";

int count = m.count("A");//4

oder sollte ich einfach nur schreiben es selbst, da es nicht zu hart?

  • Die erste Sache, die den Sinn kam, war zu erstellen, ein weiteres std::map<string , int> welches verwendet wird zum zählen der Häufigkeit der einzelnen .second
  • Das sollte das Letzte, was mir einfällt. Du bist einfach Einführung viel Komplexität zu erreichen, eine sehr einfache Aufgabe, für die es bereits toos.
  • Dibling: Was meinst du mit viel Komplexität? Wenn Sie sehen, von den Antworten unten, ohne C++0x unterstützen, müssen Sie eine angemessene Menge an code zu schreiben, wenn Sie die Nutzung von STL-count_if. Ich bin geneigt zu glauben, dass mit einer anderen Karte benötigen weniger Menge an code. Auch mit Karte hat eine bessere Laufzeit-Komplexität also O(log n), während Sie gehen durch alle map-Elemente, wenn Sie count_if d.h. O(n)
  • Mit einem zweiten map zum speichern von Frequenzen ist besser, wenn Sie brauchen, um eine große Anzahl von zählt. Dieser Ansatz erfordert auch, dass die Elemente, die im container gespeichert sind, vergleichbar. Wenn Sie nur eine einzige zählen, dann ist es viel besser, aufzählen der Elemente mit count_if.
  • McNellis: ich sehe Ihren Punkt, und ich denke auch, deine Antwort ist schön und natürlich lehrreich. Aber trotzdem, es ist nicht die Beantwortung meiner Frage zu John Dibling über welche Arten von Komplexität ist die Verwendung einer zweiten Karte imposant, im Vergleich zu mit, um eine Funktion definieren, Objekt =). Ja, es erfordert operator< umgesetzt werden (wahrscheinlich irrelevant, wenn der Schlüssel ist std::string). Ja, es ist Verschwendung von Speicher, wenn man nur zählen, der es mal (auch wenn poster nicht geben). Aber Komplexität in der Umsetzung? Ich nicht kaufen =)
InformationsquelleAutor calccrypto | 2011-04-01
  1. 6

    Können Sie std::count mit einem benutzerdefinierten Wert parameter:

    struct Compare {
    std::string str;
    Compare(const std::string& str) : str(str) {}
};
bool operator==(const std::pair<int, std::string>&p, const Compare& c) {
    return c.str == p.second;
}
bool operator==(const Compare& c, const std::pair<int, std::string>&p) {
    return c.str == p.second;
}


int  main() {
    std::map<int, std::string> m;
    m[1] = "A";
    m[22] = "A";
    m[53] = "C";
    m[12] = "A";
    m[6] = "A";

    int count = std::count(m.begin(), m.end(), Compare("A"));

    std::cout << count << "\n";
}
    InformationsquelleAutor Robᵩ
  2. 14

    Können Sie die count_if - Algorithmus mit einer custom-Prädikat-Objekt Funktion:

    template <typename Pair>
struct second_equal_to
    : std::unary_function<const Pair&, bool>
{
    second_equal_to(const typename Pair::second_type& value)
        : value_(value) { }

    bool operator()(const Pair& p) const
    {
        return p.second == *value_;
    }

private:
    typename Pair::second_type value_;
};

    Verwendung:

    typedef std::map<int, std::string> Map;
typedef Map::value_type MapEntry;
std::count_if(m.begin(), m.end(), second_equal_to<MapEntry>("A"));

    Oder, für eine allgemeinere Lösung, Sie können schreiben, eine apply_to_second Prädikat Transformator:

    template <typename Pair, typename Predicate>
struct apply_to_second_f
    : std::unary_function<const Pair&, bool>
{
    apply_to_second_f(const Predicate& p)
        : predicate_(p) { }

    bool operator()(const Pair& p) const
    {
        return predicate_(p.second);
    }

    Predicate predicate_;
};

template <typename Pair, typename Predicate>
apply_to_second_f<Pair, Predicate> apply_to_second(const Predicate& p)
{
    return apply_to_second_f<Pair, Predicate>(p);
}

    Verwendung:

    std::count_if(m.begin(), m.end(), 
    apply_to_second<MapEntry>(std::bind2nd(std::equal_to<std::string>(), "A")));

    Wenn Sie einen compiler, unterstützt lambda-Ausdrücke, Sie brauchen keine custom-Prädikat functor bei allen; können Sie eine viel einfachere lambda:

    std::count_if(m.begin(), m.end(), [](const MapEntry& e) { 
    return e.second == "A";
});
    • Mein Einhorn geben Sie einen Daumen hoch und ein +1
    • Das lamda ist sexy, keine Notwendigkeit für viele Zeilen extra-code, wenn Sie nur einmal verwendet werden.
    InformationsquelleAutor James McNellis
  3. 2

    STL ist count_if und es ist durchaus machbar manuell.

    EDIT: Sorry, sollte count_if nicht zählen

    InformationsquelleAutor nevets1219
  4. 0

    map::zählen, zählen ist der Schlüssel und nicht das element, so dass das Beispiel in deiner Frage, wäre falsch. Möchten Sie vielleicht zu prüfen, mit eine zusätzliche Karte, um zu verfolgen die Anzahl der einzelnen Werte.

    map<string, int> value_count;
//use like this
++value_count[val];
    • Definitiv die einfachere Lösung, wenn die Durchführung eine zusätzliche variable herum ist nicht ein Problem.
    • -1 Nun müssen Sie halten zwei Karten in sync. Jedes mal, wenn Sie ändern, der erste, Sie haben zu stellen Sie sicher, dass Sie die zweite ist auch entsprechend geändert. Ich glaube, das ist die "große Komplexität" - das war früher. Es sei denn, Sie umgestalten, diese in eine richtige container-Klasse, die sich mit dem halten beide Karten in sync würde ich abraten.
    InformationsquelleAutor ryaner
  5. 0

    Diese sollte generisch genug:

    template< class T1, class T2 >
class Condition
{
    public:
        Condition( const T2& val ) : _val( val ) {};
        bool operator()( const typename std::pair< const T1, T2 >& aPair )
        {
            return (aPair.second == _val);
        }
    private:
        const T2 _val;
};

    dann können Sie es verwenden, wie diese:

    Condition< int, std::string > comp( "A" );
size_t count = std::count_if( m.begin(), m.end(), comp );

    Tun, beachten Sie, dass dies nicht wirklich sehr Verschieden von vorherigen Antworten, aber es sollte wiederverwendbar sein, mit allem, was durchläuft Paare als auch. Nur umbenennen Bedingung, um etwas sinnvolles.

    InformationsquelleAutor broc
Schreibe einen Kommentar