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

  • Domain Regex

    • AspirinJunkie
    • 5. August 2021 um 06:14
    Zitat von Banana_2_Day

    Kannst Du das Pattern so umschreiben, dass es unabhängig von einer Topleveldomain ist?

    Laut Wiki gibt es ca. 1500 Topleveldomains.

    Es sind sehr viele unterschiedliche Topleveldomains.

    Ja klar ist das möglich aber im Zweifel wackliger.
    Warum sieht man schön anhand deines Ausschnittes wo die Datei plusone.js genannt wird.
    Diese stellt von ihrer Form allein, so wie sie ist, eine gültige Domain dar.

    Sie ist es jedoch bekanntlich nicht und soll auch nicht gematcht werden, aber das ergibt sich für uns nicht aus deren Aufbau, sondern erst aus dem Kontext in welchem sie steht.

    Es gibt daher zwei Möglichkeiten:

    1. Da .js keine gültige TLD ist, kann man (wie bisher) die TLDs auf eine bestimmte Liste eingrenzen. Das sind ca. 1500 und man kann sich das Pattern immer topaktuell direkt von AutoIt damit zusammenbauen lassen. Wie @Musashi aber bereits schon anmerkte ist das Performance-mäßig nicht ganz die Wunschoption.
    2. Man fügt Kontext-Informationen hinzu. Also was darf vor der Domain stehen, was dahinter?
      Das hast du in deinem Vorschlag ja bereits getan wo du "gefolgt von / bzw. ##" vorgeschlagen hast.

    Nr. 2 habe ich mal umgesetzt: https://regex101.com/r/h4AaCM/6

  • Domain Regex

    • AspirinJunkie
    • 4. August 2021 um 18:10

    Die Abfrage selbst bleibt ja aber gleich, da sie ja in beiden Fällen funktioniert.
    Reicht das verlinkte Pattern für deinen Zweck?

  • Domain Regex

    • AspirinJunkie
    • 4. August 2021 um 17:38

    Warum zwei getrennte Abfragen?

    Mal schnell und etwas naiv rangegangen - aber so sollte das Prinzip klar bleiben und kann auch leicht angepasst werden.:

    regex101: build, test, and debug regex
    Regular expression tester with syntax highlighting, explanation, cheat sheet for PHP/PCRE, Python, GO, JavaScript, Java. Features a regex quiz & library.
    regex101.com

    Was meine ich mit "naiv"?:

    • ist aktuell auf feste Top-Level-Domains beschränkt (die du gerne erweitern kannst oder durch etwas variables ersetzen)
    • Umlaute und diakritische Zeichen sind prinzipiell auch (in Abhängigkeit von der Top-Level-Domain) erlaubt (Die IDN-Tabellen) - hier aber nicht.
  • Textdatei Datenbank Zeilenumbruch

    • AspirinJunkie
    • 2. August 2021 um 21:00

    Die Frage ob eine Datenbank wie SQLite hier sinnvoll wäre oder nicht können wir anhand des gezeigten gar nicht beurteilen.
    Für eine Datenbank müssen die Datensätze eine in sich wohnende feste Struktur haben.

    Das gezeigte Beispiel ist jedoch mal wieder herrlich unkonkret was komplett verhindert ableiten zu können wie man mit diesen Daten am besten umgeht.
    Da stehen nur durchnummerierte Datensatz-Header mit darauf folgenden variablen Anzahl an Textzeilen.
    Die Frage ist doch aber gibt es dort irgendeine inhaltliche Struktur? Gibt es dort eventuell bestimmte Attribute die jeden Datensatz beschreiben?

    Mit solchen nonsens-Beispielen kann man schlicht nicht adäquat Hinweise geben wie man damit umgeht.

    Zu deinem _ArrayDelete: Ja ist langsam weil bei einem einzelnen ArrayDelete alle Elemente die danach kommen einzeln nach vorne im Array verschoben werden müssen.
    Das dauert.
    Eventuell kann man versuchen mehrere Löschungen in einen Durchlauf unterzubringen so dass man nur einen Durchlauf braucht.
    Aber auch hier: Bitte ganz konkret am tatsächlichen Sachverhalt.

    Edit: Mal als ganz unkonkretes Beispiel wie ich das mit dem Delete in einem Durchlauf meinte:

    AutoIt
    #include<array.au3>
    
    Global Const $N = 1e4
    
    ; Array erstellen mit 1/3 leerer Werte, welche anschließend gelöscht werden sollen
    Global $aArray[$N]
    For $i = 0 To $N -1
        $aArray[$i] = Random(0, 2, 1) = 0 ? "" : "Wert " & $i+1
    Next
    _ArrayDisplay($aArray, "Array vorher")
    
    
    ; Alle leeren Werte aus dem Array löschen
    Global $iCounter = 0
    For $i = 0 To $N - 1
        If $aArray[$i] = "" Then
            $iCounter += 1
        Else
            $aArray[$i-$iCounter] = $aArray[$i]
        EndIf
    Next
    ReDim $aArray[$N - $iCounter]
    _ArrayDisplay($aArray, "Array nachher")
    Alles anzeigen
  • Kombinatorik UDF ArrayCombinations - Verschiedene Möglichkeiten der Zusammenstellung von Elementen einer Menge

    • AspirinJunkie
    • 29. Juli 2021 um 05:04

    Huch wie ist die denn da reingerutscht?
    Super- danke!

  • Kombinatorik UDF ArrayCombinations - Verschiedene Möglichkeiten der Zusammenstellung von Elementen einer Menge

    • AspirinJunkie
    • 28. Juli 2021 um 21:08

    Oh vielen Dank schonmal, dass du den Thread mit einem "offiziellem Beitrag" adelst.... :D

    Ja ich denke auch, dass man das bisschen von der mathematischen Ebene trennen muss.

    Die Kunst ist hierbei darauf zu kommen, dass das Problem, was man gerade zu lösen hat, thematisch damit zu tun hat.
    Deswegen habe ich im Titel ja auch etwas allgemeiner von "verschiedenen Zusammenstellungen von Elementen" geschrieben in der Hoffnung somit etwas weniger Abschreckung zu erzeugen.

  • Kombinatorik UDF ArrayCombinations - Verschiedene Möglichkeiten der Zusammenstellung von Elementen einer Menge

    • AspirinJunkie
    • 28. Juli 2021 um 10:13

    Letztens gab es mal wieder eine Aufgabe die grundlegend mit Kombinatorik gelöst werden konnte.
    Dabei ist mir mal wieder bewusst geworden, dass die beiden Kombinatorik-Funktionen in der Array.au3 _ArrayCombinations und _ArrayPermute offensichtlich ziemlich willkürlich rausgepickt wurden.
    Ebenso wichtige Spielarten der Kombinatorik wie Kombination mit Zurücklegen oder Variationen mit und ohne Zurücklegen werden davon überhaupt nicht abgedeckt.
    Darüber hinaus sind sie auch meiner Meinung nach wahnsinnig beknackt realisiert, denn die einzige Möglichkeit für deren Rückgabewert ist ein zusammengepappter String für jede Gruppe wo man dann selbst zusehen kann wie man wieder an die Einzelelemente kommt.

    Kurz - es war Zeit eine eigene UDF hierfür zu schreiben.
    Diese beinhaltet folgende Funktionen:

    Code
    _comb_Combinations                - ermittelt k Kombinationen aus n Elementen ohne Zurücklegen
    _comb_Combinations_Repetition     - ermittelt k Kombinationen aus n Elementen mit Zurücklegen
    _comb_Combinations_Repetition_All - ermittelt 1..k Kombinationen aus n Elementen mit Zurücklegen
    _comb_Permute                     - ermittelt alle Permutationen aus n Elementen ohne Zurücklegen
    _comb_Variations                  - ermittelt k Variationen aus n Elementen ohne Zurücklegen
    _comb_Variations_Repetition       - ermittelt k Variationen aus n Elementen mit Zurücklegen
    _comb_ArrayInArrayTo2D            - Hilfsfunktion um Array-In-Array-Konstrukte in ein 2D-Array zu konvertieren
    __comb_binomialcoefficient        - berechnet den Binomialkoeffizienten "n über k"
    __comb_factorial                  - berechnet die Fakultät "x!"
    _comb_Permute_restricted          - Spezialfall der Permutation bei der für jedes Element angegeben wird wo es stehen darf (Bsp: https://autoit.de/thread/87422-beschreibung-von-punkten-und-ihren-kanten-zu-anderen-punkten/?postID=704373#post704373)

    Beispiel zur Benutzung

    AutoIt
    #include "ArrayCombinations.au3"
    
    ; Das Elemente-Array:
        Global $aA[] = ["A", "B", "C", "D", "E", "F"]
    ; Größe der zu ziehenden Stichprobe:
        Global $k = 3
    
    ; Permutation (=Variation aller Elemente)
        $aPermutations = _comb_Permute($aA)
        _ArrayDisplay($aPermutations, "Alle Permutationen", "", 64)
    
    ; Kombinationen von k Elementen ohne Zurücklegen
        $aCombs = _comb_Combinations($aA, $k)
        _ArrayDisplay($aCombs, $k & "er-Kombinationen ohne Zurücklegen", "", 64)
    
    ; Kombinationen von k Elementen mit Zurücklegen
        $aCombsRep = _comb_Combinations_Repetition($aA, $k)
        _ArrayDisplay($aCombsRep, $k & "er-Kombinationen mit Zurücklegen", "", 64)
    
    ; Alle Kombinationen mit Stichprobengröße 1 bis k
        $aCombsRepAll = _comb_Combinations_Repetition_All($aA, $k)
        $aCombsRepAll2D = _comb_ArrayInArrayTo2D($aCombsRepAll)
        _ArrayDisplay($aCombsRepAll2D, "Alle Kombinationen bis " & $k & " Elemente", "", 64 )
    
    ; Variationen mit Zurücklegen
        $aVariations = _comb_Variations($aA, $k)
        _ArrayDisplay($aVariations, $k & "er Variationen ohne Zurücklegen", "", 64)
    
    ; Variationen ohne Zurücklegen
        $aVariationsRep = _comb_Variations_Repetition($aA, $k)
        _ArrayDisplay($aVariationsRep, $k & "er Variationen mit Zurücklegen", "", 64)
    Alles anzeigen

    Dateien

    ArrayCombinations.au3 10,74 kB – 449 Downloads
  • Script zur Ermittlung des passenden Gutscheins

    • AspirinJunkie
    • 26. Juli 2021 um 07:54
    Zitat von AspirinJunkie

    Wie gesagt das ist alles noch eher dahingerotzt.
    Man könnte das ganze ziemlich verschlanken wenn man eine Kombination mit Repetition implementiert.
    Mach ich bestimmt auch nochmal - da brauche ich aber bisschen den Kopf frei und ebenso bisschen Zeit.

    So wie versprochen hier noch die algorithmisch saubere Implementierung.
    Diese sollte auch deutlich fixer ablaufen, da nun jede zu betrachtende Kombination wirklich nur 1x vorkommt:

    AutoIt
    #include <GUIConstantsEX.au3>
    #include <Array.au3>
    
    #region Aufbereitung der Gutscheine
    Global $aGutscheine[][] = [ _ ;[Gutscheinwert in € | Zähler | Rabatt | Gutscheinart | Rabatt in %]
        [500, 0,   40, 3, 8.00], _
        [100, 0,    8, 3, 8.00], _
        [ 80, 0,    5, 2, 6.25], _
        [ 50, 0,    4, 3, 8.00], _
        [ 44, 0, 2.64, 1, 6.00], _
        [ 25, 0,    2, 2, 8.00], _
        [ 20, 0, 1.20, 1, 6.00], _
        [ 10, 0,  0.9, 2, 9.00], _
        [5.5, 0,  0.5, 2, 9.09], _
        [  5, 0,  0.3, 1, 6.00] ]
    
    ; Array mit den Indizes für einfacheres Kombinieren (einfach nur von 0...n)
    Local $aIndizes[UBound($aGutscheine)]
    For $i = 0 To UBound($aGutscheine) - 1
        $aIndizes[$i] = $i
    Next
    
    ; Alle möglichen Kombinationen (bis 3 Elemente) erzeugen und als Gruppen von Indizes auflisten:
    $aCombinations = _ArrayCombinations_Repetition_All($aIndizes, 3)
    #endregion
    
    #region GUI creation
    $Main = GUICreate("Main", 260, 135)
    
    GUICtrlCreateLabel("Startbetrag:", 10, 13, 110, 18)
    $startbetrag = GUICtrlCreateInput("", 10, 30, 100, 20)
    GUICtrlCreateLabel("Rabatt:", 10, 78, 100, 18)
    $rabatt = GUICtrlCreateInput("", 10, 95, 100, 20)
    GUICtrlCreateLabel("Endbetrag:", 150, 78, 80, 18)
    $endbetrag = GUICtrlCreateInput("", 150, 95, 100, 20)
    
    GUISetState()
    #endregion
    
    While 1
        Switch GUIGetMsg()
            Case $startbetrag
                Local $nZielBetrag = GUICtrlRead($startbetrag), $nRabatt, $nRabattMax = 0, $iRabattMaxIndex = 0, $nBetrag, $i = -1, $iRabattMaxN = 1e100
    
                ; Alle Kombinationen durchgehen und Endbetrag und Rabattsumme berechnen:
                For $aIndGroup In $aCombinations
                    $nBetrag = 0
                    $nRabatt = 0
                    $i += 1
    
                    ; Werte für die aktuelle Gutscheinkombi berechnen:
                    For $j In $aIndGroup
                        $nBetrag += $aGutscheine[$j][0]
                        If $nBetrag > $nZielBetrag Then ContinueLoop 2
                        $nRabatt += $aGutscheine[$j][2]
                    Next
    
                    ; falls aktuelle Kombi bisheriges Max an Rabatt erreicht hat - speichern
                    If $nRabatt >= $nRabattMax Then
                        ; bei gleichem Rabatt soll die Variante mit den wenigsten Gutscheinen verwendet werden:
                        If ($nRabatt = $nRabattMax) and ($iRabattMaxN >= UBound($aIndGroup)) Then ContinueLoop
                        $iRabattMaxIndex = $i ; für später damit man auch anzeigen kann welche Kombi genau fetzt
                        $nRabattMax = $nRabatt
                        $iRabattMaxN = UBound($aIndGroup)    ; Anzahl an Gutscheinen die hierfür nötig sind
    
                        GUICtrlSetData($endbetrag, $nZielBetrag - $nRabatt)
                        GUICtrlSetData($rabatt, $nRabatt)
                    EndIf
                Next
    
                ; Die Gutscheine ausgeben, welche man nehmen soll:
                $sOut = ""
                For $i In $aCombinations[$iRabattMaxIndex]
                    $sOut &= $aGutscheine[$i][0] & "€-Gutschein mit " & $aGutscheine[$i][2] & "€ Rabatt" & @CRLF
                Next
                MsgBox(0,"", $sOut)
    
            Case $GUI_EVENT_CLOSE
                Exit
        EndSwitch
    WEnd
    
    
    
    #region Hilfsfunktionen zur Erstellung aller möglichen Gutscheinkombinationen
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _ArrayCombinations_Repetition
    ; Description ...: all combinations of the elements of $aArray with $iK elements each with repetition of elements (unlike _ArrayCombinations)
    ;                  That means:
    ;                    - create groups of $iK elements (combination/variation - not! "permutation" )
    ;                    - the order of the elements is unimportant ("combination" - not! "variation")
    ;                    - inside the group an element can appear more than once ("repetition")
    ; Syntax ........: _ArrayCombinations_Repetition(ByRef $aArray, Const $iK)
    ; Parameters ....: $aArray   - 0-based 1D-Array with elements to combine
    ;                  $iK       - group size for results
    ; Return values .: Success - Return 2D-Array[...][$iK] where row = combination and columns = group elements 
    ;                  Failure - Return Null and set @error
    ; stolen from ...: https://rosettacode.org/wiki/Combinations_with_repetitions#C.2B.2B
    ; Author ........: AspirinJunkie
    ; Last changed ..: 2021-07-26
    ; =================================================================================================
    Func _ArrayCombinations_Repetition(ByRef $aArray, Const $iK)
        If UBound($aArray, 0) <> 1 Then Return SetError(1, UBound($aArray, 0), Null)
        If $iK < 1 Then Return SetError(2, $iK, Null)
    
        Local $iN = UBound($aArray) - 1
        Local $iNResults = _binomial_coefficient($iN + $ik, $iK)
        Local $aRet[$iNResults][$iK]
        Local $aInd[$iK + 1]
        Local $cR = 0
    
        Do
            ; determine indices for next combination set:
            For $i = 0 To $iK - 1
                If $aInd[$i] > $iN Then
                    $aInd[$i + 1] += 1
                    For $x = $i To 0 Step -1
                        $aInd[$x] = $aInd[$i + 1]
                    Next
                EndIf
            Next
    
            If $aInd[$iK] > 0 Then ExitLoop
    
            ; write current combination:
            For $i = 0 To $iK - 1
                $aRet[$cR][$i] = $aArray[$aInd[$i]]
            Next
            $cR += 1
    
            $aInd[0] += 1
        Until False
    
        Return SetExtended($cR, $aRet)
    EndFunc   ;==>_ArrayCombinations_Repetition
    
    ; _all combinations with repetition with all group sizes from 1 to $ik
    ; return array of arrays where elements = groups
    Func _ArrayCombinations_Repetition_All(ByRef $aArray, Const $iK)
        Local $iN = UBound($aArray), $iNResults = 0, $aTmp
    
        For $i = 1 To $iK
            $iNResults += _binomial_coefficient($iN + $i - 1, $i)
        Next
    
        Local $aRet[$iNResults], $iR = 0
    
        For $i = 1 To $iK
            $aTmp = _ArrayCombinations_Repetition($aArray, $i)
            Local $aGroup[$i]
            For $j = 0 To UBound($aTmp) - 1
                For $k = 0 To $i -1
                    $aGroup[$k] = $aTmp[$j][$k]
                Next
                $aRet[$iR]= $aGroup
                $iR += 1
            Next
        Next
    
        Return $aRet
    EndFunc
    
    ; calculates the binomial coefficient (n over k)
    ; note: might reach limit even if result might not
    ; so for large results use other approach
    Func _binomial_coefficient($n, $k)
        Local $res = 1
    
        If $k > ($n-$k) Then $k = $n-$k
    
        For $i = 0 To $k-1
            $res *= $n - $i
            $res /= $i + 1
        Next
    
        Return $res
    EndFunc   ;==>_binomial_coefficient
    
    #endregion
    Alles anzeigen

    Für mehrmaliges Berechnen kann man das Skript noch weiter optimieren indem man für alle Gutscheinkombis den Gesamtbetrag der Gutscheine und deren Rabattsumme einmalig berechnet und in ein Array abspeichert.
    Anschließend noch nach dem Betrag und dem Rabatt sortieren und die Suche dann als binäre Suche implementieren.
    Dann wird es richtig fix.

  • Script zur Ermittlung des passenden Gutscheins

    • AspirinJunkie
    • 23. Juli 2021 um 13:25
    Zitat von Inferior

    Prinzipiell liegen alle Gutscheine in unendlichfacher Anzahl vor. Einziges Nadelöhr ist, dass in Summe nur 3 Gutscheine verwendet werden können. Egal welche Höhe und welche Gutscheinart.

    Wie du sagst muss das Ausgangsarray nur verdreifacht werden und fertig.

    In meinem Skript oben einfach dazu nur Zeile 25 ändern zu For $j = 2 To 3.

    Und schon werden auch Kombinationen gefunden wo jeder Gutschein 3x vorkommen kann.

    Wie gesagt das ist alles noch eher dahingerotzt.
    Man könnte das ganze ziemlich verschlanken wenn man eine Kombination mit Repetition implementiert.
    Mach ich bestimmt auch nochmal - da brauche ich aber bisschen den Kopf frei und ebenso bisschen Zeit.

    Zitat von Inferior

    Ich vermute die Verwirrung kommt daher, dass ich im Array $aGutscheine in der Dimmension 3 (0 bis 4) = Gutscheinart die Zahlen 1 bis 3 angegeben habe. Dort könnte aber auch stehen: "grün, rot, blau"

    Das war jetzt nicht verwirrend.
    Mir war schon klar, dass die Art wohl etwas anderes angeben soll.
    Aus der Aufgabenstellung war aber nicht ersichtlich ob die Gutscheinanzahl jeweils variabel ist.
    Daher habe ich es gleich mit so implementiert und die Art einfach beispielhaft hierzu als Attribut missbraucht.

  • Script zur Ermittlung des passenden Gutscheins

    • AspirinJunkie
    • 23. Juli 2021 um 12:54
    Zitat von Inferior

    Die Auflistung aller möglichen Kombinationen ist nicht notwendig.

    Äh doch - über diese Liste iterieren wir ja bei der Ermittlung, welche Kombination die beste ist.

    Zitat von Inferior

    Was nun noch fehlt ist folgendes: Die Funktion _ArrayCombinations zieht nicht in Betracht, dass auch die gleichen Gutscheinkombinationen möglich wären:

    Doch wird in Betracht gezogen. Dies wird dadurch umgesetzt, dass Gutscheine, welche mehrmals vorliegen auch mehrmals im Array $aScheine vorkommen (bei mir habe ich ja als Anzahl für die Gutscheine die Art eingesetzt). Die anschließende Kombination darauf bringt dann auch Kombis bei welchem Gutscheine mehrmals verwendet werden.
    Gib z.B. mal als Startbetrag 250 ein und du wirst eine Lösung erhalt bei der der 100€-Gutschein 2x verwendet wird.

  • Script zur Ermittlung des passenden Gutscheins

    • AspirinJunkie
    • 23. Juli 2021 um 06:38

    Die Anzahl der Gutscheine ist hier ziemlich überschaubar.
    Daher ist es kein Problem einfach alle möglichen Gutscheinkombinationen zu ermitteln und diese einzeln durchzugehen.

    Welche Auswirkung die Art des Gutscheins hat habe ich aus deiner Erläuterung noch nicht verstanden - du wertest sie ja auch nicht in deinem Skript aus.
    Im folgenden Beispielskript habe ich die Art daher frecherweise einfach als Anzahl genommen wie oft der jeweilige Gutschein vorliegt.

    Im Grunde habe ich mal folgendes gemacht: Jeden Gutschein so oft er existiert als Einzelgutschein zum Gutscheinarray hinzugefügt.
    So dass ein Gutschein, welchen man 2x hat auch 2x im Array existiert.
    Dann habe ich von dieser Gutscheinliste alle möglichen Kombinationen (sowohl 1x, 2x, als auch 3x) erstellt.
    Das Ergebnisarray beinhaltet einfach nur die Indizes im Ausgangsarray.

    Dann muss man im Grunde nur noch diese Kombinationen durchgehen und schauen bei welcher Kombi der Rabatt am höchsten ist.

    Zugegeben: Es ist aktuell nur schnell dahingerotzt. Da kann/muss man noch deutlich im Code aufräumen.
    Alternativ könnte man auch die Kombinationserstellung auch direkt (so wie du) in den Berechnungsteil schieben aber da fehlt mir gerade die Zeit da eine clevere Kombinatorik bisschen nachdenken erfordert.
    Eventuell bringt es dich dennoch ein Stück weiter:

    AutoIt
    #include <GUIConstantsEX.au3>
    #include <Array.au3>
    
    Global $aGutscheine[][] = [ _ ;[Gutscheinwert in € | Zähler | Rabatt | Gutscheinart | Rabatt in %]
        [500, 0,   40, 3, 8.00], _
        [100, 0,    8, 3, 8.00], _
        [ 80, 0,    5, 2, 6.25], _
        [ 50, 0,    4, 3, 8.00], _
        [ 44, 0, 2.64, 1, 6.00], _
        [ 25, 0,    2, 2, 8.00], _
        [ 20, 0, 1.20, 1, 6.00], _
        [ 10, 0,  0.9, 2, 9.00], _
        [5.5, 0,  0.5, 2, 9.09], _
        [  5, 0,  0.3, 1, 6.00] ]
    
    ;~ _ArrayDisplay($aGutscheine, "", "", 64, "", "Gutscheinwert in € | Zähler | Rabatt | Gutscheinart | Rabatt in %")
    
    
    #Region Wenn mehrere Gutscheine einer Sorte existieren diese auch einzeln auflisten:
    Local $aScheine = $aGutscheine
    ReDim $aScheine[3 * UBound($aGutscheine)][UBound($aGutscheine, 2)] ; *3 = max, da jeder Gutschein max vorkommen kann
    Local $cAdd = UBound($aGutscheine)
    For $i = 0 To UBound($aGutscheine) - 1
        For $j = 2 To $aGutscheine[$i][3]
            For $k = 0 To UBound($aGutscheine, 2) - 1
                $aScheine[$cAdd][$k] = $aGutscheine[$i][$k]
            Next
            $cAdd += 1
        Next
    Next
    ReDim $aScheine[$cAdd][UBound($aScheine, 2)]
    #EndRegion
    
    #Region Auflistung aller möglichen Kombinationen erstellen:
    Local $aIndizes[UBound($aScheine)]
    For $i = 0 To UBound($aIndizes) - 1
        $aIndizes[$i] = $i
    Next
    Local $aTmp, $aCombinations = $aIndizes
    For $i = 2 To 3
        $aTmp = _ArrayCombinations($aIndizes, $i, "|")
        _ArrayDelete($aTmp, 0)
        _ArrayAdd($aCombinations, $aTmp)
    Next
    
    ;~ _ArrayDisplay($aCombinations)
    #EndRegion
    
    
    $Main = GUICreate("Main", 260, 135)
    
    GUICtrlCreateLabel("Startbetrag:", 10, 13, 110, 18)
    $startbetrag = GUICtrlCreateInput("", 10, 30, 100, 20)
    GUICtrlCreateLabel("Rabatt:", 10, 78, 100, 18)
    $rabatt = GUICtrlCreateInput("", 10, 95, 100, 20)
    GUICtrlCreateLabel("Endbetrag:", 150, 78, 80, 18)
    $endbetrag = GUICtrlCreateInput("", 150, 95, 100, 20)
    
    GUISetState()
    
    While 1
        Switch GUIGetMsg()
            Case $startbetrag
                Local $nZielBetrag = GUICtrlRead($startbetrag), $aIndizes, $nSum, $nRabatt, $nRabattMax = 0, $iRabattMaxIndex = 0, $nBetrag
    
                ; Alle Kombinationen durchgehen und Endbetrag und Rabattsumme berechnen:
                For $i = 0 To UBound($aCombinations) - 1
                    $nBetrag = 0
                    $nRabatt = 0
    
                    $aIndizes = StringSplit($aCombinations[$i], "|", 3)
                    For $j In $aIndizes
                        $nBetrag += $aScheine[$j][0]
                        $nRabatt += $aScheine[$j][2]
                    Next
                    If $nBetrag > $nZielBetrag Then ContinueLoop
    
                    If $nRabatt >= $nRabattMax Then
                        $iRabattMaxIndex = $i ; für später damit man auch anzeigen kann welche Kombi genau fetzt
                        $nRabattMax = $nRabatt
    
                        GUICtrlSetData($endbetrag, $nZielBetrag - $nRabatt)
                        GUICtrlSetData($rabatt, $nRabatt)
    
                    EndIf
                Next
                
                ; Die Gutscheine ausgeben, welche man nehmen soll:
                $sOut = ""
                For $i In StringSplit($aCombinations[$iRabattMaxIndex], "|", 3)
                    $sOut &= $aScheine[$i][0] & "€-Gutschein mit " & $aScheine[$i][2] & "€ Rabatt" & @CRLF
                Next
                MsgBox(0,"", $sOut)
    
            Case $GUI_EVENT_CLOSE
                Exit
        EndSwitch
    WEnd
    Alles anzeigen
  • StringRegExpReplace - Tool für Aktenprotkolle - bitte hilfe :)

    • AspirinJunkie
    • 20. Juli 2021 um 18:03

    Kann vieles bedeuten.
    Evtl. ist die Datei nicht xml konform.
    Oder ein falscher Dateipfad.

    Können wir halt nicht reproduzieren ohne konkretes Beispiel bei dem es scheitert.

    Zitat von MojoeB

    Ich verstehe auch nicht ganz wie er dann die richtige Zeile findet wenn es mehrere '/Data/LStatus' -> <Data><LStatus></LStatus></Data> Zeilen davon gibt.

    Das lässt sich entweder direkt über den >>XPath<< (das Konstrukt /Data/LStatus) filtern oder indem man mehrere Nodes auswählt und diese dann in einer Schleife durchläuft.

  • StringRegExpReplace - Tool für Aktenprotkolle - bitte hilfe :)

    • AspirinJunkie
    • 20. Juli 2021 um 05:34

    Die Daten liegen als XML formatiert vor und sollten daher am besten auch so behandelt werden.
    Sprich: Seh ich XML lass ich Finger von RegEx.

    Beispiel:

    AutoIt
    Local $o_XML = ObjCreate("Microsoft.XMLDOM")
    
    ; XML-Datei laden und als xml-DOM parsen:
    If Not $o_XML.load("Test.txt") Then Exit MsgBox(48, "Fehler", "Fehler beim Öffnen der Datei")
    
    ; Zweitens:
    $o_XML.SelectSingleNode('/Data/LStatus').text = "YES"
    
    ; Drittens:
    $o_XML.SelectSingleNode('/Data/LStatus').text = "Wait"
    $o_XML.SelectSingleNode('/Data/STATUS').text = "zurück im fach"
    $o_XML.SelectSingleNode('/Data/SBN').text = "neueSeriennummer"
    
    ; Änderungen an der Datei übernehmen:
    $o_XML.save("Test.txt")
    Alles anzeigen
  • Doppelte Einträge komplett aus Array löschen

    • AspirinJunkie
    • 18. Juli 2021 um 16:38
    AutoIt
    #include <Array.au3>
    
    Global $aArray[5] = ["Max","Felix","Felix","Kevin","Laura"]
    
    $aNeu = _ArrayDeleteDuplicates($aArray)
    
    _ArrayDisplay($aNeu)
    
    Func _ArrayDeleteDuplicates(ByRef $aArray)
        Local $oCount = ObjCreate("Scripting.Dictionary")
    
        For $i In $aArray
            $oCount($i) += 1
        Next
    
        Local $iR = 0, $aRet[UBound($aArray)]
        For $i In $aArray
            If $oCount($i) = 1 Then
                $aRet[$iR] = $i
                $iR += 1
            EndIf
        Next
    
        ReDim $aRet[$iR]
        Return $aRet
    EndFunc
    Alles anzeigen
  • Daten sortieren in Excel Tabelle

    • AspirinJunkie
    • 18. Juli 2021 um 13:19
    Zitat von 32vroni

    Gibt es eine Sortierfunktion für die Werte in Deiner UDF?

    Nun ja.
    Hab oben die UDF neu hochgeladen und das Beispiel angepasst.

  • Daten sortieren in Excel Tabelle

    • AspirinJunkie
    • 17. Juli 2021 um 08:58
    Zitat von 32vroni

    Im Ergebnis fehlt die erste Zeile von den Rohdaten ("Bestückung")

    Ja logisch. In deiner ersten Beispieldatei ging es mit der 3. Zeile los.
    In deinem Beispiel jetzt bereits ab der 2. Zeile.
    Das musst du natürlich entsprechend anpassen.

    Beim Schreiben ist mir aufgefallen, dass meine Lösung von oben als allgemeineres Problem gesehen werden kann - nämlich der Überführung von Dictinaries in ein Array.
    Ich habe daher für diesen Teil eine UDF gebastelt da ich dies bestimmt noch einmal gebrauchen kann.
    Damit wird das Skript bei dir auch gleich deutlich übersichtlicher (die DictionaryHelpers.au3 liegt im Anhang):

    AutoIt
    #include "DictionaryHelpers.au3"
    #include "xlsxNative.au3"
    
    ; Input-Array einlesen:
    $aDaten = _xlsx_2Array("BRD-Rohdaten.xlsx")
    
    ; Daten durchgehen und Übertragung der Daten in Key-Value-Struktur (Dictionary-Array $aDataSets)
    Global $sKategorie, $aDataSets[UBound($aDaten) - 1]
    For $iR = 1 To UBound($aDaten) - 1
        Local $oCur = ObjCreate("Scripting.Dictionary")
        $oCur.CompareMode = 1
    
        For $iC = 0 To UBound($aDaten, 2) - 2 Step 2
            $sKategorie = $aDaten[$iR][$iC]
    
            For $i = 1 To 1e100
                If Not $oCur.Exists($sKategorie & " " & $i) Then
                    $oCur($sKategorie & " " & $i) = $aDaten[$iR][$iC + 1]
                    ExitLoop
                EndIf
            Next
        Next
        $aDataSets[$iR - 1] = $oCur
    Next
    
    ; Daten nur anzeigen
    _dicDisplay($aDataSets, True)
    
    ; Daten in Excel exportieren:
    Local $aOut = _dic2Array($aDataSets, True)
    FileDelete("Out.xlsx")
    _xlsx_WriteFromArray("Out.xlsx", $aOut)
    Alles anzeigen

    Dateien

    DictionaryHelpers.au3 6,04 kB – 483 Downloads
  • Daten sortieren in Excel Tabelle

    • AspirinJunkie
    • 16. Juli 2021 um 10:51

    Ansonsten müsstest du mir mal Testdaten zukommen lassen damit ich schauen kann wo genau es klemmt.

    Zitat von 32vroni

    Das liegt offenbar am kaufmännischen Und &, welches in einer Zelle steht.

    Ja stimmt - die XML-Escapes baue ich noch schnell ein - die UDF update ich gleich entsprechend.

    Edit: Das &-Problem sollte nun behoben sein.

  • runwair java web launcher

    • AspirinJunkie
    • 16. Juli 2021 um 10:48

    Ja sollte - wenn Java sich halt überall wo es ausgeführt werden soll auch ordentlich in PATH eingetragen hat.

    Kleiner Tipp zu den Anführungszeichen in Strings: Es gibt zwei Zeichen für Strings in AutoIt womit man diese Dopplungen umgehen kann:

    AutoIt
    RunWait('"javaws.exe" "https://xyz.com:443/main/system/launch/client/test.jnlp"', @ScriptDir, @SW_HIDE)
  • runwair java web launcher

    • AspirinJunkie
    • 16. Juli 2021 um 10:25

    Java nistet seinen Pfad doch in der Regel in der "PATH"-Umgebungsvariable ein.

    Das heißt es sollte eigentlich auch funktionieren wenn du javaws.exe komplett ohne Pfadangabe schreibst.

    Kannst du gut von der Kommandozeile aus testen in dem du mal folgendes ausführst:

    Code
    where javaws.exe
  • Daten sortieren in Excel Tabelle

    • AspirinJunkie
    • 14. Juli 2021 um 21:49
    Zitat von 32vroni

    Ich weiß, wie oft jede der insgesamt 30 Bezeichnungen maximal vorkommt

    Wenn man diese Infos hat kann man es ziemlich simpel aber statisch umsetzen.
    Für den ganz konkreten Fall des Beispieles hier könnte es so umgesetzt werden:

    AutoIt
    #include <Array.au3>
    #include "xlsxNative.au3"
    
    ; Input-Array einlesen:
    $aDaten = _xlsx_2Array("M1.xlsx")
    
    Global $aOut[UBound($aDaten) - 1][16] = [["Bestückung 1", "Bestückung 2", "Bestückung 3", "Bestückung 4", "Bestückung 5", "Bestückung 6", "Bestückung 7", "Bestückung 8", "Sonstiges 1", "Sonstiges 2", "Sonstiges 3", "Sonstiges 4", "Sonstiges 5", "Sonstiges 6", "Sonstiges 7", "Sonstiges 8"]]
    Global $cB, $cS ; Zähler für aktuelle Bestückung und sonstiges
    
    For $iR = 2 To UBound($aDaten) - 1
        $cB = 0
        $cS = 0
    
        For $iC = 0 To 14 Step 2
            If $aDaten[$iR][$iC] = "Bestückung" Then
                $aOut[$iR - 1][$cB] = $aDaten[$iR][$iC + 1]
                $cB += 1
            Else
                $aOut[$iR - 1][$cS + 8] = $aDaten[$iR][$iC + 1]
                $cS += 1
            EndIf
        Next
    Next
    
    ; Output-xlsx schreiben:
    _xlsx_WriteFromArray("out.xlsx", $aOut)
    Alles anzeigen

    Für die Excel-Geschichten nehme ich hier einfach meine xlsxNative-UDF. Man kann aber natürlich jede andere UDF dafür nehmen.

    Spannender wird es aber wenn man die Bezeichnungen dynamisch haben möchte.
    Dann wird es etwas witziger bei der Umsetzung:

    AutoIt
    #include <Array.au3>
    #include "xlsxNative.au3"
    
    ; Input-Array einlesen:
    $aDaten = _xlsx_2Array("M1.xlsx")
    
    ; feste Liste an Kategorien (könnte man aber auch dynamisch aus den Daten ableiten)
    Global $aBezeichnungen[] = ["Bestückung", "Sonstiges"]
    
    ; Hilfslisten um für jede Kategorie die maximale Anzahl der Elemente sowie deren Indizes im Ausgabearray zu speichern:
    Global $oBezMax = ObjCreate("Scripting.Dictionary"), $oBezIndizes = ObjCreate("Scripting.Dictionary")
    $oBezMax.CompareMode = 1 ; damit Dictionary case insensitive arbeitet
    $oBezIndizes.CompareMode = 1
    
    ; Daten durchgehen und hierbei maximale Anzahl Elemente für jede Kategorie ermitteln
    ; außerdem Übertragung der Daten in Key-Value-Struktur (Dictionary-Array $aDataSets)
    Global $sKategorie, $aDataSets[UBound($aDaten) - 2]
    For $iR = 2 To UBound($aDaten) - 1
        Local $oCur = ObjCreate("Scripting.Dictionary")
        $oCur.CompareMode = 1
    
        For $iC = 0 To 14 Step 2
            $sKategorie = $aDaten[$iR][$iC]
            For $i = 1 To 1e100
                If Not $oCur.Exists($sKategorie & " " & $i) Then
                    $oCur($sKategorie & " " & $i) = $aDaten[$iR][$iC + 1]
                    If $i > $oBezMax($sKategorie) Then $oBezMax($sKategorie) = $i
                    ExitLoop
                EndIf
            Next
        Next
        $aDataSets[$iR - 2] = $oCur
    Next
    
    ; Anzahl der Ausgabespalten ermitteln umd Augabearray zu dimensionieren:
    Global $dCols = 0
    For $sBez In $aBezeichnungen
        $dCols += $oBezMax($sBez)
    Next
    Global $aOut[UBound($aDaten) - 1][$dCols]
    
    ; Header für Ausgabearray schreiben und Indizes für Bezeichnungen ermitteln:
    Global $iInd = 0
    For $sBez In $aBezeichnungen
        For $i = 1 To $oBezMax($sBez)
            $aOut[0][$iInd] = $sBez & " " & $i
            $oBezIndizes($sBez & " " & $i) = $iInd
            $iInd += 1
        Next
    Next
    
    ; Ausgabearray mit den Daten füllen
    Local $dIndex = 1
    For $oDataSet In $aDataSets
        For $sKey In $oDataSet.Keys
            $aOut[$dIndex][$oBezIndizes($sKey)] = $oDataSet($sKey)
        Next
        $dIndex += 1
    Next
    
    ; Output-xlsx schreiben:
    _xlsx_WriteFromArray("out.xlsx", $aOut)
    Alles anzeigen

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™