Quelle: https://www.autoitscript.com/forum/topic/17…comment-1282689
For the number of tabs you can go to the Options menu, select Open User Options File and put buffers=xx into it where xx is the number of buffers you want, the max is 100.
As to the Stop Executing command, not sure if that's changeable because it's a SciTE default if I remember correctly.
das Zauberwort hier ist "Normalisierung" 
besser gesagt: die 3. Normalform ist Standard
Aber auch wenn wir zwei mit unseren Lösungen keinen Blumentopf gewinnen, zeigt es doch recht schön, wie man in AutoIt Tempo erzeugen oder eben auch nicht erzeugen kann.
Mir hat es auf jeden Fall was gebracht.
Ich hoffe dir auch.
Beim nächsten mal reißen wir die Hütte ein
sry, hatte nur drüber geflogen.
So wie es für mich aussieht ist die Bremse die jeweilige While Schleife. Ohne es jetzt nachgerechnet zu haben...
Kann es sein, dass du in der While immer -1 rechnest für jedes Zeichen, bis $End erreicht?
Dass sind dann schon viele Schleifendurchläufe. Ich denke dass ist die Bremse
ich hab nach 5 Minuten abgebrochen und 1x durchlaufen lassen. Dabei habe ich (muss ich fairerweise zugeben ^^) die Zeit nicht gemessen sondern nur geschätzt.
Ich kan bei einem Durchlauf auf geschätzte 0,5 Sekunden.
Da ich den Test 10 * 2000 mal = 20000 mal laufen lasse um einen Mittelwert zu erhalten, wären das geschätzt 10000 Sekunden geworden.
Das sind 166,66 Minuten was ca, 2,7 Std. entspräche.
Deine Messung hat genauere 7450 Sekunden ergeben, die mein Test gelaufen wäre.
Für die Ungenauigkeit entschuldige ich mich selbstverständlich. Nach deiner Messung wäre das Script nur 2,07 Std. gelaufen.
Ich denke die _ArrayAdd-Aufrufe machen dein Script so langsam.
Ich bin ja dem selben Irrtum unterlegen und hatte es auch mit Arrays versucht.
Ich danke allen Teilnehmern, dass sie sich so für diese Runde
des Hackathon-Wettbewerb begeistert haben. 
Es zeigt, dass hier sehr helle Köpfe am Werk sind.
und nun zum Testverfahren:
getestet wurde auf einer HP Z440 Workstation ohne Netzwerk
Intel(R) Xeon(R) CPU E5-1620 v4 @ 3.50GHz mit 64 GB RAM
Die eingereichten Funktionen wurden jeweils 10 * mit 2000 Durchläufen getestet (32-bit und 64-bit, auf Anregung von UEZ ;-)),
und die Ergebnisse gemittelt. Während der Tests wurde der PC nicht verwendet oder sonst irgendwie CPU-technisch belastet.
Testergebnis:
Anzahl Teilnehmer: 8 (alphabetisch sortiert)
Anzahl gewerteter Lösungen: 7
| Teilnehmer | 32-bit Ergebnis in Sekunden | 64-bit Ergebnis in Sekunden |
| AspirinJunkey | 5.7189838 | 5.32926829 |
| chesstiger | 6.74941181 | 6.48062599 |
| Eukalyptus | 7.18151855 | 6.42435041 |
| Kanashius | 6.93677436 | 6.46164125 |
| Mars | 5.831345 | 5.41359282 |
| Moombas | abgebrochen, da 10*2000 Durchläufe ca. 2,7 Std. gedauert hätten | |
| Schnuffel | 27.23534696 | 25.91358436 |
| UEZ | 6.67757466 | 6.2812514 |
Daraus ergibt sich:
1. AsprinJunkey
2. Mars
3. UEZ
4. chesstiger
5. Kanashius
6. Eukalyptus
7. Schnuffel
8. Moombas (aufgrund der extremen Laufzeit aus der Wertung genommen)
Hier die eingereichten Lösungen und wie ich getestet habe:
#AutoIt3Wrapper_UseX64=Y
#cs ****************** AutoIt Hackathon 2025 / 2 ******************
Kategorie: Teil 2 - String-Manipulation
Schwierigkeit: Level II
Aufgabe: "CypherEnigma"
Aufwand: 1 - 2 Std. (geschätzt)
Lerninhalt: In dieser Aufgabe geht es um die Erstellung von Arrays, den "zero-based Index", das "schleifen" durch Arrays, eine "umlaufende" Zählung durch Arrays und ASCII-Zeichen.
Die Vereinfachung durch Globale Variablenerstellung, das Auslagern von Operationen in eigene Funktionen und vielleicht auch um die Nutzung von "Modulo" ;-)
Die Aufgabe wurde bewusst relativ einfach gehalten und würde so nicht als Verschlüsselung nutzen.
Es geht hier mehr darum, die Aufgabe korrekt zu verstehen und umzusetzen. Dabei sind "alle" Anmerkungen in der Aufgabe wichtig!
Aufgabe: Erstelle eine Funktion, die als Input 5 Parameter übernimmt und eine verschlüsselte Zeichenkette zurückgibt
Parameter 1: (String mit ASCII-Zeichen (theoretisch Dec 0 - Dec 255)) als Steuerzeichen werden ausschließlich "HT", "LF" & "CR" enthalten sein!
Parameter 2: ($nKlein als Zahl) Verschiebefaktor für Kleinbuchstaben
Parameter 3: ($nGross als Zahl) Verschiebefaktor für Großbuchstaben
Parameter 4: ($nSonder als Zahl) Verschiebefaktor für Sonderzeichen (ASCII 32 - 126 außer Klein- und Großbuchstaben)
Parameter 5: ($nExtra als Zahl) allgemeiner Verschiebefaktor, n-tes Zeichen in Parameter 1 * $nExtra
Alle nicht betrachteten ASCII-Zeichen werden unverändert übernommen.
Der Verschiebefaktor kann auch größer als die Anzahl Zeichen der entsprechenden Zeichengruppe sein! (Beispiel $nKlein=155)
Für jedes Zeichen des übergebenen Strings ist die Verschiebung in der entsprechenden Zeichengruppe vorzunehmen.
Dabei wird als Verschiebung der feste Verschiebeparameter der Gruppe ($nKlein, $nGross, $nSonder) plus
dem Extra Verschiebungsfaktor $nExtra, der sich mit jedem angewandten Zeichen mit sich selbst addiert angewendet wird.
z. B. das 3te Zeichen in Param1: ("u") wird um die Summe der Verschiebefaktoren ($nKlein + ($nExtra + $nExtra + $nExtra)) auf die Gruppe Kleinbuchstaben angewendet.
Wenn das Ende der Zeichengruppe erreicht ist, wird am Anfang wieder begonnen und weiter verschoben.
Alle Texte werden als String übergegeben.
Steuerzeichen, Zahlen und die ASCII Zeichen jenseits von Dec 126 werden 1:1 übernommen
Prüfung: Die Funktion _Check() beinhaltet die Prüfungsdatensätze und für jeden Text einen Hash der Lösung
Die Ausgabe zeigt an, wie viele der Texte korrekt verschlüsselt wurden
Sobald dein Script 100% korrekte Texte verschlüsselt hat, poste dein Script im Thread
Sieger: Gewonnen hat der Teilnehmer, dessen Funktion alle 7 Texte korrekt verschlüsselt und
2000 Durchläufe der Test-Texte in der kürzesten Zeit verschlüsselt
PS: Zusätzliche Funktionen und Globale Variablen können erstellt werden, müssen aber im Lösungspost mit angegeben werden.
Es gilt der Code-Block, der im Thread als Antwort gepostet wird.
Als einzige Vorgabe für das Script wird die Funktion samt Namen und Paremeterübernahme vorgegeben.
Diese ist unten ersichtlich, muss so verwendet werden und aus dieser muss das Ergebnis als Return erfolgen.
Die Verwendung von #includes ist gestattet, müssen aber im Script mit angegeben werden!
#ce ****************** AutoIt Hackathon 2025 / 2 ******************
Global $Teilnehmer = ""
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (UEZ): 32-bit: 9.06163702 s | 64bit: 7.96252668 s
; um dein Script zu überprüfen, drücke "F5"
; ===== dein Code-Block ab hier =====
Global $sonder = "", $slen
For $j = 32 To 126
If Not (($j > 64 And $j < 91) Or ($j > 96 And $j < 123)) Then
$sonder &= Chr($j)
EndIf
Next
$slen = StringLen($sonder)
;ConsoleWrite(_Check() & @CRLF)
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
#cs
Kleinbuchstaben: a (97) bis z (122)
Großbuchstaben: A (65) bis Z (90)
Sonderzeichen: ASCII 32–126, ohne Buchstaben
Steuerzeichen + ASC > 126: z.B. HT (ASCII 9), LF (10), CR (13) → unverändert übernehmen
#ce
Local $Return, $i, $c, $a, $t, $pos, $newPos
Local $iLen = StringLen($sString)
For $i = 1 To $iLen
$c = StringMid($sString, $i, 1)
$a = Asc($c)
Switch $a
Case 65 To 90 ;Großbuchstaben
$Return &= Chr(65 + (Mod($a - 65 + $nGross + ($i * $nExtra), 26)))
Case 97 To 122 ;Kleinbuchstaben
$Return &= Chr(97 + (Mod($a - 97 + $nKlein + ($i * $nExtra), 26)))
Case 32 To 64, 91 To 96, 123 To 126 ;Sonderzeichen ohne Buchstaben
$pos = StringInStr($sonder, $c, 1)
$newPos = Mod(($pos - 1 + $nSonder + ($i * $nExtra)), $slen)
$Return &= StringMid($sonder, $newPos + 1, 1)
Case Else ;Steuerzeichen oder > 126
$Return &= $c
EndSwitch
Next
Return $Return
EndFunc ;==>_CypherEnigma
; ===== dein Code-Block bis hier =====
#ce Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (UEZ): 9.96199453 s Zeilen: 28
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (UEZ 2.0): 32-bit: 7.58049067 s | 64bit: 7.3450835 s
Global $timer = TimerInit()
;Sonderzeichen
Global $sonder = "", $aSonder[44], $slen = 43, $i = 1, $j
For $j = 32 To 126
If Not (($j > 64 And $j < 91) Or ($j > 96 And $j < 123)) Then
$aSonder[$i] = Chr($j)
$sonder &= $aSonder[$i]
$i += 1
EndIf
Next
;ConsoleWrite(_Check() & @CRLF)
;ConsoleWrite(TimerDiff($timer) & @CRLF)
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
#cs
Kleinbuchstaben: a (97) bis z (122)
Großbuchstaben: A (65) bis Z (90)
Sonderzeichen: ASCII 32–126, ohne Buchstaben
Steuerzeichen + ASC > 126: z.B. HT (ASCII 9), LF (10), CR (13) → unverändert übernehmen
#ce
Local $Return, $i, $a, $t, $pos, $newPos, $aString = StringSplit($sString, ""), $iLen = $aString[0]
For $i = 1 To $iLen
$a = Asc($aString[$i])
Switch $a
Case 65 To 90 ;Großbuchstaben
$Return &= Chr(65 + (Mod($a - 65 + $nGross + ($i * $nExtra), 26)))
Case 97 To 122 ;Kleinbuchstaben
$Return &= Chr(97 + (Mod($a - 97 + $nKlein + ($i * $nExtra), 26)))
Case 32 To 64, 91 To 96, 123 To 126 ;Sonderzeichen ohne Buchstaben
$pos = StringInStr($sonder, $aString[$i], 1)
$newPos = Mod(($pos - 1 + $nSonder + ($i * $nExtra)), $slen)
$Return &= $aSonder[$newPos + 1]
Case Else ;Steuerzeichen oder > 126
$Return &= $aString[$i]
EndSwitch
Next
Return $Return
EndFunc ;==>_CypherEnigma
#ce
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (UEZ 3.0): 32-bit: 6.67757466 s | 64bit: 6.2812514 s
#cs
Kleinbuchstaben: a (97) bis z (122)
Großbuchstaben: A (65) bis Z (90)
Sonderzeichen: ASCII 32–126, ohne Buchstaben
Steuerzeichen + ASC > 126: z.B. HT (ASCII 9), LF (10), CR (13) → unverändert übernehmen
#ce
Global $timer = TimerInit()
;Sonderzeichen
Global $aSonder[44], $mapSonder[127], $aChar[128], $slen = 43, $i = 1, $j
For $j = 31 To 127
If Not(($j > 64 And $j < 91) Or ($j > 96 And $j < 123)) And $j > 31 And $j < 127 Then
$aSonder[$i] = Chr($j)
$mapSonder[Asc($aSonder[$i])] = $i
$i += 1
EndIf
$aChar[$j] = Chr($j)
Next
;ConsoleWrite(_Check() & @CRLF)
;ConsoleWrite(TimerDiff($timer) & @CRLF)
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
Local $Return, $i, $a, $t, $pos, $newPos, $aString = StringSplit($sString, ""), $iLen = $aString[0]
For $i = 1 To $iLen
$a = Asc($aString[$i])
Switch $a
Case 65 To 90 ;Großbuchstaben
$Return &= $aChar[65 + (Mod($a - 65 + $nGross + ($i * $nExtra), 26))]
Case 97 To 122 ;Kleinbuchstaben
$Return &= $aChar[97 + (Mod($a - 97 + $nKlein + ($i * $nExtra), 26))]
Case 32 To 64, 91 To 96, 123 To 126 ;Sonderzeichen ohne Buchstaben
$pos = $mapSonder[$a]
$newPos = Mod(($pos - 1 + $nSonder + ($i * $nExtra)), $slen)
$Return &= $aSonder[$newPos + 1]
Case Else ;Steuerzeichen oder > 126
$Return &= $aString[$i]
EndSwitch
Next
Return $Return
EndFunc ;==>_CypherEnigma
#ce
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (chesstiger): 32-bit: 6.74941181 s | 64bit: 6.48062599 s
Func _CypherEnigma($sInput, $nLower, $nUpper, $nSpecial, $nExtra)
$a = StringToASCIIArray($sInput)
For $i = 0 To UBound($a) - 1
If $a[$i] >= 97 And $a[$i] <= 122 Then
$a[$i] = Mod($a[$i] + $nLower + ($i + 1) * $nExtra - 97, 26) + 97
ElseIf $a[$i] >= 65 And $a[$i] <= 90 Then
$a[$i] = Mod($a[$i] + $nUpper + ($i + 1) * $nExtra - 65, 26) + 65
ElseIf $a[$i] >= 32 And $a[$i] <= 126 Then
$a[$i] -= (($a[$i] > 64) + (($a[$i] - 26) > 96)) * 26
$a[$i] = Mod($a[$i] + $nSpecial + ($i + 1) * $nExtra - 32, 43) + 32
$a[$i] += (($a[$i] > 64) + (($a[$i] + 26) > 96)) * 26
EndIf
Next
Return StringFromASCIIArray($a)
EndFunc ;==>_CypherEnigma
#ce Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (chesstiger): 7.74971565 s Zeilen: 15
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (Mars): 32-bit: 5.831345 s | 64bit: 5.41359282 s
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
Local $Return
Local Static $mKlein[], $mGross[], $mSonder[], $mKleinInv[], $mGrossInv[], $mSonderInv[], $uK, $uG, $uS
If Not UBound($mKlein) Then
For $i = 0 To 255 Step 1
Switch $i
Case 97 To 122
$mKlein[UBound($mKlein)] = $i
Case 65 To 90
$mGross[UBound($mGross)] = $i
Case 32 To 126
$mSonder[UBound($mSonder)] = $i
EndSwitch
Next
For $i = 0 To UBound($mKlein) - 1 Step 1
$mKleinInv[$mKlein[$i]] = $i
Next
For $i = 0 To UBound($mGross) - 1 Step 1
$mGrossInv[$mGross[$i]] = $i
Next
For $i = 0 To UBound($mSonder) - 1 Step 1
$mSonderInv[$mSonder[$i]] = $i
Next
$uK = UBound($mKlein)
$uG = UBound($mGross)
$uS = UBound($mSonder)
EndIf
Local $aSplit = StringToASCIIArray($sString)
For $i = 0 To UBound($aSplit) - 1 Step 1
Switch $aSplit[$i]
Case 97 To 122
$Return &= Chr($mKlein[Mod($mKleinInv[$aSplit[$i]] + $nKlein + ($i + 1) * $nExtra, $uK)])
Case 65 To 90
$Return &= Chr($mGross[Mod($mGrossInv[$aSplit[$i]] + $nGross + ($i + 1) * $nExtra, $uG)])
Case 32 To 126
$Return &= Chr($mSonder[Mod($mSonderInv[$aSplit[$i]] + $nSonder + ($i + 1) * $nExtra, $uS)])
Case Else
$Return &= Chr($aSplit[$i])
EndSwitch
Next
Return $Return
EndFunc ;==>_CypherEnigma
#ce
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (Kanashius): 32-bit: 6.93677436 s | 64bit: 6.46164125 s
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
Local $arLetters = StringToASCIIArray($sString)
Local $iExtra = $nExtra
For $i=0 To UBound($arLetters)-1 Step 1
Local $iCode = $arLetters[$i]
If $iCode>64 And $iCode<91 Then
$iCode = 65 + Mod($iCode + $nGross + $iExtra - 65, 26)
ElseIf $iCode>96 And $iCode<123 Then
$iCode = 97 + Mod($iCode + $nKlein + $iExtra - 97, 26)
ElseIf $iCode>31 And $iCode<127 Then
$iCode -= 32
If $iCode>32 Then $iCode-=26
If $iCode>38 Then $iCode-=26
$iCode = Mod($iCode + $nSonder + $iExtra, 43) + 32
If $iCode>64 Then $iCode+=26
If $iCode>96 Then $iCode+=26
EndIf
$arLetters[$i] = $iCode
$iExtra += $nExtra
Next
;ConsoleWrite(StringFromASCIIArray($arLetters)&@crlf)
Return StringFromASCIIArray($arLetters)
EndFunc ;==>_CypherEnigma
#ce
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (AspirinJunkey): 32-bit: 5.7189838 s | 64bit: 5.32926829 s
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
; [einmalig] Sonderzeichenbereiche auf einen fortlaufenden Bereich abbilden und Lookup-Arrays erstellen
Local Static $aSH = StringToASCIIArray(BinaryToString("0x0000000000000000000000000000000000000000000000000000000000000000000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20000000000000000000000000000000000000000000000000000021222324252600000000000000000000000000000000000000000000000000002728292A")), _
$aSZ = StringToASCIIArray(" !""#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~")
Local $i = 0, $iC, $iOffZ = 0, $aAR = StringToASCIIArray($sString), $j = UBound($aAR) - 1
If $nExtra = 0 Then
; wenn $nExtra = 0, dann vermeide die Mods (geht auch bei $nExtra <> 0 aber da ist es aufwendiger und bringt keinen messbaren Performancesprung)
; normalisiere die Offsets
$nKlein = Mod($nKlein, 26)
$nGross = Mod($nGross, 26)
$nSonder = Mod($nSonder, 43)
Local $nKleinMin = $nKlein - 26, $nGrossMin = $nGross - 26, $nSonderMin = $nSonder - 43, $mC[], $iOld
For $i = 0 To $j
$iC = $aAR[$i]
; ignoriere Zeichen außerhalb des relevanten Bereiches
If $iC - 32 > 94 Then ContinueLoop
; wenn ein Zeichen bereits prozessiert wurde - nutze das bereits berechnete Ergebnis
If MapExists($mC, $iC) Then
$aAR[$i] = $mC[$iC]
ContinueLoop
EndIf
$iOld = $iC
Switch $iC
Case 97 To 122
; Kleinbuchstaben
$iC += ($iC + $nKlein > 122) ? $nKleinMin : $nKlein
Case 65 To 90
; Großbuchstaben
$iC += ($iC + $nGross > 90) ? $nGrossMin : $nGross
Case Else
; Sonderzeichen
$iC = $aSH[$iC]
$iC = $aSZ[$iC + ($iC + $nSonder > 42 ? $nSonderMin : $nSonder)]
EndSwitch
$aAR[$i] = $iC
$mC[$iOld] = $iC
Next
Else
; $nExtra <> 0
For $i = 0 To $j
$iOffZ += $nExtra
$iC = $aAR[$i]
; ignoriere Zeichen außerhalb des relevanten Bereiches
If $iC > 126 Or $iC < 32 Then ContinueLoop
Switch $iC
Case 97 To 122
; Kleinbuchstaben
$iC = Mod($iC - 97 + $nKlein + $iOffZ, 26) + 97
Case 65 To 90
; Großbuchstaben
$iC = Mod($iC - 65 + $nGross + $iOffZ, 26) + 65
Case Else
; Sonderzeichen
$iC = $aSZ[Mod($aSH[$iC] + $nSonder + $iOffZ, 43)]
EndSwitch
$aAR[$i] = $iC
Next
EndIf
Return StringFromASCIIArray($aAR)
EndFunc ;==>_CypherEnigma
#ce
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (Schnuffel): 32-bit: 27.23534696 s | 64-bit: 25.91358436 s
Global $aKlein[26][2], $aGross[26][2], $aSonder[43][2], $nSonderCount = 0
For $i = 0 To 25 ; Array's für Groß und Kleinbuchstaben erstellen
$aKlein[$i][0] = $i + 97
$aKlein[$i][1] = Chr($i + 97)
$aGross[$i][0] = $i + 65
$aGross[$i][1] = Chr($i + 65)
Next
For $i = 32 To 126 ; Array für alle Sonderzeichen (inkl. Zahlen) Asc(32) - Asc(126) erstellen
Switch $i
Case 32 To 64, 91 To 96, 123 To 126
$aSonder[$nSonderCount][0] = $i
$aSonder[$nSonderCount][1] = Chr($i)
$nSonderCount += 1
EndSwitch
Next
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra = 0)
Local $Return, $nShift, $Asc, $ZielIndex
Local $aString = StringSplit($sString, '')
For $i = 1 To $aString[0] ; jedes Zeichen prüfen in welchem Array es vorkommt und an welcher Stelle, verschieben und an Return anhängen
$Asc = Number(Asc($aString[$i])) ; Eingabezeichen in Asc umwandeln
Switch $Asc ; Zeichengruppe auswählen
Case 32 To 64, 91 To 96, 123 To 126 ; Sonderzeichen und Zahlen
$Return &= _ShiftArray($aSonder, $Asc, $nSonder, $i * $nExtra)
ContinueLoop
Case 65 To 90 ;Großbuchstaben
$Return &= _ShiftArray($aGross, $Asc, $nGross, $i * $nExtra)
ContinueLoop
Case 97 To 122 ;Kleinbuchstaben
$Return &= _ShiftArray($aKlein, $Asc, $nKlein, $i * $nExtra)
ContinueLoop
Case Else
$Return &= $aString[$i]
EndSwitch
Next
Return $Return
EndFunc ;==>_CypherEnigma
Func _ShiftArray($aArray, $nAsc, $nShift, $nExtra)
For $k = 0 To UBound($aArray)
If $nAsc = $aArray[$k][0] Then ExitLoop ; $k ist der Index des Source Element aus dem Array
Next
Local $ZielIndex = Mod($k + $nShift + $nExtra, UBound($aArray)) ; neuer Index
Return $aArray[$ZielIndex][1] ; verschobenes neues Zeichen zurückgeben
EndFunc
#ce
#cs Moombas abgebrochen, da jeder Durchgang ca. 0,5 Sek dauerte. bei 10 * 2000 wären das 10000 Sek. = 2Std. 46 Min.
#include<Array.au3>
Global $aSonder[] = []
For $Row = 32 to 126
Switch $Row
Case 32 to 64 ;special characters 1
_ArrayAdd($aSonder, $Row)
Case 91 to 96 ;special characters 2
_ArrayAdd($aSonder, $Row)
Case 123 to 126 ;special characters 3
_ArrayAdd($aSonder, $Row)
EndSwitch
Next
$aSonder[0] = Ubound($aSonder, $UBOUND_ROWS)-1
Func _CypherEnigma(Const $sString, $nKlein, $nGross, $nSonder, $nExtra)
Local $Return, $ASCII
Local Const $aArray = Stringsplit($sString, '')
For $Row = 1 to $aArray[0]
$ASCII = ASC($aArray[$Row])
Switch $ASCII
Case 32 to 64, _
91 to 96, _
123 to 126 ;special characters
$Return &= _Shift_Sonder($nSonder, $Row * $nExtra, $ASCII)
Case 65 to 90 ;Upper Case
$Return &= _Shift( 65, 90, $nGross , $Row * $nExtra, $ASCII)
Case 97 to 122 ;lower case
$Return &= _Shift( 97, 122, $nKlein , $Row * $nExtra, $ASCII)
Case Else ;rest stays like they are
$Return &= $aArray[$Row]
EndSwitch
Next
Return $Return
EndFunc ;==>_CypherEnigma
Func _Shift(Const $Start, $End, $Shift, $Extra, $Data)
Local $Return = $Data + $Shift + $Extra
While $Return > $End
$Return = $Return - ($End - $Start) - 1
WEnd
Return Chr($Return)
Endfunc
Func _Shift_Sonder(Const $Shift, $Extra, $Data)
Local $Return = _ArraySearch($aSonder, $Data) + $Shift + $Extra
While $Return > $aSonder[0]
$Return = $Return - ($aSonder[0])
WEnd
Return Chr($aSonder[$Return])
Endfunc
#ce
#cs Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (Eukalyptus): 32-bit: 7.18151855 s | 64-bit: 6.42435041 s
Global $iStruct = 1024
Global $tStruct = DllStructCreate("byte[" & $iStruct & "]")
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
Local $Return = "", $iASC, $iS2, $iS3
Local $bBin = StringToBinary($sString)
If BinaryLen($bBin) > $iStruct Then
$iStruct = BinaryLen($bBin)
$tStruct = DllStructCreate("byte[" & $iStruct & "]")
EndIf
DllStructSetData($tStruct, 1, $bBin)
$nKlein -= 97
$nGross -= 65
$nSonder -= 32
$iS2 = $nSonder - 26
$iS3 = $nSonder - 52
Switch $nExtra
Case 0
For $i = 1 To BinaryLen($bBin)
$iASC = DllStructGetData($tStruct, 1, $i)
Switch $iASC
Case 97 To 122
$iASC = Mod($iASC + $nKlein, 26) + 97
Case 65 To 90
$iASC = Mod($iASC + $nGross, 26) + 65
Case 32 To 64
$iASC = Mod($iASC + $nSonder, 43) + 32
Switch $iASC
Case 65 To 70
$iASC += 26
Case 71 To 74
$iASC += 52
EndSwitch
Case 91 To 96
$iASC = Mod($iASC + $iS2, 43) + 32
Switch $iASC
Case 65 To 70
$iASC += 26
Case 71 To 74
$iASC += 52
EndSwitch
Case 123 To 126
$iASC = Mod($iASC + $iS3, 43) + 32
Switch $iASC
Case 65 To 70
$iASC += 26
Case 71 To 74
$iASC += 52
EndSwitch
EndSwitch
$Return &= Chr($iASC)
Next
Case Else
For $i = 1 To BinaryLen($bBin)
$iASC = DllStructGetData($tStruct, 1, $i)
Switch $iASC
Case 97 To 122
$iASC = Mod($iASC + $nKlein + $nExtra * $i, 26) + 97
Case 65 To 90
$iASC = Mod($iASC + $nGross + $nExtra * $i, 26) + 65
Case 32 To 64
$iASC = Mod($iASC + $nSonder + $nExtra * $i, 43) + 32
Switch $iASC
Case 65 To 70
$iASC += 26
Case 71 To 74
$iASC += 52
EndSwitch
Case 91 To 96
$iASC = Mod($iASC + $iS2 + $nExtra * $i, 43) + 32
Switch $iASC
Case 65 To 70
$iASC += 26
Case 71 To 74
$iASC += 52
EndSwitch
Case 123 To 126
$iASC = Mod($iASC + $iS3 + $nExtra * $i, 43) + 32
Switch $iASC
Case 65 To 70
$iASC += 26
Case 71 To 74
$iASC += 52
EndSwitch
EndSwitch
$Return &= Chr($iASC)
Next
EndSwitch
Return $Return
EndFunc ;==>_CypherEnigma
#ce
; Funktion zur Überprüfung des eigenen Scripts. Nicht mit in den Thread laden!
#include <Crypt.au3> ; das include ist für die Überprüfung deines Scripts notwendig!
Global $aPruefDaten[][] = [[], _
["donaudampfschifffahrtgesellschaft", 5, 0, 0, 0, "0x53E2F132EAF79CE13689BB73846682788E8771B0063CC9CB9501F5C07EEBCDAA"], _
["dieser satz beinhaltet nur kleine buchstaben und leerzeichen", 5, 0, 2, 0, "0x5992BF8319893D0295A57477F19A78E8D286197A0B5AC5A6894DD2EA3CDE603B"], _
["In diesem Satz musst du schon Klein und Grossbuchstaben verschieben", 8, 3, 0, 0, "0x431C76C6E9CA4F350E45774613827182E3D91E173332A35A4FF436AA3173ED73"], _
["Damit es noch etwas schwieriger wird, kommen hier noch Sonderzeichen dazu!", 4, 7, 9, 0, "0xF253F31D8EE1A6DCBCF8FA73CA3A458791F9D69E6934484B3FFDC828B3903FC1"], _
["Bisher wurde auf die Extra-Verschiebung verzichtet. Dies ändert sich jetzt mit diesem Satz.", 3, 7, 2, 5, "0xB85541C2C4A026A24A2742D113BD26FA6EE3AA8972EAD3EC99A4F0572EA5F45E"], _
["Die Krone erlangst du aber nur, wenn du schnöden Sonderzeichen wie z.B. @,&,%,^," & @CRLF & _
"üblen Umlauten wie 'Übernatürlicher Cräcker' und eine Verschiebung über die Grenze" & @CRLF & _
"der Anzahl Zeichen im Alphabet beherrscht." & @CRLF & _
"Nur dann hast du 90% erreicht. :-)", 23, 35, 17, 33, "0x559CDDFD354A0CA84567A9DED88867DC95B4DEE55788DE155BBD07CA4010AE41", ""], _
["und wenn du diesen Text auch entschlüsselst, dann bist du mein Held. ^^" & @CRLF & _
"Eine Auflistung der Kleinbuchstaben: abcdefghijklmnopqrstuvwxyz" & @CRLF & _
"Eine Auflistung der Großbuchstaben: ABCDEFGHIJKLMNOPQRSTUVWXYZ" & @CRLF & _
"Eine Auflistung ausgewählter Sonderzeichen: !§=$&Z)§&;:_-" & @CRLF & _
"und eine Extra-Verschiebung beginnend mit 252 Zeichen. inkl. TAB ==> ;-)", 147, 92, 42, 252, "0x726F77BE455F42DDB7E02F1E20AF85CC61BAFC8C8A372B357815E200AE4FB03C", ""]]
If _Check() = "7/7" Then
Global $TimerEnd, $Timer = TimerInit()
For $l = 1 To 10
For $i = 1 To 2000
_Check2()
Next
Next
$TimerEnd = TimerDiff($Timer) / 10
ConsoleWrite("Zeit für 10 * 2000 Durchgänge gemittelt für Teilnehmer (" & $Teilnehmer & "): " & $TimerEnd / 1000 & " s" & @CRLF)
EndIf
Func _Check()
Local $correct = 0
For $i = 1 To UBound($aPruefDaten) - 1
$CryptResultData = _CypherEnigma($aPruefDaten[$i][0], $aPruefDaten[$i][1], $aPruefDaten[$i][2], $aPruefDaten[$i][3], $aPruefDaten[$i][4])
If _Crypt_HashData($CryptResultData, $CALG_SHA_256) = $aPruefDaten[$i][5] Then $correct += 1
Next
Return $correct & "/" & (UBound($aPruefDaten) - 1)
EndFunc ;==>_Check
Func _Check2()
For $i = 1 To 7
$CryptResultData = _CypherEnigma($aPruefDaten[$i][0], $aPruefDaten[$i][1], $aPruefDaten[$i][2], $aPruefDaten[$i][3], $aPruefDaten[$i][4])
Next
EndFunc ;==>_Check2
;~ Func _DeCypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra = 0)
;~ Local $Return, $nShift, $Asc
;~ Local $aString = StringSplit($sString, '')
;~ For $i = 1 To $aString[0] ; jedes Zeichen prüfen in welchem Array es vorkommt und an welcher Stelle, verschieben und an Return anhängen
;~ $Asc = Number(Asc($aString[$i])) ; Eingabezeichen in Asc umwandeln
;~ Switch $Asc ; Zeichengruppe auswählen
;~ Case 32 To 64, 91 To 96, 123 To 126 ; Sonderzeichen und Zahlen
;~ For $k = 0 To UBound($aSonder)
;~ If $Asc = $aSonder[$k][0] Then ExitLoop ; $k ist das Source Element aus dem Array
;~ Next
;~ $k = $k - ($nSonder + $i * $nExtra) ; neuer Index
;~ While $k < 0
;~ $k += UBound($aSonder)
;~ WEnd
;~ $Return &= $aSonder[$k][1] ; verschobenes neues Zeichen an Return anhängen
;~ Case 65 To 90 ;Großbuchstaben
;~ For $k = 0 To UBound($aGross)
;~ If $Asc = $aGross[$k][0] Then ExitLoop ; $k ist das Source Element aus dem Array
;~ Next
;~ $k = $k - ($nGross + $i * $nExtra) ; neuer Index
;~ While $k < 0
;~ $k += UBound($aGross)
;~ WEnd
;~ $Return &= $aGross[$k][1] ; verschobenes neues Zeichen an Return anhängen
;~ Case 97 To 122 ;Kleinbuchstaben
;~ For $k = 0 To UBound($aKlein)
;~ If $Asc = $aKlein[$k][0] Then ExitLoop ; $k ist das Source Element aus dem Array
;~ Next
;~ $k = $k - ($nKlein + $i * $nExtra) ; neuer Index
;~ While $k < 0
;~ $k += UBound($aKlein)
;~ WEnd
;~ $Return &= $aKlein[$k][1] ; verschobenes neues Zeichen an Return anhängen
;~ Case Else
;~ $Return &= $aString[$i]
;~ EndSwitch
;~ Next
;~ Return $Return
;~ EndFunc ;==>_DeCypherEnigmaEs gab Teilnehmer, die Ihre Lösung während der Laufzeit des Wettbewerbes "optimiert" und erneut abgebenen haben.
Dies ist kein Regelverstoß sondern in meinen Augen maximales Inetresse an der Aufgabe.
Es wurde ja auch nicht untersagt.
Demzufolge werte ich von jedem Teilnehmer seine letzte abgegebene Lösung.
Resumee:
Soweit ich das überhaupt beurteilen kann, hatte die Aufgabe ein paar kleine "Stolpersteine".
1. Ich erwähnte die Nutzung von Arrays (dies war zwar mein Ansatz, aber bei weitem nicht der effizienteste )
2. die Zusammenführung der Sonderzeichen Asc 32 - Asc 126 zu einer Gruppe und der Verschiebung darin
3. die Extra-Verschiebung die anscheinend die 1er-Hürde war (die aber jeder bestanden hat )
summa summarum:
Ein klarer Beweis dafür, dass die "alten Hasen" und die "jungen Hasen" hier alle wissen was sie tun.
Die zehntel-Sekunden sind vll. eher einer Schwäche der Prüfungsumgebung zuzuordnen als einer Klassifizierung der Teilnehmer.
Daher beglückwünsche ich euch alle, dass ihr diese Aufgabe angenommen und bravourös gemeistert habt. 
Die Betrachtung der einzelnen Skripte finde ich höchst interessant. In gewisser Weise spiegeln sie doch wieder,
was für ein Geist das Skript geschrieben hat und welche Prioritäten er gesetzt hat.
PS:
Bei Teilnehmern, die Ihre Lösung auf mehrere Wegen verbreitet haben, gehe ich davon aus, dass diese Lösungen identisch sind.
Die Prüfung, ob einer abgeschrieben hat, überlasse ich Euch. 
Ich hoffe mir fallen noch weitere Aufgaben ein, die euch herausfordern und in der Lösungsfindung Spaß machen.
yep, betrachte die als 1 Gruppe und verschiebe dann
mach aus der Gruppe der Sonderzeichen (Asc 32 - Asc 126) (inkl. Zahlen ohne Groß- Kleinbuchstaben) eine gedankliche Gruppe und verschiebe jedes Zeichen aus dieser Gruppe "nur" in dieser Gruppe
du kannst vielleicht deine Software über den extmounter.exe steuern und damit mounten und unmounten.
C:\Program Files (x86)\Paragon Software\LinuxFS for Windows>extmounter.exe
Usage:
/list - show ext tree(disk/volume)
/refresh disk# [volume#] -- update state of disk# [and volume#]
/mount [/ro - read only] [/online - force online disk and volume] [/ugm [uid value] [gid value] [mode value]] [disk#,lvm#] [volume#] [mount point] [/p "password"] - mount volume(s)
/umount [disk#,lvm#] [mount point] - unmount volume(s)
/ugm disk# volume#
/fsck [disk#,lvm#] [options]
/mkfs [disk#,lvm#] [options]
/logging on/off -- enable/diable extended loggingDesweiteren kannst du den Status des Fensters so anfragen: (kann man sicherlich verbessern)
Opt("WinTitleMatchMode", 2)
$iPID = ShellExecute("C:\Program Files (x86)\Paragon Software\LinuxFS for Windows\Linux File Systems for Windows by Paragon Software.exe","","C:\Program Files (x86)\Paragon Software\LinuxFS for Windows")
ConsoleWrite("PID: " & $iPID & @CRLF)
WinWait("Linux")
$Liste = WinList("Linux")
ConsoleWrite("Fenstertitel: " & $Liste[1][0] & @CRLF)
Sleep(1000)
$Liste2 = WinList(".au3")
WinActivate($Liste2[1][1])
Sleep(1000)
$test = WinGetState($Liste[1][1])
ConsoleWrite("Fenster inaktiv: " & $test & @CRLF)
Sleep(1000)
WinActivate($Liste[1][1])
$test = WinGetState($Liste[1][1])
ConsoleWrite("Fenster aktiv: " & $test & @CRLF)
Sleep(1000)
ProcessClose($iPID)
Sleep(1000)
$test = WinGetState($Liste[1][1])
ConsoleWrite("Fenster geschlossen: " & $test & @CRLF)my short one.
Mal bewusst ohne jegliche Erklärung.
Alles was im Moment "hard-gecoded" ist (z.B. die 12) kann natürlich für dynamisches Verhalten auch durch eine Variable ersetzt werden.
Sollte ich an deiner Aufgabenstellung etwas falsch verstanden haben, dann sry
#include <MsgBoxConstants.au3>
#include <Array.au3>
Global $ini = @ScriptDir & "\magic.ini"
Global $iniOutput[12][12]
Global $keys = IniReadSection($ini, 'Data')
Global $text = "dieses kleine aber ihr und testen zu scripte kleine einen total konfus " & _
"gewirbelten satz durch sortieren. zu woerter ganzen die dabei lesbaren string bzw. " & _
"array verwandeln. es auch es damit muss stehen eigentlich mal zwoelf rasters " & _
"wort richtige das magisches quadrat dar. es ist das dann um muss " & _
"stehen wort welches es im internet zu finden gibt. in vorher ganze " & _
"das habe ich in jeweils zwoelf reihen und zwoelf somit spalten. zwoelf " & _
"jeweils in worten sind es dann insgesamt 144 worte. worten zwoelf aus " & _
"also besteht es libre office calc ausrechen lassen wo was quadrat magische " & _
"simpelste bzw. einfachste eine ini datei zu schreiben wo ein stellt und " & _
"aus dem text zwoelf eines prinzip dem auf basiert einen sinn ergibt. " & _
"AutoIT hilft dann einen in wieder map ini eine ich finde das " & _
"immer so toll soll script test AutoIT feine durchaus hoffentlich dann auch!"
Global $aText = StringSplit($text, ' ')
Global $Ausgabe
For $i = 1 To 12
$a = StringSplit($keys[$i][1], '.')
For $j = 1 To 12
$iniOutput[$i-1][$j-1] = $a[$j]
Next
Next
Global $Ausgabe
For $i = 1 To 12
For $j = 1 To 12
$Ausgabe &= $aText[$iniOutput[$i-1][$j-1]] & " "
Next
$Ausgabe = StringTrimRight($ausgabe,1)
$Ausgabe &= @CRLF
Next
ConsoleWrite($Ausgabe & @CRLF)
MsgBox(0, "dein Text:", $Ausgabe)Nachdem ich vom aufmerksam lesenden chesstiger auf einen Fehler in der Aufgabenstellung hingewiesen wurde,
möchte ich diesen hier für alle klarstellen.
Der letzte Satz der Aufgabenstellung lautete bisher:
Steuerzeichen, Zahlen und die ASCII Zeichen jenseits von Dec 126 werden 1:1 übernommen
Dies ist so sachlich falsch und muss lauten:
Steuerzeichen und die ASCII Zeichen jenseits von Dec 126 werden 1:1 übernommen
Ich bitte etwaige Unannehmlichkeiten bei der Lösungsfindung zu entschuldigen.
nur mal so als Beispiel, so kann das durchaus aussehen:
(Die gestrichelte Linie oben ist nur ein Beispiel für jegliche Art der Formatierung mit der UDF.
Farben, Richtungen, Formen ist alles kein Problem.
Die Kopfdaten sind ein Template, dass auf jeder Seite angezeigt werden würde
und die dynamischen Daten werden durch Variablen eingesetzt und können überall her kommen.
Lediglich deine verwendete Schriftart (Bosch*****) ist nicht eingebettet in deinem Beispiel und kann auf anderen Rechnern nicht angezeigt werden.
Die müsste man (wenn diese unbedingt Verwendung finden soll) mit einbetten.
Das sollte aber auch kein Problem sein.
Hallo und herzlich willkommen zum zweiten AutoIt-Hackathon
Alles was ihr zur Teilnahme braucht, ist das Script, das unterhalb im Code-Block eingefügt ist.
Diesmal gibt es das Script ausschließlich im Code-Block um Differenzen zu vermeiden.
Kopiert es vollständig in euren Editor und lest euch die Anleitung genau durch.
Vielleicht nicht in diesem, aber möglicherweise in einem der nächsten Hackathon's ist zuweilen die genaue Lesart der Aufgabe entscheidend.
Diesmal gewinnt derjenige, dessen Script die Tests zu 100% bewältigt und am schnellsten ist.
Ich weiß das mit der Geschwindigkeit ist so eine Sache in AutoIt. Daher bitte ich Andy (sofern er wieder mitmacht) nicht in Assembler zu proggen.
Ihr könnt eigene Funktionen erstellen, Globale Variablen deklarieren usw ...
Postet eure Lösung hier in diesen Thread. (den markierten Code-Block im Script)
Klinkt euch gerne auf Discord mit ein (am Besten mit Audio, so könnt ihr weiter coden und wir können euch schwitzen hören)
Ich wünsche allen Teilnehmern
happy coding 
PS: ab Dienstag abend 20:00 Uhr gibt es hier meine Lösung der Aufgabe und dann werte ich die Lösungen der Teilnehmer aus.
#cs ****************** AutoIt Hackathon 2025 / 2 ******************
Kategorie: Teil 2 - String-Manipulation
Schwierigkeit: Level II
Aufgabe: "CypherEnigma"
Aufwand: 1 - 2 Std. (geschätzt)
Lerninhalt: In dieser Aufgabe geht es um die Erstellung von Arrays, den "zero-based" Index, das "schleifen" durch Arrays,
eine "umlaufende" Zählung durch Arrays und ASCII-Zeichen.
Die Vereinfachung durch Globale Variablenerstellung, das Auslagern von Operationen in eigene Funktionen
und vielleicht auch um die Nutzung von "Modulo" ;-)
Die Aufgabe wurde bewusst relativ einfach gehalten und würde so nicht als Verschlüsselung nutzen.
Es geht hier mehr darum, die Aufgabe korrekt zu verstehen und umzusetzen. Dabei sind "alle" Anmerkungen in der Aufgabe wichtig!
Aufgabe: Erstelle eine Funktion, die als Input 5 Parameter übernimmt und eine verschlüsselte Zeichenkette zurückgibt
Parameter 1: (String mit ASCII-Zeichen (theoretisch Dec 0 - Dec 255)) als Steuerzeichen werden ausschließlich "HT", "LF" & "CR" enthalten sein!
Parameter 2: ($nKlein als Zahl) Verschiebefaktor für Kleinbuchstaben
Parameter 3: ($nGross als Zahl) Verschiebefaktor für Großbuchstaben
Parameter 4: ($nSonder als Zahl) Verschiebefaktor für Sonderzeichen (ASCII 32 - 126 außer Klein- und Großbuchstaben)
Parameter 5: ($nExtra als Zahl) allgemeiner Verschiebefaktor, n-tes Zeichen in Parameter 1 * $nExtra
Alle nicht betrachteten ASCII-Zeichen werden unverändert übernommen.
Der Verschiebefaktor kann auch größer als die Anzahl Zeichen der entsprechenden Zeichengruppe sein! (Beispiel $nKlein=155)
Für jedes Zeichen des übergebenen Strings ist die Verschiebung in der entsprechenden Zeichengruppe vorzunehmen.
Dabei wird als Verschiebung der feste Verschiebeparameter der Gruppe ($nKlein, $nGross, $nSonder) plus
dem Extra Verschiebungsfaktor $nExtra, der sich mit jedem angewandten Zeichen mit sich selbst addiert, angewendet.
z. B. das 3te Zeichen in Param1: ("u") wird um die Summe der Verschiebefaktoren ($nKlein + ($nExtra + $nExtra + $nExtra))
auf die Gruppe Kleinbuchstaben angewendet.
Wenn das Ende der Zeichengruppe erreicht ist, wird am Anfang wieder begonnen und weiter verschoben.
Alle Texte werden als String übergegeben.
Steuerzeichen und die ASCII Zeichen jenseits von Dec 126 werden 1:1 übernommen
Prüfung: Die Funktion _Check() beinhaltet die Prüfungsdatensätze und für jeden Text einen Hash der Lösung
Die Ausgabe zeigt an, wie viele der Texte korrekt verschlüsselt wurden
Sobald dein Script 100% korrekte Texte verschlüsselt hat, poste dein Script im Thread
Sieger: Gewonnen hat der Teilnehmer, dessen Funktion alle 7 Texte korrekt verschlüsselt und
2000 Durchläufe der Test-Texte in der kürzesten Zeit verschlüsselt
PS: Zusätzliche Funktionen und Globale Variablen können erstellt werden, müssen aber im Lösungspost mit angegeben werden.
Es gilt der Code-Block, der im Thread als Antwort gepostet wird.
Als einzige Vorgabe für das Script wird die Funktion samt Namen und Paremeterübernahme vorgegeben.
Diese ist unten ersichtlich, muss so verwendet werden und aus dieser muss das Ergebnis als Return erfolgen.
Die Verwendung von #includes ist gestattet, müssen aber im Script mit angegeben werden!
#ce ****************** AutoIt Hackathon 2025 / 2 ******************
; um dein Script zu überprüfen, drücke "F5"
; ===== dein Code-Block ab hier =====
Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
Local $Return
Return $Return
EndFunc ;==>_CypherEnigma
; ===== dein Code-Block bis hier =====
; Funktion zur Überprüfung des eigenen Scripts. Nicht mit in den Thread laden!
#include <Crypt.au3> ; das include ist für die Überprüfung deines Scripts notwendig!
ConsoleWrite(_Check() & @CRLF)
Func _Check()
Local $aPruefDaten[][] = [[], _
["donaudampfschifffahrtgesellschaft", 5, 0, 0, 0, "0x53E2F132EAF79CE13689BB73846682788E8771B0063CC9CB9501F5C07EEBCDAA"], _
["dieser satz beinhaltet nur kleine buchstaben und leerzeichen", 5, 0, 2, 0, "0x5992BF8319893D0295A57477F19A78E8D286197A0B5AC5A6894DD2EA3CDE603B"], _
["In diesem Satz musst du schon Klein und Grossbuchstaben verschieben", 8, 3, 0, 0, "0x431C76C6E9CA4F350E45774613827182E3D91E173332A35A4FF436AA3173ED73"], _
["Damit es noch etwas schwieriger wird, kommen hier noch Sonderzeichen dazu!", 4, 7, 9, 0, "0xF253F31D8EE1A6DCBCF8FA73CA3A458791F9D69E6934484B3FFDC828B3903FC1"], _
["Bisher wurde auf die Extra-Verschiebung verzichtet. Dies ändert sich jetzt mit diesem Satz.", 3, 7, 2, 5, "0xB85541C2C4A026A24A2742D113BD26FA6EE3AA8972EAD3EC99A4F0572EA5F45E"], _
["Die Krone erlangst du aber nur, wenn du schnöden Sonderzeichen wie z.B. @,&,%,^," & @CRLF & _
"üblen Umlauten wie 'Übernatürlicher Cräcker' und eine Verschiebung über die Grenze" & @CRLF & _
"der Anzahl Zeichen im Alphabet beherrscht." & @CRLF & _
"Nur dann hast du 90% erreicht. :-)", 23, 35, 17, 33, "0x559CDDFD354A0CA84567A9DED88867DC95B4DEE55788DE155BBD07CA4010AE41", ""], _
["und wenn du diesen Text auch entschlüsselst, dann bist du mein Held. ^^" & @CRLF & _
"Eine Auflistung der Kleinbuchstaben: abcdefghijklmnopqrstuvwxyz" & @CRLF & _
"Eine Auflistung der Großbuchstaben: ABCDEFGHIJKLMNOPQRSTUVWXYZ" & @CRLF & _
"Eine Auflistung ausgewählter Sonderzeichen: !§=$&Z)§&;:_-" & @CRLF & _
"und eine Extra-Verschiebung beginnend mit 252 Zeichen. inkl. TAB ==> ;-)", 147, 92, 42, 252, "0x726F77BE455F42DDB7E02F1E20AF85CC61BAFC8C8A372B357815E200AE4FB03C", ""]]
Local $correct = 0
For $i = 1 To UBound($aPruefDaten) - 1
$CryptResultData = _CypherEnigma(String($aPruefDaten[$i][0]), $aPruefDaten[$i][1], $aPruefDaten[$i][2], $aPruefDaten[$i][3], $aPruefDaten[$i][4])
If _Crypt_HashData($CryptResultData, $CALG_SHA_256) = $aPruefDaten[$i][5] Then
ConsoleWrite("Testergebnis Test " & $i & ": okay" & @CRLF)
$correct += 1
Else
ConsoleWrite("Testergebnis Test " & $i & ": not okay" & @CRLF)
EndIf
Next
Return @CRLF & "Testergebnis (" & $correct & "/" & (UBound($aPruefDaten) - 1) & "): " & Round(100 / (UBound($aPruefDaten) - 1) * $correct,2) & "%"
EndFunc ;==>_Checkjetzt schreibe bitte nicht so etwas wie: "du kannst funktionen mehrmals nutzen an verschiedenen stellen"
aber genau das wird seine Antwort sein.
Wenn du dir Funktionen ansiehst und dass diese auch Parameter übergeben bekommen können, dann kann man damit schon ganz schön viel anstellen.
PS: fast alle komplexeren Befehle die User geschrieben haben, sind Funktionen
Wenn du mal bei 1000+ Zeilen Code angekommen bist, wirst du diese sehr zu schätzen lernen...
herzlich willkommen
für mich liest sich das so, dass da ein 1-klick AutoIt Script alles erledigen kann
Vorraussetzung ist nur, dass auf dem TestPC die exe auch ausgeführt werden darf.
Ich kann mir da einen USB Stick vorstellen, auf dem dann auch gleich das Protokoll als pdf abgelegt wird.
ich weiß jetzt nicht, ob du auch Sektionen in der ini deklariert hast ([Section ...])
mit einem SectionName in der ini funktioniert es mit diesem Script
#include <MsgBoxConstants.au3>
#include <Array.au3>
Global $ini = @ScriptDir & "\shortlist.ini"
Global $aErgebnis[1][1]
Global $sections = IniReadSectionNames($ini)
For $a = 1 To UBound($sections) - 1
$keys = IniReadSection($ini, $sections[$a])
Redim $aErgebnis[UBound($keys)][4]
For $b = 1 To UBound($keys) - 1
$data = StringSplit($keys[$b][1], '|')
$aErgebnis[$b][0] = $keys[$b][0]
$aErgebnis[$b][1] = $data[1]
$aErgebnis[$b][2] = $data[2]
$aErgebnis[$b][3] = $data[3]
Next
Next
_ArrayDisplay($aErgebnis)hipfzwirgel das mit dem Template erstellen hast du möglicherweise falsch verstanden. Ein Template als Basis für jede Seite zu bauen ist kein Problem. Auch „erste“ & „letzte“ Seiten sind kein Problem.
Ich verstehe nur nicht, warum du programmatisch eine pdf erstellst und diese dann manuell befüllbar sein soll.
Vielleicht solltest du dir Gedanken machen, wie der Datenfluss aussieht.
Wenn du uns den beschreibst, finden wir sicher die optimale Option für dich.
man kann Word auch mit Powershell bedienen über die COM-Schnittstelle und direkt als pdf speichern.
wenn das umsetzbar ist, kann ich dir das schon bauen, wäre dann aber nicht mehr Hilfe zur Selbsthilfe,
sondern eher eine Programmieranfrage: Mit Gegenleistung
Gerne auch via PN