1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. AspirinJunkie

Beiträge von AspirinJunkie

  • isPressed("0D") geht nicht (ENTER)

    • AspirinJunkie
    • 20. November 2014 um 22:44

    @Andy
    Schmeiß mal die DllClose() noch mit in die Schleife.
    Wenn man dann noch, anstatt eine Durchschnittsdauer zu ermitteln, die Einzelwerte nimmt und in ein Diagramm abträgt, sieht man, dass der Zeitbedarf linear mit der Anzahl der offenen Handles ansteigt.
    Der benötigte Speicher des Skriptes steigt bei 100000 Durchläufen um gerade einmal 2,3mb an, wovon schonmal 0,76mb die Handles ausmachen sollten.
    Tja was ein vergessenes DllClose() nicht alles ausmacht...

    Der Argumentation, dass man durch Öffnen per DllCall die bereits geöffnete Dll umgeht kann ich daher nicht nachvollziehen.
    Wer sagt denn dass DllOpen die Dll komplett neu einliest anstatt die bereits im Speicher vorhandene zu nutzen?
    Und andersrum: Wer sagt, dass die Nutzung per String dies genau nicht tut?

    Alles deutet für mich darauf hin, dass beide im Falle einer bereits im Speicher befindlichen dll am Ende diese auch nutzen.
    Den Unterschied macht der Overhead. Wenn man das Handle einmalig per DllOpen bereits ermittelt hat, sind die Funktionszeiger schnell gesetzt.
    Nimmt man hingegen den Dateinamen, muss dieser jedesmal erst geparst werden, die Datei im Dateisystem ermittelt werden, dann muss gecheckt werden ob die Datei schon geöffnet ist ... etc. etc.
    Bei einem einmaligen DllOpen sind diese Schritte schon einmalig abgearbeitet weswegen die nachfolgenden Aufrufe fixer als die Dateinamensversion sind.
    Und dies spiegelt sich auch in den Ergebnissen wieder.

  • WinHttp und gzip

    • AspirinJunkie
    • 20. November 2014 um 19:46

    WinHTTP kann kein Gzip - WinInet schon: >>Klickmich<<
    Für WinInet gibt es auch schon eine UDF: >>WinINET.au3<<

    Edit: wie lesolutionneur schon schrieb...

  • Zahlen sortieren

    • AspirinJunkie
    • 20. November 2014 um 08:10
    Zitat von vism

    gibt es eine Möglichkeit die ganze Zahl zu vergleichen? Nicht nur die Stellen?

    Das Problem bei dir ist, dass die Elemente in deinem Array nicht vom Datentyp Zahl (Int oder Float/Double) sind sondern eine Zeichenkette (ein "String"). Also nichts weiter als ein normaler Text. Bei Strings wird zum Größenvergleich zeichenweise vorgegangen. Daher diese Sortierung wie bei dir.
    Eine Lösung wäre alle Elemente im Array vorher durchzugehen und per Number()-Funktion in einen Zahldatentyp zu wandeln oder du zeigst einfach mal wie dein Array überhaupt entsteht.

    Zitat von vism

    btw. Wie sortiere ich von groß nach klein? =(

    Hilfe zu _ArraySort() lesen.

  • Zahlen in Zahlwörter umwandeln

    • AspirinJunkie
    • 12. November 2014 um 21:11
    Zitat von Einexage

    Mein bisheriger Algorithmus zerlegt die Zahl in die einzelnen "Teilzahlen" und verknüpft die einzelnen Werte mit einem "und". Dann werden noch Ausnahmen beachtet und dann das Zahlwort ausgegeben. Geht das eventuell einfacher beziehungsweise sinnvoller?

    Ja

  • Datengrösse bei Filecopy der Copy ermitteln

    • AspirinJunkie
    • 12. November 2014 um 15:49

    FileCopy blockt das Skript bis der Kopiervorgang abgeschlossen ist.
    Zwischendurch kannst du also keinen Code ausführen, geschweige denn eine Progressbar aktualisieren.
    Es gibt daher Ansätze über das Shell-Objekt oder Windows-API-Funktionen.

    Ein anderer Ansatz ist es, selbst eine Kopierfunktion zu schreiben.
    Das ist ja prinzipiell nichts weiter als den Inhalt aus einer Datei zu lesen (hier blockweise) und in eine Zieldatei zu schreiben.
    Hier mal ein Beispiel (es ist noch eine Bremse eingebaut - wenn es produktiv eingesetzt werden soll die Zeile 50 auskommentieren):

    Copy mit Progressbar
    [autoit]

    #RequireAdmin

    [/autoit] [autoit][/autoit] [autoit]

    $Quelle = @SystemDir & '\taskmgr.exe'
    $Ziel = "C:\taskmgr.exe"

    [/autoit] [autoit][/autoit] [autoit]

    If _ProgressCopy($Quelle, $Ziel) Then MsgBox(0,"", "Kopiervorgang erfolgreich!")

    [/autoit] [autoit][/autoit] [autoit]

    Func _ProgressCopy($SourceFile, $DestinationFile)
    If Not FileExists($SourceFile) Then Return SetError(1,1,0)
    If $SourceFile == $DestinationFile Then Return SetError(2,2,0)

    [/autoit] [autoit][/autoit] [autoit]

    #region------------------------------------Declare Variables-------------------------------
    Local $ByteBlock, $Counter
    Local Const $BlockSize = Int(FileGetSize($SourceFile) / 99)
    Local Const $Opt = Opt("GUIOnEventMode", 0)
    Local $OpenHandle = FileOpen($SourceFile, 16)
    Local $WriteHandle = FileOpen($DestinationFile, 26)
    #endregion---------------------------------------------------------------------------------

    [/autoit] [autoit][/autoit] [autoit]

    If $OpenHandle = -1 Or $WriteHandle = -1 Then Return SetError(3,3,0)

    [/autoit] [autoit][/autoit] [autoit]

    #region------------------------------------GUI create--------------------------------------
    Local $GUI = GUICreate('', 400, 105, Default, Default, 0x80880000)
    Local $Label1 = GUICtrlCreateLabel($SourceFile, 8, 10)
    Local $Label2 = GUICtrlCreateLabel($DestinationFile, 8, 30)
    Local $Label3 = GUICtrlCreateLabel("0%", 360, 25, 30, 20, 0x2)
    Local $Button = GUICtrlCreateButton("Abbrechen", 160, 75, 80)
    Local $PBar = GUICtrlCreateProgress(8, 50, 384, 20)
    GUISetState()
    #endregion---------------------------------------------------------------------------------

    [/autoit] [autoit][/autoit] [autoit]

    #region----------------------------------Copy File-----------------------------------------
    Do
    $ByteBlock = FileRead($OpenHandle, $BlockSize)
    If @error Then ExitLoop
    FileWrite($WriteHandle, $ByteBlock)
    $Counter += 1
    GUICtrlSetData($PBar, $Counter)
    GUICtrlSetData($Label3, $Counter & ' %')

    [/autoit] [autoit][/autoit] [autoit]

    If GUIGetMsg() = $Button Then
    Opt("GUIOnEventMode", $Opt)
    FileClose($OpenHandle)
    FileClose($WriteHandle)
    GUIDelete($GUI)
    FileDelete($DestinationFile)
    Return SetError(4,4,0)
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    Sleep(20) ;Bremse - Auskommentieren für maximale Geschwindigkeit
    Until 0
    #endregion---------------------------------------------------------------------------------

    [/autoit] [autoit][/autoit] [autoit]

    Opt("GUIOnEventMode", $Opt)
    FileClose($OpenHandle)
    FileClose($WriteHandle)
    GUIDelete($GUI)
    Return 1
    EndFunc

    [/autoit]
  • OpenCl goes AutoIt Update 31.Dezember 2016

    • AspirinJunkie
    • 9. November 2014 um 19:23
    Zitat von Andy

    ...und muss zusätzlich nach dem Lesen des Output-Speicherbereichs noch alle Summen zusammenzählen.

    Nö bei einem richtigen Reduce-Kernel braucht man nichts mehr zusammenzählen. Das wurde ja schon im Kernel erledigt.

    Hier mal ein ausführlicher Artikel zu dem Thema: >>OpenCL Reduction<<

  • OpenCl goes AutoIt Update 31.Dezember 2016

    • AspirinJunkie
    • 9. November 2014 um 18:13

    Eine weitere Option wär der Reduce-Ansatz.
    Kann man prinzipiell mit allen assoziativen Operationen durchführen (Hier ist es die Addition).
    Dabei fängt man z.B. mit zwei benachbarten Threads an. Diese bilden gemeinsam eine Summe. Sie müssen also nur auf ihre beiden Threads warten - alle anderen schreiben ja auf eine andere Stelle und machen das parallel zu unseren ersten beiden.
    Dann wird die Summe der ersten beiden mit den von Thread 3-4 gebildet. Dann diese wieder mit Thread 5-8 usw.
    Bis am Ende nur ein Wert übrig bleibt.
    So kann man die Summe partiell parallel berechnen lassen und auf atomare Operationen verzichten.
    Man ist dann weiterhin schneller als die Summe seriell zu berechnen.

    Hier mal zur Verdeutlichung: >>http://web.engr.oregonstate.edu/~mjb/cs575/Handouts/opencl.reduction.2pp.pdf<<

  • AutoIt Sysinternal Tools Synchronizer v0.99.6 build 2020-09-23 beta

    • AspirinJunkie
    • 8. November 2014 um 23:07

    Ich wurde wohl etwas missverstanden.
    Ich wollte keineswegs keinen Contest zwischen komplexem GUI-Skript und Einzeiler-Batch starten.
    Mein Ansinnen war lediglich kurz darzulegen, dass ich meine Sysinternals-Sammlung ebenfalls per Skript aktuell halte - nur halt 100x profaner.

    @UEZ
    Ich mag dein Skript.
    Sorry das dein Thread durch meine Einlage ins OT driftete.

  • AutoIt Sysinternal Tools Synchronizer v0.99.6 build 2020-09-23 beta

    • AspirinJunkie
    • 7. November 2014 um 21:48

    Hm so schick kann man das also auch machen.
    Ich mach das einfach über eine Batch.
    Aber so schick ist es bei mir nicht (wget wird noch benötigt):

    Code
    wget --timestamping --no-directories --convert-links --accept=exe,chm,sys,hlp,cnt,dll --reject=htm,html --no-parent --recursive http://live.sysinternals.com/
  • String Problem

    • AspirinJunkie
    • 7. November 2014 um 12:19

    Lies dir doch mal die Hilfe zu den Befehlen durch.
    Willst du wissen ob _StringBetween geklappt hat, dann frag nicht dessen Rückgabewert ab, sondern @error.
    In deinem Fall hat _StringBetween übrigens nicht funktioniert.
    Interessanter wäre es daher statt $text mal $line in die Console auszugeben.

  • String Problem

    • AspirinJunkie
    • 7. November 2014 um 11:18

    Ein paar Fragen:

    Was möchtest du mit der Abfrage If @extended > 0 in Zeile 43 erreichen? Worauf bezieht sich das @extended?

    Was hast du mit der Variable $Text vor welche du in Zeile 33 definierst aber dann nicht mehr verwendest außer als zu schreibender Inhalt für die Listview (was heißt: du schreibst nichts in die ListView).

  • String Problem

    • AspirinJunkie
    • 7. November 2014 um 11:09

    Ein vollständiges Minimalbeispiel, dass jeder bei sich testen kann, wäre schonmal ein Anfang...
    Momentan ist es einfach nur sinnfrei.
    Da ist ein Exitloop wo keine Schleife ist, die zuvor als leer definierte Variable $text wird in ein Listview geschrieben, $file ist nicht defniert, von _ArrayDisplay wird @extended abgefragt obwohl @extended gar kein @extended setzt.
    etc... etc... etc...

  • Radix-Sort mit AutoIt

    • AspirinJunkie
    • 6. November 2014 um 13:23

    So habe jetzt auch noch die MSD-Variante implementiert. Einmal als unstable in-place Variante und einmal als stable nicht in-place Variante.

    Da es gerade irgendwie mit dem Thema zu tun hat: Die wohl coolste Software um die verschiedenen Sortieralgorithmen zu verstehen:
    >>The Sound of Sorting<<

  • Häufigkeit der Wörter in einem Array

    • AspirinJunkie
    • 6. November 2014 um 10:29

    Keine Ahnung wie du jetzt auf diese Funktion gekommen bist mit dem Suchbegriff "Modalwert".
    Hier halt vorgekaut (einzig die Anpassung auf ein 2D-Array musst du noch selbst übernehmen):

    Modalwert eines Arrays
    [autoit]

    #include <Array.au3>

    [/autoit] [autoit][/autoit] [autoit]

    Global $a_Array[] = ["Name1", "Name2", "Name3", "Name2", "Name3", "Name4", "Name2"]

    [/autoit] [autoit][/autoit] [autoit]

    Global $a_Max = _ArrayModalwert($a_Array, 1)
    _ArrayDisplay($a_Max, "Elemente mit maximalen Vorkommen")

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION# ======================================================================================
    ; Name ..........: _ArrayModalwert()
    ; Description ...: Bestimmt den Modalwert in einem Array
    ; Syntax ........: _ArrayModalwert(ByRef $a_Inp, Const[ $i_Start = 0, Const[ $s_Delim = "|"]])
    ; Parameters ....: ByRef $a_Inp - 1D-Array mit Stichprobenmenge
    ; Const $i_Start - [optional] Start Array-Index; gewöhnlich auf 0 oder 1 gesetzt (Standard = 0) (default:0)
    ; Const $s_Delim - [optional] Wenn "|" in den einzelnen Elementen vorkommt: ändern (default:"|")
    ; Return values .: Success: Array[0]: Anzahl an Vorkommen, Array[1..n]: häufigst vorgekommene Elemente
    ; Failure: Return 0 und setzt @error
    ; =================================================================================================
    Func _ArrayModalwert(ByRef $a_Inp, Const $i_Start = 0, Const $s_Delim = "|")
    Local $o_Dict = ObjCreate("Scripting.Dictionary")
    Local $i_CMax = 1, $i_C, $s_Mods
    ; Array durchgehen und Vorkommen von Werten zählen:
    If Not IsArray($a_Inp) Then Return SetError(1, 0, 0)
    For $x = $i_Start To UBound($a_Inp) - 1
    $o_Dict($a_Inp[$x]) += 1
    Next
    ; Werte mit maximalen Vorkommen ermitteln:
    For $i In $o_Dict.Keys
    $i_C = $o_Dict($i)
    If $i_C = $i_CMax Then
    $s_Mods &= $i & $s_Delim
    ElseIf $i_C > $i_CMax Then
    $i_CMax = $i_C
    $s_Mods = $i & $s_Delim
    EndIf
    Next
    Local $a_Return = StringSplit(StringTrimRight($s_Mods, 1), $s_Delim)
    $a_Return[0] = $i_CMax
    Return $a_Return
    EndFunc ;==>_ArrayModalwert

    [/autoit]
  • Häufigkeit der Wörter in einem Array

    • AspirinJunkie
    • 6. November 2014 um 08:05
    Zitat von DasIch

    Es sollen alle row's geprüft werden und einzig (!) der Name ausgegeben werden, welcher am Häufigsten in diesen row's vorkommt.

    Manchmal benötigt man nur den richtigen Suchbegriff.
    In deinem Fall dieser "Modalwert".
    Damit die Forensuche füttern und du findest Lösungen.
    Diese sind für 1D-Arrays aber, da dich eh nur eine bestimmte Spalte interessiert kannst du die Skripte ganz leicht entsprechend anpassen.

  • Wettbewerb (für Anfänger und Fortgeschrittene) ?

    • AspirinJunkie
    • 4. November 2014 um 22:12
    Zitat von Mars

    Vorallem ist der Mittelwert absolut nicht aussagekräftig. Im 1 Sigma intervall befindet sich nur zu 68% Wahrscheinlichkeit der tatsächliche Mittelwert. Wenn also Algo1 25.6 (+-3) und Algo2 26.5 (+-3.8) haben ist Algo1 nur mit einer gewissen wahrscheinlichkeit besser. (liegt nahe an 50% bei den Werten) Man kann also keinen Sieger bestimmen.

    Dafür gibt es statistische Tests.
    Wie man an deiner Grafik sehen kann, handelt es sich bei deinen ermittelten Mittelwerten um zufallsverteilte Werte.
    Die Frage die sich hierbei stellt ist: Kann die Differenz zwischen den beiden Mittelwerten aus deren Zufallsverteilung erklärt werden oder ist dies so unwahrscheinlich, dass eine systematische Ursache der Grund hierfür ist?
    Diese Frage kann über statistische Tests fundiert aufgelöst werden.
    Für den Fall, dass es sich um zwei normalverteilte Werte handelt welche verglichen werden sollen, kommt der Zweistichproben-t-Test in Frage.
    Ist deren Standardabweichung nicht gleich (über F-Test ermitteln) nimmt man den Welsh-Test.
    Liegt außerdem keine Normalverteilung vor (z.B. über Shapiro-Wilk-Test testbar), dann weicht man auf nichtparametrische Tests, wie dem U-Test, aus.

    Da hier aber gleich mehrere Stichproben verglichen werden sollen, müsste man wegen des Alpha-Kumulierungsfehlers aber eventuell noch die Anova bzw. den Kruskal-Wallis-Test bei Varianzinhomogenität oder den U-Test als nichtparametrische Alternative, in Betracht ziehen.

  • Radix-Sort mit AutoIt

    • AspirinJunkie
    • 4. November 2014 um 21:43
    Zitat von Andy

    aber war aufgrund der geringeren Geschwindigkeit im Vergleich zu Quicksort davon abgekommen.

    In der Theorie gibt es, vor allem bei großen Datenmengen, genügend Fälle in denen Radixsort dem Quicksort überlegen ist.

    Diese Implementierung hier kommt jedoch nur in sehr wenigen Fällen am Quicksort der _ArraySort vorbei. Bei aktiviertem Dual-Pivot-Quicksort sogar fast gar nicht.
    Das liegt aber weniger am Algorithmus als an der konkreten Implementierung.
    Für den Quicksort sind z.b. viele Größenvergleiche notwendig. Diese liegen in AutoIt für die Standardtypen nativ vor und sind daher verdammt fix.
    Für den Radixsort ist hingegen die Extraktion der n-ten Stelle der Werte essentiell. Dies liegt jedoch nicht nativ vor, sondern muss über AutoIt-Code realisiert werden.

    Jetzt könnte man sagen: Ok schön für die Theorie: Radixsort nun auch in Autoit und dann auch noch fast so schnell wie Dual-Pivot-Quicksort. lassen wir es dabei.
    Aber deine Geschichte von deiner Radixsort-Umsetzung in Assembler brachte mich zu der Überlegung: Wenn man die __dRadixUInt() in Assembler umsetzen könnte und in das Skript integrieren kann, dann könnte man vielleicht wirklich eine Sortierungsfunktion erhalten welche in vielen Fällen die _ArraySort schlägt.

    Vielleicht versuche ich mich aber auch nochmal an einer MSD-Radix-Umsetzung um zu schauen wie diese sich verhält.


    Zitat von Andy

    Wenn man Zahlen in Hex-Darstellung schreibt, kann man sie auch mit einem abgewandelten __dRadixString (0123456789ABCDEF) sortieren. Auch BigINT.Mir ist zwar keine Anwendung für sortierte BigINT bekannt, aber das hat ja nichts zu sagen.

    Die __dRadixUInt und die __dRadixString (die nicht lexikographisch sortiert!) waren ja nur Beispiele.
    Hab die Funktion bewusst ausgelagert um eben nicht nur auf die Standardtypen beschränkt zu sein. Durch kleine Anpassungen kann man mit der Funktion auch komplexere Datentypen wie Arrays in Arrays, DllStructs oder COM-Objekte sortieren. Die _ArraySort ist hingegen auf die Grundtypen beschränkt (weswegen ich in meine Dynarray-UDF auch eine Sort-Funktion mit austauschbarer Vergleichsfunktion reingenommen habe).

  • Radix-Sort mit AutoIt

    • AspirinJunkie
    • 4. November 2014 um 16:31

    Die üblichen Sortieralgorithmen beruhen auf direkten Größenvergleichen zwischen zwei Elementen.
    Mathematisch kann man beweisen, dass man hiermit jedoch auf ein Laufzeitverhalten von n*log(n) beschränkt ist.
    Auch _ArraySort unterliegt dieser Beschränkung. Dennoch ist sie durch die (optionale) Verwendung des Dual-Pivot-Quicksorts und der Verwendung von Insertionsort für kleine Teilarrays sehr nahe an einem möglichen Optimum.

    Dennoch stellt sich die Frage: Gibt es denn trotzdem Alternativen?: Jein
    Ein Algorithmus welcher nicht auf Größenvergleichen beruht ist Radix-Sort.
    Sein Grundansatz ist ein anderer: Alle Werte werden stellenweise betrachtet. Man beginnt mit der ersten Stelle und schmeißt alle Zahlen entsprechend ihrem Stellenwert in einen bestimmten Topf. Hat man das gemacht fügt man alle Töpfe in der Reihe ihres Stellenwertes wieder aneinander.
    Dann wiederholt man das Spielchen für die restlichen Stellen.
    Am Ende liegen die Werte sortiert vor. (Genauere Beschreibungen siehe google)

    Nun die Frage: Warum wurde dieses Verfahren bisher noch nicht in AutoIt implementiert?
    Das liegt einerseits an der Beschränkung der zu sortierenden Datentypen.
    Der Sortierschlüssel der Werte muss aus "Zeichen eines endlichen Alphabets" bestehen (Zitat Wikipedia ;-).
    Vorzeichenlose Integer sind ein Beispiel hierfür, oder auch Objekte mit einem UInt als Sortierungsschlüssel.

    Auf der anderen Seite benötigt man schnelle dynamische Datenstrukturen für die Zwischenspeicherung.
    AutoIt-Arrays waren dafür schlicht nicht geeignet.
    Mit dem Map-Datentyp der aktuellen Betas steht nun aber eine derartige Struktur zur Verfügung.
    Das brachte mich dazu den RadixSort nun auch einmal in Autoit zu implementieren:

    RadixSort in AutoIt (benötigt AutoIt-Version &gt; 3.3.13.6)
    [autoit]

    #include <Array.au3>

    [/autoit] [autoit][/autoit] [autoit]

    ; ################### Random-Array erstellen ######################
    Global Const $nEl = 1e3 ; Anzahl Elemente
    Global Const $dMaxEl = 1e5 - 1 ; Wertebereich
    Global $ARnd[$nEl]
    For $i = 0 To $nEl - 1
    $ARnd[$i] = Random(0, $dMaxEl, 1)
    Next
    _ArrayDisplay($ARnd, "unsortiert")
    ; -----------------------------------------------------------------

    [/autoit] [autoit][/autoit] [autoit]

    $t = $ARnd
    $iT = TimerInit()
    _ArraySort($t)
    ConsoleWrite(StringFormat("% 30s: %8.3f ms\n", "_ArraySort", TimerDiff($iT)))

    [/autoit] [autoit][/autoit] [autoit]

    $t = $ARnd
    $iT = TimerInit()
    _ArrayRadixSortLSD($t, __dRadixUInt)
    ConsoleWrite(StringFormat("% 30s: %8.3f ms\n", "_ArrayRadixSortLSD", TimerDiff($iT)))

    [/autoit] [autoit][/autoit] [autoit]

    $t = $ARnd
    $iT = TimerInit()
    _ArrayRadixSortMSD_Stable($t, __dRadixUInt)
    ConsoleWrite(StringFormat("% 30s: %8.3f ms\n", "_ArrayRadixSortMSD_Stable", TimerDiff($iT)))

    [/autoit] [autoit][/autoit] [autoit]

    $t = $ARnd
    $iT = TimerInit()
    _ArrayRadixSortMSD($t, __dRadixUInt)
    ConsoleWrite(StringFormat("% 30s: %8.3f ms\n", "_ArrayRadixSortMSD", TimerDiff($iT)))

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION# ======================================================================================
    ; Name ..........: _ArrayRadixSortLSD
    ; Description ...: sort an array with radix-sort (LSD=Least significant digit)
    ; Syntax ........: _ArrayRadixSort(ByRef $A, Const $F, [$N = Default])
    ; Parameters ....: $A - the array which should be sorted (by reference means: direct manipulating of the array - no copy)
    ; $F - a function which defines the datatype/digit-system of the array-values (see an example for deeper details)
    ; $N - the maximum number of value-digits (if Default then evaluate this value from array - slower)
    ; Return values .: Success: True - array is sorted now
    ; Failure: False
    ; @error = 1: $A is'nt an array
    ; 2: invalid value for $F
    ; Author ........: AspirinJunkie
    ; Related .......: AutoIt-version > 3.3.13.6
    ; Remarks .......: see Wikipedia for an explanation for which data you can use it
    ; =================================================================================================
    Func _ArrayRadixSortLSD(ByRef $A, Const $F, $N = Default)
    Local $i, $t, $nn, $u, $rn = 0
    Local Const $iMax = UBound($A) - 1

    [/autoit] [autoit][/autoit] [autoit]

    ; error-handling:
    If Not IsArray($A) Then Return SetError(1, 0, False)
    If Not IsFunc($F) Then Return SetError(2, 0, False)

    [/autoit] [autoit][/autoit] [autoit]

    ; evaluate the maximum number of digits:
    If $N = Default Then
    $N = 1
    For $i = 0 To $iMax
    If $N < $F($A[$i]) Then $N = $F($A[$i])
    Next
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    ; get the digit order definition:
    Local Const $O = $F()

    [/autoit] [autoit][/autoit] [autoit]

    ; create the bucket holders:
    Local $m[], $r[] ; $m = the temporary bucket-holder, $r = the already sorted bucket holder

    [/autoit] [autoit][/autoit] [autoit]

    ; sorting!:
    For $d = 1 To $N
    ; create (and empty) buckets:
    For $i In $O
    Dim $t[]
    $m[String($i)] = $t
    Dim $t[]
    $r[String($i)] = $t
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; sort into the buckets related to the current digit:
    For $i = $rn To $iMax
    $t = $A[$i]
    $u = $F($t, $d)
    If @extended Then
    MapAppend($r[$u], $t)
    Else
    MapAppend($m[$u], $t)
    EndIf
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; convert back to array (merge the buckets to the array):
    ; at first add the already sorted elements:
    For $k In $O
    $t = $r[String($k)]
    $nn = UBound($t) - 1
    For $e = 0 To $nn
    $A[$rn] = $t[$e]
    $rn += 1
    Next
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; now add the leftover elements:
    $i = $rn
    For $k In $O
    $t = $m[String($k)]
    $nn = UBound($t) - 1
    For $e = 0 To $nn
    $A[$i] = $t[$e]
    $i += 1
    Next
    Next
    Next

    [/autoit] [autoit][/autoit] [autoit]

    Return True
    EndFunc ;==>_ArrayRadixSortLSD

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION# ======================================================================================
    ; Name ..........: _ArrayRadixSortMSD
    ; Description ...: sort an array with radix-sort (MSD=Most significant digit)
    ; this implementation is stable(maintain the relative order of records with equal keys) but not in-place
    ; Syntax ........: _ArrayRadixSortMSD(ByRef $A, Const $F, [$N = Default, [$iMin = 0, [$iMax = UBound($A) - 1, {$d = Default, {Const $b_First = True}}]]])
    ; Parameters ....: $A - the array which should be sorted (by reference means: direct manipulating of the array - no copy)
    ; $F - a function which defines the datatype/digit-system of the array-values (see an example for deeper details)
    ; $N - the maximum number of value-digits (if Default then evaluate this value from array - slower)
    ; $iMin - start index for the array-range which should be sorted
    ; $iMax - end index for the array-range which should be sorted
    ; $d - Don't touch! - internal parameter which defines the actual radix
    ; $b_First - Don't touch! - internal parameter for recognize if actual function call is the begin of the recursion
    ; Return values .: Success: True - array is sorted now
    ; Failure: False
    ; @error = 1: $A isn't an array
    ; 2: invalid value for $F
    ; 3: $A isn't a 1D-Array
    ; 4: wrong value for $iMin
    ; 5: wrong value for $iMax
    ; 6: wrong combination of $iMin and $iMax
    ; Author ........: AspirinJunkie
    ; Related .......: AutoIt-version > 3.3.13.6
    ; Remarks .......: see Wikipedia for an explanation for which data you can use it
    ; =================================================================================================
    Func _ArrayRadixSortMSD(ByRef $A, ByRef Const $F, $N = Default, $iMin = 0, $iMax = UBound($A) - 1, $d = Default, Const $b_First = True)
    Local $count[], $pos, $j, $c, $u, $t
    Local Const $dLen = $iMax - $iMin ; Array-Size

    [/autoit] [autoit][/autoit] [autoit]

    If $b_First Then
    ; error-handling:
    If Not IsArray($A) Then Return SetError(1, 0, False) ; no array
    If Not IsFunc($F) Then Return SetError(2, 0, False) ; no function
    If UBound($A, 0) <> 1 Then Return SetError(3, 0, 0) ; no 1D-array
    If Not IsInt($iMin) Or $iMin < 0 Then Return SetError(4, $iMin, False) ; wrong value in $iMin
    If Not IsInt($iMax) Or $iMax > UBound($A) - 1 Then Return SetError(5, $iMin, False) ; wrong value in $iMax
    If $iMin > $iMax Then Return SetError(6, $iMax - $iMin, False) ; wrong combination of $iMin and $iMax

    [/autoit] [autoit][/autoit] [autoit]

    ; evaluate the maximum number of digits:
    If $N = Default Then
    $N = 1
    For $i = 0 To $iMax
    If $N < $F($A[$i]) Then $N = $F($A[$i])
    Next
    EndIf
    $d = $N
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    ; get the digit order definition:
    Local Const $O = $F()

    [/autoit] [autoit][/autoit] [autoit]

    ; reset the maps for the digit counter
    For $i In $O
    $count[String($i)] = 0
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; count for every digit how much elements are in it:
    For $i = $iMin To $iMax
    $count[$F($A[$i], $d)] += 1
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; calculate the positions of digit-area start in the result-array (=partial sum):
    $pos = $count
    For $i = 1 To UBound($O) - 1
    $pos[String($O[$i])] = $count[String($O[$i])] + $pos[String($O[$i - 1])]
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; reorder items:
    $i = 0
    Do
    While 1
    $u = $F($A[$iMin + $i], $d)
    $pos[$u] -= 1
    $j = $pos[$u]
    If $j <= $i Then ExitLoop
    ; swap A[iMin + i] <-> A[iMin + j]
    $c = $A[$iMin + $i]
    $A[$iMin + $i] = $A[$iMin + $j]
    $A[$iMin + $j] = $c
    WEnd
    $i += $count[$F($A[$iMin + $i], $d)]
    Until $i >= $dLen

    [/autoit] [autoit][/autoit] [autoit]

    If $d < 2 Then Return True

    [/autoit] [autoit][/autoit] [autoit]

    ; recursivly sort digit-related subarrays:
    $u = $iMin
    For $i In $O
    $c = $count[String($i)]
    If $c > 1 Then _ArrayRadixSortMSD($A, $F, $N, $u, $u + $c - 1, $d - 1, False)
    $u += $c
    Next
    Return True
    EndFunc ;==>_ArrayRadixSortMSD2

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION# ======================================================================================
    ; Name ..........: _ArrayRadixSortMSD_Stable
    ; Description ...: sort an array with radix-sort (MSD=Most significant digit)
    ; this implementation is stable(maintain the relative order of records with equal keys) but not in-place
    ; Syntax ........: _ArrayRadixSortMSD_Stable(ByRef $A, Const $F, [$N = Default, [$iMin = 0, [$iMax = UBound($A) - 1, {$d = Default, {Const $b_First = True}}]]])
    ; Parameters ....: $A - the array which should be sorted (by reference means: direct manipulating of the array - no copy)
    ; $F - a function which defines the datatype/digit-system of the array-values (see an example for deeper details)
    ; $N - the maximum number of value-digits (if Default then evaluate this value from array - slower)
    ; $iMin - start index for the array-range which should be sorted
    ; $iMax - end index for the array-range which should be sorted
    ; $d - Don't touch! - internal parameter which defines the actual radix
    ; $b_First - Don't touch! - internal parameter for recognize if actual function call is the begin of the recursion
    ; Return values .: Success: True - array is sorted now
    ; Failure: False
    ; @error = 1: $A isn't an array
    ; 2: invalid value for $F
    ; 3: $A isn't a 1D-Array
    ; 4: wrong value for $iMin
    ; 5: wrong value for $iMax
    ; 6: wrong combination of $iMin and $iMax
    ; Author ........: AspirinJunkie
    ; Related .......: AutoIt-version > 3.3.13.6
    ; Remarks .......: see Wikipedia for an explanation for which data you can use it
    ; =================================================================================================
    Func _ArrayRadixSortMSD_Stable(ByRef $A, ByRef Const $F, $N = Default, $iMin = 0, $iMax = UBound($A) - 1, $d = Default, Const $b_First = True)
    Local Static $aAux[0]
    Local $count[], $j, $iOld, $c, $p, $u, $t
    Local Const $dLen = $iMax - $iMin ; Array-Size

    [/autoit] [autoit][/autoit] [autoit]

    ; error-handling:
    If Not IsArray($A) Then Return SetError(1, 0, False)
    If Not IsFunc($F) Then Return SetError(2, 0, False)

    [/autoit] [autoit][/autoit] [autoit]

    If $b_First Then
    ; error-handling:
    If Not IsArray($A) Then Return SetError(1, 0, False) ; no array
    If Not IsFunc($F) Then Return SetError(2, 0, False) ; no function
    If UBound($A, 0) <> 1 Then Return SetError(3, 0, 0) ; no 1D-array
    If Not IsInt($iMin) Or $iMin < 0 Then Return SetError(4, $iMin, False) ; wrong value in $iMin
    If Not IsInt($iMax) Or $iMax > UBound($A) - 1 Then Return SetError(5, $iMin, False) ; wrong value in $iMax
    If $iMin > $iMax Then Return SetError(6, $iMax - $iMin, False) ; wrong combination of $iMin and $iMax

    [/autoit] [autoit][/autoit] [autoit]

    ReDim $aAux[UBound($A)]
    ; evaluate the maximum number of digits:
    If $N = Default Then
    $N = 1
    For $i = 0 To $iMax
    If $N < $F($A[$i]) Then $N = $F($A[$i])
    Next
    EndIf
    $d = $N
    EndIf
    ; get the digit order definition:
    Local Const $O = $F()

    [/autoit] [autoit][/autoit] [autoit]

    ; reset the maps for the digit counter and start-positions
    For $i In $O
    $count[String($i)] = 0
    Next
    $pos = $count

    [/autoit] [autoit][/autoit] [autoit]

    ; count for every digit how much elements are in it:
    For $i = $iMin To $iMax
    $count[$F($A[$i], $d)] += 1
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; calculate the positions of digit-area start in the result-array (=partial sum):
    For $i = 1 To UBound($O) - 1
    $pos[String($O[$i])] = $count[String($O[$i - 1])] + $pos[String($O[$i - 1])]
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; iterate through the array and put the elements in their digit-related part of the result-array:
    For $i = $iMin To $iMax
    $t = $A[$i]
    $u = $F($t, $d)
    $aAux[$pos[$u]] = $t
    $pos[$u] += 1
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; transfer changes to input array
    For $i = $iMin To $iMax
    $A[$i] = $aAux[$i - $iMin]
    Next

    [/autoit] [autoit][/autoit] [autoit]

    ; sort the digit-related-subarrays recursively
    If $d > 0 Then
    For $i In $O
    $c = $count[String($O[$i])]
    $p = $pos[String($O[$i])] + $iMin - $c
    If $c > 1 Then _ArrayRadixSortMSD_Stable($A, $F, $N, $p, $p + $c - 1, $d - 1, False)
    Next
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    If $b_First Then ReDim $aAux[0]
    Return True
    EndFunc ;==>_ArrayRadixSortMSD_Stable

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION# ======================================================================================
    ; Name ..........: __dRadixUInt
    ; Description ...: return the nth digit of an value / return the number of digits of a value / return the digit order definition array
    ; Syntax ........: __dRadixUInt([Const $v = Default, [Const $N = Default]])
    ; Parameters ....: $v - the value which should be analysed
    ; $N - the digit position which should be extracted from the value
    ; Return values .: this is an multi-functional function. It's return value depends on the parameter-combination:
    ; $v and $N is setted - return the nth digit of $v
    ; only $v is setted - return the number of digits of $v
    ; nothing is setted - return the digit order definition array
    ; @extended = 1 - if $N = the last digit (help speed up RadixSort)
    ; Author ........: AspirinJunkie
    ; Related .......: _ArrayRadixSort()
    ; =================================================================================================
    Func __dRadixUInt(Const $v = Default, Const $N = Default)
    Local Static $aRet[10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    Local Const $d = StringLen($v)
    If $v = Default Then Return $aRet ; return digit order definition
    If $N = Default Then Return $v = 0 ? 0 : $d ; return the number of digits of $value
    If $N = $d Then Return SetExtended(1, StringLeft($v, 1))
    Return $N > $d ? "0" : StringLeft(StringRight($v, $N), 1) ; return the nth digit of $value
    EndFunc ;==>__dRadixUInt

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION# ======================================================================================
    ; Name ..........: __dRadixString
    ; Description ...: return the nth digit of an String / return the number of digits of a value / return the digit order definition array
    ; Syntax ........: __dRadixString([Const $v = Default, [Const $N = Default]])
    ; Parameters ....: $v - the value which should be analysed
    ; $N - the digit position which should be extracted from the value
    ; Return values .: this is an multi-functional function. It's return value depends on the parameter-combination:
    ; $v and $N is setted - return the nth digit of $v
    ; only $v is setted - return the number of digits of $v
    ; nothing is setted - return the digit order definition array
    ; @extended = 1 - if $N = the last digit (help speed up RadixSort)
    ; Author ........: AspirinJunkie
    ; Related .......: _ArrayRadixSort()
    ; =================================================================================================
    Func __dRadixString(Const $v = Default, Const $N = Default)
    Local Static $aRet[26] = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
    Local Const $d = StringLen($v)
    If $v = Default Then Return $aRet ; return digit order definition
    If $N = Default Then Return $v = "" ? 0 : $d ; return the number of digits of $value
    If $N = $d Then Return SetExtended(1, StringLeft($v, 1))
    Return $N > $d ? "0" : StringLeft(StringRight($v, $N), 1) ; return the nth digit of $value
    EndFunc ;==>__dRadixString

    [/autoit]
  • alle Möglichkeiten der Zeichenreihenfolge eines Strings

    • AspirinJunkie
    • 2. November 2014 um 10:12
    Zitat von Alina

    Dabei kommen doppelte Kombinationen vor. Sollte man das nicht beachten, der der Frage, der vorkommenden Kombinatioen?

    Daher haben wir ja gefragt welchen Anwendungsfall das Ganze haben soll.
    Und hierfür ist dieser Ansatz sowieso prinzipiell ungeeignet, weswegen ich ja noch eine Alternative gepostet habe.
    Wenn du es dennoch so machen willst musst du lediglich noch ein _ArrayUnique() hintendran hängen um deinen Fall mit beachten.

  • alle Möglichkeiten der Zeichenreihenfolge eines Strings

    • AspirinJunkie
    • 30. Oktober 2014 um 18:23

    Wir hatten vor geraumer Zeit mal eine optimierte Lösung für das Lösen von Anagrammen erstellt (über eine effektive Wörterbuchabfrage).
    Der Thread ist beim Servercrash im Sommer aber leider verloren gegangen.
    Wenn du mal ein Beispiel gibst, schreib ich es dir aber schnell neu.

    Der naive Ansatz über Permutationen führt eher nicht zum Ziel.

    Edit: O.k. hab mich mal rangesetzt:
    Benötigt wird: Eine Wörterbuchdatei (findet man im Netz oder >>hier<<)

    Grundidee: Man sortiere das Anagramm zeichenweise. Ist ein Wort eine Variation des Anagramms, dann ist dessen Sortierergebnis, das selbe wie beim Anagramm. Nun geht man eine Liste möglicher Wörter durch, sortiert diese jeweils zeichenweise und kann sie so mit dem Anagramm vergleichen.

    Nun zum Skript:

    Anagramm-Finder
    [autoit]

    ; Das Anagramm:
    Global $s_Anagramm = "lrahaso"

    [/autoit] [autoit][/autoit] [autoit]

    ; Wörterbuchdatei:
    Global Const $s_DicPath = "wörter.txt"

    [/autoit] [autoit][/autoit] [autoit]

    Global $s_Line, $s_Sorted
    Global $h_File = FileOpen($s_DicPath)
    If $h_File = -1 Then Exit MsgBox(48, "Fehler", "Konnte Wörterbuchdatei nicht öffnen")

    [/autoit] [autoit][/autoit] [autoit]

    ; Das Anagramm sortieren:
    Global Const $s_AnaSorted = CharSort($s_Anagramm)
    Global Const $s_AnaLen = StringLen($s_AnaSorted)

    [/autoit] [autoit][/autoit] [autoit]

    ; Wörterbuch durchgehen und auf Anagramm hin überprüfen:
    Do
    If StringLen($s_Line) = $s_AnaLen Then
    If $s_AnaSorted == CharSort($s_Line) Then MsgBox(0, "Fund", $s_Line)
    EndIf
    $s_Line = FileReadLine($h_File)
    Until @error
    FileClose($h_File)

    [/autoit] [autoit][/autoit] [autoit]

    ; sort the chars of a string with insertion-sort
    Func CharSort(ByRef $s_String)
    ; by AspirinJunkie
    Local $a_Chars = StringSplit($s_String, "", 2)
    Local $T1, $T2, $s_Ret = ""
    Local Const $n = UBound($a_Chars) - 1
    For $i = 0 To $n
    $T1 = $a_Chars[$i]
    For $j = $i - 1 To 0 Step -1
    $T2 = $a_Chars[$j]
    If $T1 >= $T2 Then ExitLoop
    $a_Chars[$j + 1] = $T2
    Next
    $a_Chars[$j + 1] = $T1
    Next
    For $i = 0 To $n
    $s_Ret &= $a_Chars[$i]
    Next
    Return $s_Ret
    EndFunc ;==>CharSort

    [/autoit]

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™