Kommt letztlich aufs selbe hinaus, habs mir immer angewöhnt 1000 zu nehmen.
Ich meinte den OptEvent gar nicht erst benutzen.
Kommt letztlich aufs selbe hinaus, habs mir immer angewöhnt 1000 zu nehmen.
Ich meinte den OptEvent gar nicht erst benutzen.
@alpines es müsste bereits reichen wenn er "Sleep 10" in die While einbaut.
Du hast ianmy ja auch bereits definiert. Nach den ersten 2 Zeilen kannst du das "Global" weg lassen. Eventuell solltest du noch einige Tutorials lesen.
Wenn du das Array mit Zahlen beschreiben willst, was sollen dann die eckigen Klammern darum?
Ich empfehle dir mit Listen zu arbeiten, da diese wesentlich performanter gegenüber dynamischer Veränderung stehen.
AspirinJunkie hat dazu mal einen Thread erstellt: https://autoit.de/index.php/Thre…iven-zum-Array/
dass Compiler heutzutage Code generieren, welcher (von Menschen) nicht mehr weiter zu verbessern ist
Falsche Tatsache. Dies war nicht meine Aussage. Die korrekte Aussage ist unten zu finden.
beliebiger Quellcode
Fehler Nummer eins gefunden: Das war nie Ausgangssituation, geschweige denn Gegenstand der Sache. Es geht um eine große Menge, nicht etwa um "Alle", das würde implizieren dass Aussage 2 natürlich auch so richtig ist.
Anders herum gesagt, ein Mensch in Form eines ASM-Programmierers sei im Vergleich zum Compiler maximal "gleich gut".
Eine Aussage, die ich nicht tätigte.
Compiler hat "automatisch" den besten (nicht von Menschen zu verbessernden) Code erstellt
Ich weiß wirklich nicht woher du diese Aussagen nimmst, bin aber beeindruckt. Da solltest du jemandem mal auf die Finger hauen.
Also dann mal loslegen:
Meine Aussage dazu war, ist und wird bleiben: Wenn du deinen Prozessor kennst, dann produzierst du besseren Code als dein Compiler. Wenn du das nicht tust, dann nicht.
Um der Aussage mal kurz den Interpretationsfreiraum zu nehmen: Jemand der beschissenen Code produziert kann seinen Prozessor selbstverständlich nicht kennen, sonst würde er nicht so töricht sein und beschissenen Code produzieren.
Der Grund dafür liegt im Kern dessen, was dein Prozessor dir beim Pipelining abnehmen kann. Angenommen du schaust dir deinen ASM kompilierten Code an und stellst fest, dass ein paar Anweisungen redundant sind "Hä? Warum schiebt er hier ne Anweisung rein die nichts tut?" dann denkst du dir erstmal "Das kann weg."
Völlig falsch. Das kann eben nicht weg. Du weißt nicht, ob es deiner Pipeline zu Gute kommt, wenn sie einen Takt stallt und dann weiter macht, weil der Compiler bereits erkennt dass sonst ein Hazard auftritt (der mehr Zeit kostet als 1 Takt), oder eben nicht.
Und das, da würde ich fast drauf wetten, können 99% aller Software Entwickler nicht (mich natürlich eingeschlossen).
Dazu mal ein kurzer Beitrag von Heise.de - Compilervergleich: Intel vor Microsoft vor GCC.
Zitat aus dem Artikel: "Verallgemeinert kommt Louel zu dem Ergebnis, dass Intel mit seinem Compiler die Nase vorn hat. Die GCC litten unter anderem daran, dass sich viele ihrer Tuning-Optionen letztlich als unproduktiv erwiesen hätten."
Genau auf diesen Punkt will ich hinaus.
Nächstes Beispiel: Loop Unrolling. Man fässt sich an den Kopf, dass eine Datei "etwas" größer wird, aber im Endeffekt greifen wir der Pipeline unter die Arme weil sie einfach alles abarbeiten kann. Macht dein Compiler je nach Bedarf für Einen, man würde aber eine for-to Schleife nicht n-mal kopieren, nur weil es schneller ist.
Die Frage die sich mir nach den getätigten Aussagen stellt ist, ob hier wirklich einer ernsthafte Absicht einer Diskussion ist. Wenn ja, dann wären 90% der Aussagen im Eingangspost absolut überflüssig, weil sie nichts mit der Aussage per se zu tun haben, sondern eher sind à la "Der Compiler kann aus Scheiße Gold machen". Das ist natürlich kein Gegenstand der Sache, geschweige denn eine Basis auf der man sich unterhalten müsste.
Wenn es aber um langfristige Berechnungen und schnelle Abarbeitung von Aufgaben gehen soll, bei der die Zeit der Programmierung keine so große Rolle spielt, dann lohnt es sich definitiv mal die paar Extrastunden zu investieren um das Programm doch noch ein Stück zu verbessern.
Da würde ich fast das präferieren, was Andy vorschlug: HLL (€: Selbstverständlich in die Richtung, sprich:) Warum dann nicht gleich einen eigenen Prozessor entwerfen (angenommen es geht um wirklich spezielle Aufgaben, z.B. Datenbanken)
redundante Zeilen
Hmm das ist schön und gut.
Redundant wäre sowas:
int i = n;
i += 2;
könnte man sich vermutlich an den Kopf fassen. Zwecks Lesbarkeit ist das aber eindeutig besser als die Alternative (das Beispiel ist nicht gut gewählt, verdeutlicht aber den Sachverhalt). Und der Compiler (der gelebte Antichrist) kürzt das sowieso so zusammen, als stünde da "n + 2".
solche Optimierungen absolut nicht notwendig sind
Und genau das ist eine beschissene Einstellung. "Ob wir das in 5 oder 6 ms erledigen ist doch egal" ist es eben nicht!
Wenn man ein Snippet publiziert und sich nur seine Eigenen Eingaben analysiert hat, dann wird man denken "Ja super läuft schnell". Sicher, für genügend kleine Eingaben macht es keinen Unterschied ob 50 oder 60ms, das spürt man nicht mal.
Dann nutzt aber jemand diese API (oder was auch immer) und stellt fest, dass es Sack langsam ist.
Gerade im OpenSource Bereich stolpert man viel zu oft über Code, wo man am liebsten heulen würde.
Wie programmiert/compiliert ihr? Ist (Code-)Optimierung überflüssig/überbewertet?
Überbewertet nicht, aber mir fehlt das KnowHow um noch weiter zu optimieren.
Müsste mit der BigNum UDF (klick mich) zu lösen sein.
Kannst du timen, dass das Script vor anderen Sachen terminiert? Also dass es beim Abmelden z.B. als Erstes terminiert?
Ich könnte mir vorstellen, dass es für das Script ein Problem ist wenn das Fenster nicht mehr existiert.
Wie wäre es denn damit, wenn du das Script mal pushst?
Eventuell verwendest du ja eine Ressource, die beim abmelden vorher gelöscht wurde.
Zufällig dasLayout von QWERTZ und QWERTY vertauscht? Passiert manchmal, dass es sich umstellt.
Ich denke ein Login System wäre nicht sinnlos, wenn du einfach eine Datenbank mit Accounts machst und dort einfach nur eine Variable setzt, ob er berechtigt oder unberechtigt ist.
Das ist auch einfach zu implementieren (5 Minuten Arbeit mit PHP)
Falls du dein Programm auch noch soweit absichern willst, dass beim decompilen nicht die Berechnungen usw sichtbar werden, kannst du diese auch einfach per PHP durchführen lassen. Dann ist der mathematische Teil zumindest nicht ersichtlich, selbst wenn jemand das Programm knackt.
Noch eine Stufe weiter wäre dann, dass du die Berechnungen nur durchführst wenn ein autorisierter Nutzer das macht, also z.B. die Login Daten mit übermittelst, das ist aber unnötig das jedes Mal zu tun und deshalb lieber einen Token geben lassen beim Login, der dann immer mit geschickt wird.
@Mars wie gesagt, Dienstag dann, ich bin doch gar nicht daheim ![]()
Nein Aspirin, ich schrieb in der SB mit ihm über QuickSort und Selection. Mit eben selbst genannter Laufzeit. Hatte aber einen Denkfehler, also eigentlich nicht, und kam deshalb auf O(n*k log k), was ja falsch ist, weil es + ist, wie du eben nanntest.
Den Vorschlag unterbreitete ich auch bereits, schon ganz zu Anfang, allerdings kam ich irgendwie davon ab... Natürlich sollte das schneller sein als O(n*k) ![]()
Edit: wobei ich mir gerade überlege: als Ergebnis des Quick-Select sollte das Array sowieso schon so aufgeteilt sein, das alle Elemente kleiner n links davon stehen, und alle größer n rechts davon. Nur halt in sich noch unsortiert.
Und genau diese Sortierung führt dann zum O(k Log k) ![]()
Per PN schon geschrieben, hier in Textform nochmal:
Ich würde bei dem Problem "größten / kleinsten j Elemente" eine Priority Queue, ferner einen Fibonacci Heap (ich glaube ich schrieb per PN vom Binomialheap, bleibt sich gleich, aber Fib-Heap ist irgendwie witziger) nehmen.
Damit staucht sich die Zeit auf O(n + k), wobei k die Anzahl der gesuchten Elemente beschreibt.
€: Irgendwas betrachte ich hier gerade immer noch falsch, vielleicht sollte ich ruhig sein
, es ergibt sich natürlich für jedes Element aus der langen Liste eine Worst-Case Laufzeit von O(log k), also wäre es O(n*log k + k) oder irgendwie sowas.
Anhang noch, damit sich keiner fragt wie ich auf das O(k) komme: Priority Queue => Extract-Min dauert O(1), also eine konstante Zeit. Da bei einem Fib-Heap die amortisierten Kosten (also wenn man eine Folge von x-Operationen betrachtet) pro Operation ebenfalls in O(1) liegen, und in dem Fib-Heap lediglich die k-Elemente drinnen liegen, dauert es am Ende also höchsten n-mal ein Extract-Min / Insert (und wir gehen ja nicht zurück) sowie k-mal das Extract-Min, wenn wir alles in einen Array schreiben. => O(n * log k + k) (oder so)
Folglich also O(1) * O(n) + O(1) * O(k) => O(1 * n + 1 * k) => O(1 * (n + k)) => O(n + k)
Wenn ich mich nicht vertan habe (und das will ich nicht ausschließen), dann liege ich mit der Annahme richtig, dass es in O(n + k) lösbar ist (nachdem ich, hier danke an Mars, unbedingt auf n * k log k hängen bleiben wollte
)
Das "Schöne" an AutoIt ist, dass obwohl wir mit einer doppelt verketteten Liste arbeiten müssen (gibt es in AutoIt die Möglichkeit? Ich hoffe.), wir dennoch schneller als Array Operationen sein sollten, da AutoIt Arrays sowieso nicht cache-friendly arbeiten.
€: Noch ein Anhang: Irgendwo muss in der Überlegung ein Fehler drinnen stecken, sonst wäre ja ein Sortieren über eine PQ innerhalb von O(n) Elementen möglich, nachweisbar ist es aber mindestens O(n * log n), da wir unterscheiden müssen.Ich überdenke das am Montag nochmal ;D
€2: Das Extract-Min dauert amortisiert immer noch log n. Demnach wäre es aber in O(n*log k) zu schaffen, was immer noch besser als O(n*k) sein sollte.
Du willst das Script über AutoIt ausführen, oder du willst es in AutoIt übersetzen und als AutoIt Quellcode haben?
knapp Faktor 100
Es ist eher Faktor 1k, zumindest beim 1. Durchgang.
Ich muss kurz fragen, erster und zweiter Durchgang: Ihr lasst das Script einmal, und direkt danach nochmal laufen? Bei mir gibt es dort nämlich keine Zeitdifferenz. Gibt es doch, Frage erübrigt sich.
Wäre dennoch durchaus interessant, wie man den Spaß umgehen kann.
Gut okay, da es sich mit den X Millisekunden um eine einmalige Zeit handelt, ist das durchaus egal für den weiteren Verlauf des Programms, aber schön ist es trotzdem nicht.