Der Server muss sowieso deine öffentliche IP kennen, und natürlich kann er diese auch an ein JS im Browser weiter geben.

Zum Thema Cookies google am besten mal nach "Same Origin Policy", wobei man dazu sagen muss, dass im Schnitt alle halbe Jahre jeder größere Browser Sicherheitslücken hat, mit denen man das umgehen kann. (Zufällig erst vorgestern war Safari mal wieder an der Reihe.)

Und zur lokalen IP: Die kann man ganz einfach mit der WebRTC-API über JS herausfinden, aber das weiß kaum jemand. Trackingfirmen nutzen das gerne für Fingerprinting aus, aber viele Addons erlauben das zu blocken. (z. B. uBlock Origin, usw.)

Und auch wenn du nicht danach gefragt hast: Die MAC-Adressse kann man mit einem Java Applet auslesen, allerdings ist "Java im Browser" heutzutage zum Glück kein Thema mehr, aber früher - vor vielen hundert Jahren - war das noch möglich. :)

Fazit: Öffentliche IP auslesen ist kein Ding, private IP auch nicht, wenn man weiß wie und Cookies sollte normalerweise (!) nur die Website auslesen können, die sie gesetzt hat (ja, ich weiß, ist technisch nicht korrekt und es gibt Ausnahmen, ...), aber in relativ regelmäßigen Zeitabständen gilt das aufgrund von Browserbugs nicht mehr.

In meinem Beruf (Softwareentwicklung) sehe ich genügend junge Programmierer, die gelinde gesagt totalen Mist zusammen frickeln, und denen kann man dann schon mal gute Ratschläge geben.

Die meisten nehmen es dankbar an, aber einige reagieren wie du ... naja, einige Leute müssen ihre Fehler eben selber machen, um daraus zu lernen. :)

Wie man in C++ würfelt steht im Codebeispiel unten auf dieser Seite:

https://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution

Die anderen Antworten hauen mich etwas um. Ich glaube, in kaum einer anderen Programmiersprache fürchten sich die Programmierer so sehr davor, die Standardbibliothek zu nutzen, als bei Python.

Stattdessen wird ständig das Rad neu (und falsch bzw. ineffizient) zu erfunden.

Aber egal, deine Lösung sieht so, und nicht anders, aus:

from collections import Counter

values = [1, 2, 3, 4, 4]
stats = Counter(values)

print(dict(stats))

for value, count in stats.most_common():
    print(value, ' => ', count)

Das gibt dir die Statistiken einmal als Dictionary, und einmal in sortierter Reihenfolge aus:

{1: 1, 2: 1, 3: 1, 4: 2}
4  =>  2
1  =>  1
2  =>  1
3  =>  1

Auch wenn es anfangs etwas länger dauert, üerfliege wenigstens mal die gesamte (!) Dokumentation zur Standardbibliothek von Python!

Dann hast du nämlich im Hinterkopf "was es so alles gibt", und musst nur kurz danach suchen, anstatt auf schlechte Frickellösungen von GF zurück zu greifen. :)

Weniger als 0! Kein Scherz! (Erklärung in den nächsten Absätzen ...)

Ich spreche hier mal aus meiner eigenen Erfahrung als professioneller Entwickler mit vielen zich Jahren Berufserfahrung.

Ich werde oft in Projekte berufen, die seit vielen Jahren bzw. Jahrzehnten gewachsen sind.

Das erste, was ich mit Legacy-Code mache, ist vernünftige Tests zu schreiben, bzw. das System überhaupt erst mal testbar zu machen.

Im zweiten Schritt wird "Kosmetik" gemacht und der Code aufgehübscht, offensichtliche Bugs entfernt, Sicherungen eingebaut, uvm.

Dann wird groß ausgemistet, und größere Codeteile redesigned bzw. extrem viel alter Klumpatsch weggeworfen.

Am Ende werden neue Features eingebaut und die Software weiter gehärtet.

Und jetzt kommts: Wenn ich damit fertig bin, habe ich i. d. R. mehr Codezeilen vernichtet, als insgesamt hinzugefügt.

An den Projektmetriken sieht man dann, dass ich eine negative Anzahl an Codezeilen beigetragen habe, was immer ganz lustig aussieht.

Das Projekt ist danach deutlich schlanker, schneller, sicherer, allgemein effizienter, hat vernünftige Tests und neue Features.

Deshalb ist es für einige Entwickler gar nicht mal so unüblich, wenn sie über die Projektlaufzeit gemittelt im Schnitt -10000 (Minus Zehntausend!) Zeilen Code pro Tag "produzieren".

Aber das bezog sich auf Legacy-Code.

Meine allgemeine Erfahrung bei Neuentwicklungen ist, dass die besten Programmierer die wenigsten Zeilen an Code schreiben, der dann letztendlich auch im Projekt dauerhaft (!) bestehen bleiben.

Die schlechtesten Entwickler schreiben meistens den meisten Code, der dann aber natürlich nicht gut durchdacht ist, und eine Million mal mutiert, bis er dann irgendwann entfernt wird.

Solche Entwickler produzieren natürlich massenhaft LOCs, aber da das alles Abfall ist, bleibt davon am Ende nicht viel übrig.

Gute Entwickler überlegen sich vorher was und vor allem wie sie es schreiben, was dann meist enorm kurz, effizient und dennoch semantisch gut verständlich ist.

Bei Stackoverflow und auch an anderer Stelle werden dazu Statistiken erhoben, und seit den 90ern ändert sich nicht viel daran: Gute Programmierer schaffen etwas über 100 Zeilen pro Tag. Damit sind die gemeint, die auch übrig bleiben.

Du kannst natürlich locker 2000 oder 3000 Zeilen pro Tag eintippen, aber da kann ich dir garantieren, dass das am Ende größtenteils Murks sein wird.

Fazit: Je besser der Entwickler, desto weniger LOCs. Und bei Legacy-Projekten sind negative LOCs eher die Regel, als die Ausnahme, zumindest in der Anfangsphase. :)

Dein Code ist Fehlerhaft, da du ein binäres UND anstelles des Modulo Operators verwendest.

Davon abgesehen ist dein Code C und nicht C++ und du benutzt die alte rand() Funktion mit extrem schlechter zufälliger Verteilung.

In C++ würde ich es so machen:

#include <iostream> // cout, endl
#include <random> // default_random_engine, random_device, uniform_int_distribution
#include <type_traits> // extent_v

#include <cstdlib> // size_t

int main() {
    using namespace ::std;

    const int values[] { 5, 10, 20, 50, 100, 200 };
    constexpr size_t count { extent_v<decltype(values)> };

    default_random_engine prng { random_device{}() };
    uniform_int_distribution<size_t> choice { 0, count - 1 };

    for (size_t i {}; i < 10; ++i) {
        const auto value { values[choice(prng)] };

        cout << i << " => " << value << endl;
    }
}

Dafür brauchst du aber einen modernen Compiler, der C++17 unterstützt.

Das Programm gibt dir einfach 10 zufällig gewälte Einträge aus deinem Array aus.

Viel Spaß! :)

Etwas größeres als Thomann wirst du nicht finden. :)

Entweder so:

#include <iostream> // cout, endl
#include <iterator> // begin, end
#include <numeric> // accumulate
#include <type_traits> // extent

// ...

using namespace ::std;

// ...

const auto average {
  accumulate(begin(anzahl), end(anzahl), 0.0)
  / extent_v<decltype(Stadt)>
};

cout << average << endl;

Falls dir das noch zu hoch ist, dann einfach "händisch" in einer Schleife alle Werte aus deinem Array aufsummieren, und ganz am Ende durch "sizeof(Stadt) / sizeof(*Stadt)" teilen.