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. Schnuffel

Beiträge von Schnuffel

  • eine etwas andere uhr mit erweiterten features

    • Schnuffel
    • 8. Juni 2025 um 10:30

    ich hab mal ein wenig dran rum gebastelt um das Startverhalten etwas zu optimieren und das Laufzeitverhalten.
    Da ist aber noch Potenzial drin...

    Tidy spuckt aber noch einen harten Error aus (CRT ...)
    den habe ich jetzt nicht gesucht / behoben (ist jetzt behoben. Anscheinend mag Tidy keine Variablen mit ca. 4000 Zeichen in einer Zeile ...)

    AutoIt
    #include <ButtonConstants.au3>
    #include <ComboConstants.au3>
    #include <GUIConstantsEx.au3>
    #include <StaticConstants.au3>
    #include <WindowsConstants.au3>
    #include <Date.au3>
    #include <DateTimeConstants.au3>
    ;#include <GDIPlus.au3> / not necessary
    ;#include <WinAPIGdi.au3> / not necessary
    
    ; #####################################################################
    ; # Fill Data into Dropdown Boxes
    ; #####################################################################
    Global $Timer = TimerInit()
    ; Fill Dropdown: Hours
    Local $sHours = "01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23"
    ; Fill Dropdown: Minutes and Seconds
    Local $sMinSec = "01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32|33|34|35|36|37|38|39|40|41|42|43|44|45|46|47|48|49|50|51|52|53|54|55|56|57|58|59"
    ; Fill Dropdown: Milliseconds
    Local $sMillis = "001|002|003|004|005|006|007|008|009|010|011|012|013|014|015|016|017|018|019|020|021|022|023|024|025|026|027|028|029|030|031|032|033|034|035|036|037|038|039|040|041|042|043|044|045|046|047|048|049|050|051|052|053|054|055|056|057|058|059|060|061|062|063|064|065|066|067|068|069|070|071|072|073|074|075|076|077|078|079|080|081|082|083|084|085|086|087|088|089|090|091|092|093|094|095|096|097|098|099|100|" & _
    "101|102|103|104|105|106|107|108|109|110|111|112|113|114|115|116|117|118|119|120|121|122|123|124|125|126|127|128|129|130|131|132|133|134|135|136|137|138|139|140|141|142|143|144|145|146|147|148|149|150|151|152|153|154|155|156|157|158|159|160|161|162|163|164|165|166|167|168|169|170|171|172|173|174|175|176|177|178|179|180|181|182|183|184|185|186|187|188|189|190|191|192|193|194|195|196|197|198|199|200|" & _
    "201|202|203|204|205|206|207|208|209|210|211|212|213|214|215|216|217|218|219|220|221|222|223|224|225|226|227|228|229|230|231|232|233|234|235|236|237|238|239|240|241|242|243|244|245|246|247|248|249|250|251|252|253|254|255|256|257|258|259|260|261|262|263|264|265|266|267|268|269|270|271|272|273|274|275|276|277|278|279|280|281|282|283|284|285|286|287|288|289|290|291|292|293|294|295|296|297|298|299|300|" & _
    "301|302|303|304|305|306|307|308|309|310|311|312|313|314|315|316|317|318|319|320|321|322|323|324|325|326|327|328|329|330|331|332|333|334|335|336|337|338|339|340|341|342|343|344|345|346|347|348|349|350|351|352|353|354|355|356|357|358|359|360|361|362|363|364|365|366|367|368|369|370|371|372|373|374|375|376|377|378|379|380|381|382|383|384|385|386|387|388|389|390|391|392|393|394|395|396|397|398|399|400|" & _
    "401|402|403|404|405|406|407|408|409|410|411|412|413|414|415|416|417|418|419|420|421|422|423|424|425|426|427|428|429|430|431|432|433|434|435|436|437|438|439|440|441|442|443|444|445|446|447|448|449|450|451|452|453|454|455|456|457|458|459|460|461|462|463|464|465|466|467|468|469|470|471|472|473|474|475|476|477|478|479|480|481|482|483|484|485|486|487|488|489|490|491|492|493|494|495|496|497|498|499|500|" & _
    "501|502|503|504|505|506|507|508|509|510|511|512|513|514|515|516|517|518|519|520|521|522|523|524|525|526|527|528|529|530|531|532|533|534|535|536|537|538|539|540|541|542|543|544|545|546|547|548|549|550|551|552|553|554|555|556|557|558|559|560|561|562|563|564|565|566|567|568|569|570|571|572|573|574|575|576|577|578|579|580|581|582|583|584|585|586|587|588|589|590|591|592|593|594|595|596|597|598|599|600|" & _
    "601|602|603|604|605|606|607|608|609|610|611|612|613|614|615|616|617|618|619|620|621|622|623|624|625|626|627|628|629|630|631|632|633|634|635|636|637|638|639|640|641|642|643|644|645|646|647|648|649|650|651|652|653|654|655|656|657|658|659|660|661|662|663|664|665|666|667|668|669|670|671|672|673|674|675|676|677|678|679|680|681|682|683|684|685|686|687|688|689|690|691|692|693|694|695|696|697|698|699|700|" & _
    "701|702|703|704|705|706|707|708|709|710|711|712|713|714|715|716|717|718|719|720|721|722|723|724|725|726|727|728|729|730|731|732|733|734|735|736|737|738|739|740|741|742|743|744|745|746|747|748|749|750|751|752|753|754|755|756|757|758|759|760|761|762|763|764|765|766|767|768|769|770|771|772|773|774|775|776|777|778|779|780|781|782|783|784|785|786|787|788|789|790|791|792|793|794|795|796|797|798|799|800|" & _
    "801|802|803|804|805|806|807|808|809|810|811|812|813|814|815|816|817|818|819|820|821|822|823|824|825|826|827|828|829|830|831|832|833|834|835|836|837|838|839|840|841|842|843|844|845|846|847|848|849|850|851|852|853|854|855|856|857|858|859|860|861|862|863|864|865|866|867|868|869|870|871|872|873|874|875|876|877|878|879|880|881|882|883|884|885|886|887|888|889|890|891|892|893|894|895|896|897|898|899|900|" & _
    "901|902|903|904|905|906|907|908|909|910|911|912|913|914|915|916|917|918|919|920|921|922|923|924|925|926|927|928|929|930|931|932|933|934|935|936|937|938|939|940|941|942|943|944|945|946|947|948|949|950|951|952|953|954|955|956|957|958|959|960|961|962|963|964|965|966|967|968|969|970|971|972|973|974|975|976|977|978|979|980|981|982|983|984|985|986|987|988|989|990|991|992|993|994|995|996|997|998|999"
    ConsoleWrite(TimerDiff($Timer) & "ms nach Dropdown Variablen Erstellung" & @CRLF)
    
    #Region ### START Koda GUI section ###
    Global $illclock = GUICreate("Clocking It!", 338, 791, -1, -1, -1, BitOR($WS_EX_COMPOSITED, $WS_EX_LAYERED))
    Global $MenuFile = GUICtrlCreateMenu("File")
    Global $MenuReset = GUICtrlCreateMenuItem("Reset", $MenuFile)
    Global $MenuExit = GUICtrlCreateMenuItem("Exit", $MenuFile)
    Global $MenuHelp = GUICtrlCreateMenu("Help")
    Global $MenuInfo = GUICtrlCreateMenuItem("Info", $MenuHelp)
    Global $MenuAbout = GUICtrlCreateMenuItem("About", $MenuHelp)
    Global $DayDate = GUICtrlCreateLabel("DayDate", 40, 20, 262, 33)
    Global $Clock = GUICtrlCreateLabel("", 40, 66, 262, 53)
    Global $StartCheckBox = GUICtrlCreateCheckbox("Start", 16, 160, 41, 17)
    Global $StopCheckBox = GUICtrlCreateCheckbox("Stop", 288, 160, 41, 17)
    Global $Autocalculation = GUICtrlCreateLabel("00:00:00.000", 64, 152, 213, 33)
    Global $StartMCalc = GUICtrlCreateLabel("Start Calculation:", 16, 219, 84, 17)
    Global $EndMCalc = GUICtrlCreateLabel("End Calculation:", 16, 251, 81, 17)
    Global $MStartHrs = GUICtrlCreateCombo("00", 104, 216, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MStartMin = GUICtrlCreateCombo("00", 160, 216, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MStartSec = GUICtrlCreateCombo("00", 216, 216, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MStartMil = GUICtrlCreateCombo("000", 272, 216, 50, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MEndHrs = GUICtrlCreateCombo("00", 104, 248, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MEndMin = GUICtrlCreateCombo("00", 160, 248, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MEndSec = GUICtrlCreateCombo("00", 216, 248, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MEndMil = GUICtrlCreateCombo("000", 272, 248, 50, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $MCalcGo = GUICtrlCreateButton("Calculate Time", 16, 280, 123, 33)
    Global $MCalResult = GUICtrlCreateLabel("00:00:00.000", 152, 280, 170, 33)
    Global $SetAlarm = GUICtrlCreateLabel("Set Alarm Time:", 16, 355, 86, 17)
    Global $AlarmHrs = GUICtrlCreateCombo("00", 104, 352, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $AlarmMin = GUICtrlCreateCombo("00", 160, 352, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $AlarmSec = GUICtrlCreateCombo("00", 216, 352, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $AlarmMil = GUICtrlCreateCombo("000", 272, 352, 50, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $AlarmOn = GUICtrlCreateButton("ON", 16, 384, 147, 25)
    Global $AlarmOff = GUICtrlCreateButton("OFF", 176, 384, 147, 25)
    Global $Stopwatch = GUICtrlCreateLabel("00:00:00.000", 40, 448, 255, 33)
    Global $StopwatchStart = GUICtrlCreateButton("START", 11, 504, 75, 25)
    Global $StopwatchStop = GUICtrlCreateButton("STOP", 91, 504, 75, 25)
    Global $StopwatchCont = GUICtrlCreateButton("CONTINUE", 171, 504, 75, 25)
    Global $StopwatchReset = GUICtrlCreateButton("RESET", 251, 504, 75, 25)
    Global $SetCntdwn = GUICtrlCreateLabel("Set Countdown:", 16, 579, 80, 17)
    Global $CountHrs = GUICtrlCreateCombo("00", 104, 576, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $CountMin = GUICtrlCreateCombo("00", 160, 576, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $CountSec = GUICtrlCreateCombo("00", 216, 576, 45, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $CountMil = GUICtrlCreateCombo("000", 272, 576, 50, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL, $WS_VSCROLL))
    Global $Countdown = GUICtrlCreateLabel("00:00:00.000", 40, 616, 250, 41)
    Global $CountStart = GUICtrlCreateButton("START", 11, 672, 75, 25)
    Global $CountStop = GUICtrlCreateButton("STOP", 91, 672, 75, 25)
    Global $CountCont = GUICtrlCreateButton("CONTINUE", 171, 672, 75, 25)
    Global $CountReset = GUICtrlCreateButton("RESET", 251, 672, 75, 25)
    Global $Exit = GUICtrlCreateButton("EXIT", 232, 720, 91, 33)
    #EndRegion ### END Koda GUI section ###
    
    ConsoleWrite(TimerDiff($Timer) & "ms nach GUI Erstellung" & @CRLF)
    
    ; #####################################################################
    ; # Other Global Values To Declare
    ; #####################################################################
    Global $nMsg = 0
    Global $popupMsg = 0
    Global $elapsedMS = 0
    Global $MDay = 0
    Global $DateString = 0
    Global $AlarmSet = False
    Global $AlarmTargetMS = 0
    Global $hAlarmPopup = 0
    Global $bAlarmPopupVisible = False
    Global $btnAlarmOK = 0
    Global $runrunrun = 0 ; Timer handle for current running timer
    Global $elapsedBeforeStop = 0 ; Accumulated elapsed time before last stop
    Global $isRunning = False ; Stopwatch running state
    Global $g_CountdownTotalMS = 0 ; Total countdown duration (fixed)
    Global $g_CountdownRemainingMS = 0 ; Time left when paused or running
    Global $g_CountdownStartTime = 0 ; TimerInit() timestamp for running countdown
    Global $g_CountdownRunning = False ; True when countdown is actively running
    
    ; #####################################################################
    ; # Style Values for indivdual Parts
    ; #####################################################################
    
    GUICtrlSetFont($DayDate, 14, 600, 0, "Consolas")
    GUICtrlSetStyle($DayDate, BitOR($SS_CENTER, $SS_CENTERIMAGE))
    GUICtrlSetBkColor($DayDate, -1)
    GUICtrlSetFont($Clock, 26, 900, 0, "Consolas")
    GUICtrlSetStyle($Clock, BitOR($SS_CENTER, $SS_CENTERIMAGE))
    GUICtrlSetBkColor($Clock, -1)
    GUICtrlSetFont($Autocalculation, 20, 600, 0, "Consolas")
    GUICtrlSetStyle($Autocalculation, BitOR($SS_CENTER, $SS_CENTERIMAGE))
    GUICtrlSetBkColor($Autocalculation, -1)
    GUICtrlSetFont($MCalResult, 18, 600, 0, "Consolas")
    GUICtrlSetStyle($MCalResult, BitOR($SS_CENTER, $SS_CENTERIMAGE))
    GUICtrlSetBkColor($MCalResult, -1)
    GUICtrlSetState($AlarmOff, $GUI_DISABLE)
    GUICtrlSetFont($Stopwatch, 26, 900, 0, "Consolas")
    GUICtrlSetStyle($Stopwatch, BitOR($SS_CENTER, $SS_CENTERIMAGE))
    GUICtrlSetBkColor($Stopwatch, -1)
    GUICtrlSetState($StopwatchStart, $GUI_ENABLE)
    GUICtrlSetState($StopwatchReset, $GUI_DISABLE)
    GUICtrlSetState($StopwatchStop, $GUI_DISABLE)
    GUICtrlSetState($StopwatchCont, $GUI_DISABLE)
    GUICtrlSetFont($Countdown, 26, 900, 0, "Consolas")
    GUICtrlSetStyle($Countdown, BitOR($SS_CENTER, $SS_CENTERIMAGE))
    GUICtrlSetBkColor($Countdown, -1)
    GUICtrlSetState($CountStart, $GUI_ENABLE)
    GUICtrlSetState($CountReset, $GUI_DISABLE)
    GUICtrlSetState($CountStop, $GUI_DISABLE)
    GUICtrlSetState($CountCont, $GUI_DISABLE)
    ConsoleWrite(TimerDiff($Timer) & "ms nach GUI Status setzen" & @CRLF)
    
    AdlibRegister("_SetDay", 1000)
    
    ; #####################################################################
    ; # Main Loop for the actual Application
    ; #####################################################################
    
    GUICtrlSetData($MStartHrs, $sHours)
    GUICtrlSetData($MEndHrs, $sHours)
    GUICtrlSetData($AlarmHrs, $sHours)
    GUICtrlSetData($CountHrs, $sHours)
    
    GUICtrlSetData($MStartMin, $sMinSec)
    GUICtrlSetData($MEndMin, $sMinSec)
    GUICtrlSetData($AlarmMin, $sMinSec)
    GUICtrlSetData($CountMin, $sMinSec)
    GUICtrlSetData($MStartSec, $sMinSec)
    GUICtrlSetData($MEndSec, $sMinSec)
    GUICtrlSetData($AlarmSec, $sMinSec)
    GUICtrlSetData($CountSec, $sMinSec)
    
    GUICtrlSetData($MStartMil, $sMillis)
    GUICtrlSetData($MEndMil, $sMillis)
    GUICtrlSetData($AlarmMil, $sMillis)
    GUICtrlSetData($CountMil, $sMillis)
    ConsoleWrite(TimerDiff($Timer) & "ms nach DropDown Befüllung" & @CRLF)
    
    AdlibRegister("_SetClock", 20)
    
    GUISetState(@SW_SHOW)
    ConsoleWrite(TimerDiff($Timer) & "ms GUI ist sichtbar" & @CRLF)
    
    While 1
    $nMsg = GUIGetMsg()
    
    If $isRunning Then
    If $runrunrun <> 0 Then
    $totalElapsed = $elapsedBeforeStop + TimerDiff($runrunrun)
    Else
    $totalElapsed = $elapsedBeforeStop
    EndIf
    GUICtrlSetData($Stopwatch, FormatTime($totalElapsed))
    EndIf
    
    ; ausgelagert in AdLib
    ;Local $aDays[7] = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
    ;Local $dayOfWeek = _DateToDayOfWeekISO(@YEAR, @MON, @MDAY)
    ;Local $dayname = $aDays[$dayOfWeek - 1]
    ; Format the date string
    ;Local $DateString = $dayname & ", " & @MDAY & "." & @MON & "." & @YEAR
    ;GUICtrlSetData($DayDate, $DateString)
    
    ; ausgelagert in AdLib
    ; Update label text
    ;$TimeString = StringFormat("%02d:%02d:%02d.%02d0", @HOUR, @MIN, @SEC, @MSEC / 10)
    ;GUICtrlSetData($Clock, $TimeString)
    
    Switch $nMsg
    Case $GUI_EVENT_CLOSE, $Exit, $MenuExit
    ExitLoop
    
    Case $StartCheckBox
    If GUICtrlRead($StartCheckBox) = $GUI_CHECKED Then
    GUICtrlSetData($StartCheckBox, 'GO')
    $StartCBTime = TimerInit()
    Else
    GUICtrlSetData($StartCheckBox, 'Start')
    EndIf
    
    Case $StopCheckBox
    If GUICtrlRead($StopCheckBox) = $GUI_CHECKED Then
    GUICtrlSetData($StopCheckBox, 'END')
    ; Calculate elapsed time in milliseconds
    $elapsedMS = TimerDiff($StartCBTime)
    GUICtrlSetData($Autocalculation, FormatTime($elapsedMS))
    Else
    GUICtrlSetData($StopCheckBox, 'Stop')
    EndIf
    
    Case $MCalcGo
    _CalculateManualTime()
    
    Case $AlarmOn
    _SetAlarm()
    $AlarmSet = True
    GUICtrlSetState($AlarmOn, $GUI_DISABLE)
    GUICtrlSetState($AlarmOff, $GUI_ENABLE)
    
    Case $AlarmOff
    _ClearAlarm()
    $AlarmSet = False
    GUICtrlSetState($AlarmOff, $GUI_DISABLE)
    GUICtrlSetState($AlarmOn, $GUI_ENABLE)
    
    Case $StopwatchStart
    $runrunrun = TimerInit()
    $elapsedBeforeStop = 0
    $isRunning = True
    GUICtrlSetState($StopwatchStop, $GUI_ENABLE)
    GUICtrlSetState($StopwatchStart, $GUI_DISABLE)
    GUICtrlSetState($StopwatchReset, $GUI_DISABLE)
    GUICtrlSetState($StopwatchCont, $GUI_DISABLE)
    
    Case $StopwatchStop
    If $isRunning Then
    $elapsedBeforeStop += TimerDiff($runrunrun)
    $isRunning = False
    EndIf
    GUICtrlSetState($StopwatchReset, $GUI_ENABLE)
    GUICtrlSetState($StopwatchCont, $GUI_ENABLE)
    
    Case $StopwatchCont
    If Not $isRunning Then
    $runrunrun = TimerInit()
    $isRunning = True
    EndIf
    GUICtrlSetState($StopwatchReset, $GUI_DISABLE)
    GUICtrlSetState($StopwatchCont, $GUI_DISABLE)
    
    Case $StopwatchReset
    $elapsedBeforeStop = 0
    $isRunning = False
    $runrunrun = 0 ; Reset timer handle
    GUICtrlSetData($Stopwatch, "00:00:00.000")
    GUICtrlSetState($StopwatchStart, $GUI_ENABLE)
    GUICtrlSetState($StopwatchReset, $GUI_DISABLE)
    GUICtrlSetState($StopwatchStop, $GUI_DISABLE)
    GUICtrlSetState($StopwatchCont, $GUI_DISABLE)
    
    Case $CountStart
    _ReadyCountdownTimer() ; Sets $g_CountdownTotalMS, $g_CountdownStartTime, $g_CountdownRunning = True
    $g_CountdownRemainingMS = $g_CountdownTotalMS
    GUICtrlSetState($CountStop, $GUI_ENABLE)
    GUICtrlSetState($CountStart, $GUI_DISABLE)
    GUICtrlSetState($CountReset, $GUI_DISABLE)
    GUICtrlSetState($CountCont, $GUI_DISABLE)
    
    
    Case $CountStop
    ; Pause countdown by calculating remaining time
    $elapsedMS = TimerDiff($g_CountdownStartTime)
    $g_CountdownRemainingMS = $g_CountdownRemainingMS - $elapsedMS
    $g_CountdownRunning = False
    GUICtrlSetState($CountStop, $GUI_DISABLE)
    GUICtrlSetState($CountReset, $GUI_ENABLE)
    GUICtrlSetState($CountCont, $GUI_ENABLE)
    
    Case $CountCont
    ; Continue countdown by restarting timer with remaining time
    $g_CountdownStartTime = TimerInit()
    $g_CountdownRunning = True
    GUICtrlSetState($CountReset, $GUI_DISABLE)
    GUICtrlSetState($CountCont, $GUI_DISABLE)
    GUICtrlSetState($CountStop, $GUI_ENABLE)
    
    Case $CountReset
    $g_CountdownRunning = False
    $g_CountdownRemainingMS = 0
    $g_CountdownTotalMS = 0
    GUICtrlSetData($Countdown, "00:00:00.000")
    GUICtrlSetState($CountStart, $GUI_ENABLE)
    GUICtrlSetState($CountReset, $GUI_DISABLE)
    GUICtrlSetState($CountStop, $GUI_DISABLE)
    GUICtrlSetState($CountCont, $GUI_DISABLE)
    
    Case $MenuReset
    _AllBackToStartingPosition()
    
    EndSwitch
    
    ; Handle alarm popup messages if visible
    If $bAlarmPopupVisible Then
    $popupMsg = GUIGetMsg($hAlarmPopup)
    If $popupMsg = $btnAlarmOK Or $popupMsg = $GUI_EVENT_CLOSE Then
    _DestroyAlarmPopup()
    EndIf
    EndIf
    
    ; Alarm checking
    If $AlarmSet And Not $bAlarmPopupVisible Then
    Local $currentMS = (@HOUR * 3600000) + (@MIN * 60000) + (@SEC * 1000) + @MSEC
    If $currentMS >= $AlarmTargetMS Then
    ;SoundPlay(@ScriptDir & "\alarm.wav", 1)
    _CreateAlarmPopup()
    _ClearAlarm()
    EndIf
    EndIf
    
    If $g_CountdownRunning Then
    Local $elapsedMS = TimerDiff($g_CountdownStartTime)
    Local $remainingMS = $g_CountdownRemainingMS - $elapsedMS
    
    If $remainingMS <= 0 Then
    $remainingMS = 0
    $g_CountdownRunning = False
    GUICtrlSetData($CountHrs, $sHours, "00")
    GUICtrlSetData($CountMin, $sMinSec, "00")
    GUICtrlSetData($CountSec, $sMinSec, "00")
    GUICtrlSetData($CountMil, $sMillis, "000")
    GUICtrlSetData($Countdown, "00:00:00.000")
    GUICtrlSetState($CountStart, $GUI_ENABLE)
    GUICtrlSetState($CountReset, $GUI_DISABLE)
    GUICtrlSetState($CountStop, $GUI_DISABLE)
    GUICtrlSetState($CountCont, $GUI_DISABLE)
    _ShowAlarmPopup()
    Else
    GUICtrlSetData($Countdown, FormatTime($remainingMS))
    EndIf
    
    Else
    ; Countdown paused — just show remaining time without counting down
    GUICtrlSetData($Countdown, FormatTime($g_CountdownRemainingMS))
    EndIf
    WEnd
    
    ; #####################################################################
    ; # Terminate the Application
    ; #####################################################################
    
    GUIDelete()
    AdlibUnRegister("_SetClock")
    AdlibUnRegister("_SetDay")
    Exit
    
    ; #####################################################################
    ; # Functions used in the Application
    ; #####################################################################
    
    Func _CalculateManualTime()
    Local $startH = Number(GUICtrlRead($MStartHrs))
    Local $startM = Number(GUICtrlRead($MStartMin))
    Local $startS = Number(GUICtrlRead($MStartSec))
    Local $startMS = Number(GUICtrlRead($MStartMil))
    Local $endH = Number(GUICtrlRead($MEndHrs))
    Local $endM = Number(GUICtrlRead($MEndMin))
    Local $endS = Number(GUICtrlRead($MEndSec))
    Local $endMS = Number(GUICtrlRead($MEndMil))
    Local $startTotalMS = ($startH * 3600000) + ($startM * 60000) + ($startS * 1000) + $startMS
    Local $endTotalMS = ($endH * 3600000) + ($endM * 60000) + ($endS * 1000) + $endMS
    Local $diffMS = $endTotalMS - $startTotalMS
    If $diffMS < 0 Then $diffMS += 24 * 3600000 ; Handle crossing midnight
    GUICtrlSetData($MCalResult, FormatTime($diffMS))
    EndFunc ;==>_CalculateManualTime
    
    Func _SetAlarm()
    Local $hrs = Number(GUICtrlRead($AlarmHrs))
    Local $min = Number(GUICtrlRead($AlarmMin))
    Local $sec = Number(GUICtrlRead($AlarmSec))
    Local $mil = Number(GUICtrlRead($AlarmMil))
    ; Convert to milliseconds for easier comparison
    $AlarmTargetMS = ($hrs * 3600000) + ($min * 60000) + ($sec * 1000) + $mil
    $AlarmSet = True
    EndFunc ;==>_SetAlarm
    
    Func _ClearAlarm()
    $AlarmSet = False
    EndFunc ;==>_ClearAlarm
    
    Func _ShowAlarmPopup()
    ; Prevent multiple popups
    If $hAlarmPopup And WinExists($hAlarmPopup) Then Return
    ; Create the popup GUI
    $hAlarmPopup = GUICreate("Warning", 250, 120, -1, -1, $WS_POPUP + $WS_CAPTION + $WS_SYSMENU)
    GUICtrlCreateLabel("Time's UP! Please press OK.", 20, 20, 210, 40, $SS_CENTER)
    Local $btnOK = GUICtrlCreateButton("OK", 85, 70, 80, 30)
    GUISetState(@SW_SHOW, $hAlarmPopup)
    ; Handle messages for the alarm popup separately
    While 1
    Local $msg = GUIGetMsg()
    If $msg = $btnOK Or $msg = $GUI_EVENT_CLOSE Then
    GUIDelete($hAlarmPopup)
    $hAlarmPopup = 0
    ExitLoop
    EndIf
    ;Sleep(10) ; Let CPU breathe / not necessary cause "While" is automatically using a sleep
    WEnd
    EndFunc ;==>_ShowAlarmPopup
    
    Func _CreateAlarmPopup()
    $hAlarmPopup = GUICreate("Warning", 250, 120, -1, -1, $WS_POPUP + $WS_CAPTION + $WS_SYSMENU)
    GUICtrlCreateLabel("Time's UP! Please press OK.", 20, 20, 210, 40, $SS_CENTER)
    $btnAlarmOK = GUICtrlCreateButton("OK", 85, 70, 80, 30)
    GUISetState(@SW_SHOW, $hAlarmPopup)
    $bAlarmPopupVisible = True
    EndFunc ;==>_CreateAlarmPopup
    
    Func _DestroyAlarmPopup()
    GUIDelete($hAlarmPopup)
    $hAlarmPopup = 0
    $bAlarmPopupVisible = False
    EndFunc ;==>_DestroyAlarmPopup
    
    ; Format milliseconds into 00:00:00.000 string
    Func FormatTime($ms)
    Local $hours = Int($ms / 3600000)
    Local $minutes = Int(Mod($ms, 3600000) / 60000)
    Local $seconds = Int(Mod($ms, 60000) / 1000)
    Local $milliseconds = Mod($ms, 1000)
    Return StringFormat("%02d:%02d:%02d.%03d", $hours, $minutes, $seconds, $milliseconds)
    EndFunc ;==>FormatTime
    
    Func _ReadyCountdownTimer()
    Local $RCountHrs = Number(GUICtrlRead($CountHrs))
    Local $RCountMin = Number(GUICtrlRead($CountMin))
    Local $RCountSec = Number(GUICtrlRead($CountSec))
    Local $RCountMil = Number(GUICtrlRead($CountMil))
    $g_CountdownTotalMS = ($RCountHrs * 3600000) + ($RCountMin * 60000) + ($RCountSec * 1000) + $RCountMil
    $g_CountdownStartTime = TimerInit()
    $g_CountdownRunning = True
    ; Set initial display
    Local $Countvalues = StringFormat("%02d:%02d:%02d.%03d", $RCountHrs, $RCountMin, $RCountSec, $RCountMil)
    GUICtrlSetData($Countdown, $Countvalues)
    EndFunc ;==>_ReadyCountdownTimer
    
    Func _AllBackToStartingPosition()
    _ClearAlarm()
    $AlarmSet = False
    GUICtrlSetState($AlarmOff, $GUI_DISABLE)
    GUICtrlSetState($AlarmOn, $GUI_ENABLE)
    GUICtrlSetData($StartCheckBox, 'Start')
    GUICtrlSetData($StopCheckBox, 'Stop')
    GUICtrlSetData($Autocalculation, "00:00:00.000")
    GUICtrlSetData($MStartHrs, $sHours, "00")
    GUICtrlSetData($MEndHrs, $sHours, "00")
    GUICtrlSetData($AlarmHrs, $sHours, "00")
    GUICtrlSetData($CountHrs, $sHours, "00")
    GUICtrlSetData($MStartMin, $sMinSec, "00")
    GUICtrlSetData($MEndMin, $sMinSec, "00")
    GUICtrlSetData($AlarmMin, $sMinSec, "00")
    GUICtrlSetData($CountMin, $sMinSec, "00")
    GUICtrlSetData($MStartSec, $sMinSec, "00")
    GUICtrlSetData($MEndSec, $sMinSec, "00")
    GUICtrlSetData($AlarmSec, $sMinSec, "00")
    GUICtrlSetData($CountSec, $sMinSec, "00")
    GUICtrlSetData($MStartMil, $sMillis, "000")
    GUICtrlSetData($MEndMil, $sMillis, "000")
    GUICtrlSetData($AlarmMil, $sMillis, "000")
    GUICtrlSetData($CountMil, $sMillis, "000")
    GUICtrlSetState($StartCheckBox, $GUI_UNCHECKED)
    GUICtrlSetState($StopCheckBox, $GUI_UNCHECKED)
    GUICtrlSetData($MCalResult, "00:00:00.000")
    $elapsedBeforeStop = 0
    $isRunning = False
    $runrunrun = 0
    GUICtrlSetData($Stopwatch, "00:00:00.000")
    GUICtrlSetState($StopwatchStart, $GUI_ENABLE)
    GUICtrlSetState($StopwatchReset, $GUI_DISABLE)
    GUICtrlSetState($StopwatchStop, $GUI_DISABLE)
    GUICtrlSetState($StopwatchCont, $GUI_DISABLE)
    $g_CountdownRunning = False
    $g_CountdownRemainingMS = 0
    $g_CountdownTotalMS = 0
    GUICtrlSetData($Countdown, "00:00:00.000")
    GUICtrlSetState($CountStart, $GUI_ENABLE)
    GUICtrlSetState($CountReset, $GUI_DISABLE)
    GUICtrlSetState($CountStop, $GUI_DISABLE)
    GUICtrlSetState($CountCont, $GUI_DISABLE)
    EndFunc ;==>_AllBackToStartingPosition
    
    Func _SetClock()
    $TimeString = StringFormat("%02d:%02d:%02d.%03s", @HOUR, @MIN, @SEC, @MSEC)
    GUICtrlSetData($Clock, $TimeString)
    EndFunc ;==>_SetClock
    
    Func _SetDay()
    If $MDay <> @MDAY Then
    $MDay = @MDAY
    Local $aDays[] = ["", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
    Local $dayname = $aDays[_DateToDayOfWeekISO(@YEAR, @MON, @MDAY)]
    ; Format the date string
    $DateString = $dayname & ", " & @MDAY & "." & @MON & "." & @YEAR
    GUICtrlSetData($DayDate, $DateString)
    EndIf
    EndFunc ;==>_SetDay
    Alles anzeigen
  • zeit berechnung zwischen zwei zeiten aber inklusive millisekunden

    • Schnuffel
    • 4. Juni 2025 um 18:22

    ein kleines Beispiel für die Berechnung:

    AutoIt
    ;~ #Region
    ;~ #pragma compile(FileVersion, 1.0.0.0)
    ;~ #pragma compile(LegalCopyright, © (Schnuffel))
    ;~ #pragma compile(ProductVersion, 1.0.0.0)
    ;~ ;#AutoIt3Wrapper_AU3Check_Parameters=-d -w 1 -w 2 -w 3 -w 4 -w 5 -w 6 -w 7
    ;~ #AutoIt3Wrapper_AU3Check_Stop_OnWarning=y
    ;~ #AutoIt3Wrapper_Outfile=%scriptfile%.exe
    ;~ #AutoIt3Wrapper_Res_Language=1031
    ;~ #AutoIt3Wrapper_Res_requestedExecutionLevel=asInvoker
    ;~ #AutoIt3Wrapper_Run_Au3Stripper=y
    ;~ #AutoIt3Wrapper_UseUpx=n
    ;~ #AutoIt3Wrapper_UseX64=y
    ;~ #Au3Stripper_Parameters=/sf /sv /mo /rm /rsln
    ;~ #EndRegion
    #cs===============================================================================
    AutoIt Version:		3.3.16.1
    
    Description:
    
    Author(s):      	Oliver Zimmermann (Schnuffel@autoit.de / Schnuffel@autoit.com)
    
    Changelog:
    -------------------------------------------------------------------------
    ! = Bugfix, + = Feature added, - = Feature removed, ~ = Behaviour changed
    -------------------------------------------------------------------------
    1.0.0.0 -
    
    #ce===============================================================================
    #include <ButtonConstants.au3>
    #include <GUIConstantsEx.au3>
    
    Global $s1000
    For $i = 0 To 999
    	$s1000 &= $i & "|"
    Next
    StringTrimRight($s1000, 1)
    Global $s60
    For $i = 0 To 59
    	$s60 &= $i & "|"
    Next
    StringTrimRight($s60, 1)
    Global $s24
    For $i = 0 To 23
    	$s24 &= $i & "|"
    Next
    StringTrimRight($s24, 1)
    
    Global $nMs1, $nMs2, $nMsDiff, $nErgHour, $nErgMin, $ErgSec, $nrgMsec, $nErgRest
    Global $hGUI = GUICreate("", 500, 400, -1, -1)
    GUISetFont(10)
    GUICtrlCreateLabel("Start:", 10, 10)
    GUICtrlCreateLabel("Hour:", 10, 30, 40, 20)
    Global $hHourStart = GUICtrlCreateCombo("", 50, 27, 50, 20)
    GUICtrlSetData(-1, $s24, 0)
    GUICtrlCreateLabel("Min:", 10, 60, 60, 20)
    Global $hMinStart = GUICtrlCreateCombo("", 50, 57, 50, 20)
    GUICtrlSetData(-1, $s60, 0)
    GUICtrlCreateLabel("Sek:", 10, 90, 60, 20)
    Global $hSecStart = GUICtrlCreateCombo("", 50, 87, 50, 20)
    GUICtrlSetData(-1, $s60, 0)
    GUICtrlCreateLabel("MSek:", 10, 120, 60, 20)
    Global $hMSecStart = GUICtrlCreateCombo("", 50, 117, 50, 20)
    GUICtrlSetData(-1, $s1000, 0)
    
    GUICtrlCreateLabel("Ende:", 200, 10)
    GUICtrlCreateLabel("Hour:", 200, 30, 40, 20)
    Global $hHourEnde = GUICtrlCreateCombo("", 250, 27, 50, 20)
    GUICtrlSetData(-1, $s24, 0)
    GUICtrlCreateLabel("Min:", 200, 60, 60, 20)
    Global $hMinEnde = GUICtrlCreateCombo("", 250, 57, 50, 20)
    GUICtrlSetData(-1, $s60, 0)
    GUICtrlCreateLabel("Sek:", 200, 90, 60, 20)
    Global $hSecEnde = GUICtrlCreateCombo("", 250, 87, 50, 20)
    GUICtrlSetData(-1, $s60, 0)
    GUICtrlCreateLabel("MSek:", 200, 120, 60, 20)
    Global $hMSecEnde = GUICtrlCreateCombo("", 250, 117, 50, 20)
    GUICtrlSetData(-1, $s1000, 0)
    GUISetFont(12)
    Global $hButton = GUICtrlCreateButton("calculate", 10, 170, 120, 40)
    GUICtrlCreateLabel("Ergebnis:", 140, 180, 80, 40)
    Global $hErgebnis = GUICtrlCreateLabel("", 220, 180, 120, 40)
    
    
    GUISetFont(10)
    Global $nMsg = GUIGetMsg()
    GUISetState()
    
    While 1
    	$nMsg = GUIGetMsg()
    	Switch $nMsg
    		Case -3
    			Exit
    		Case $hButton
    			$nMs1 = GUICtrlRead($hHourStart) * 3600000 + GUICtrlRead($hMinStart) * 60000 + GUICtrlRead($hSecStart) * 1000 + GUICtrlRead($hMSecStart)
    			$nMs2 = GUICtrlRead($hHourEnde) * 3600000 + GUICtrlRead($hMinEnde) * 60000 + GUICtrlRead($hSecEnde) * 1000 + GUICtrlRead($hMSecEnde)
    
    			$nMsDiff = $nMs2 - $nMs1
    			If $nMsDiff < 0 Then
    				MsgBox(0, "Error", "die zweite Zeit ist 'kleiner' als die erste Zeit!")
    			Else
    				$nErgHour = Floor($nMsDiff / 3600000)
    				$nErgRest = $nMsDiff - $nErgHour * 3600000
    				$nErgMin = Floor($nErgRest / 60000)
    				$nErgRest = $nErgRest - $nErgMin * 60000
    				$nErgSec = Floor($nErgRest / 1000)
    				$nErgMSec = $nErgRest - $nErgSec * 1000
    				GUICtrlSetData($hErgebnis, StringRight("0" & $nErgHour, 2) & ":" & StringRight("0" & $nErgMin, 2) & ":" & StringRight("0" & $nErgSec, 2) & ":" & StringRight("000" & $nErgMSec, 4))
    			EndIf
    	EndSwitch
    WEnd
    Alles anzeigen
  • das problem mit der maus und der minimierung

    • Schnuffel
    • 3. Juni 2025 um 07:43

    ich wollte dir nicht zu Nahe treten, aber nach zig Jahren hier im Forum ist es nunmal so, dass in der Regel nicht das eigentliche Problem benannt wird, sondern das Problem der eigenen Lösungsfindung. Wenn das bei dir nicht der Fall ist, dann entschuldige ich mich gern. ☺️

    Freut mich wenn wir helfen konnten und lass dich nicht von mir entmutigen 😉

  • das problem mit der maus und der minimierung

    • Schnuffel
    • 2. Juni 2025 um 11:33

    hier mal eine kleine Spielerei ^^

    Shift-Alt-d zum starten/stoppen

    Shift-Alt-x zum Beenden

    AutoIt
    HotKeySet("!+d", "OnOff")
    HotKeySet("!+x", "_X")
    Global $Duration = 5000 ; in ms
    Global $Move = 5 ; in px
    Global $Speed = 5 ; Mouse speed 0 to 100 (instantly to very slow)
    Global $MB_Time = 0.5 ; Time in Sec to show MsgBox
    Global $nS = 1 ; On/Off Switch at startup
    
    OnOff() ; initiate the first status
    
    While Sleep(10)
    WEnd
    Func OnOff()
    	$nS = Mod($nS + 1, 2)
    	If $nS = 0 Then
    		AdlibUnRegister("_MM")
    		MsgBox(262144 + 64, "Info", "MouseMover off", $MB_Time)
    	EndIf
    	If $nS = 1 Then
    		AdlibRegister("_MM", $Duration)
    		MsgBox(262144 + 64, "Info", "MouseMover on", $MB_Time)
    	EndIf
    EndFunc   ;==>OnOff
    Func _X()
    	MsgBox(262144 + 64, "Info", "MouseMover Exit", $MB_Time)
    	Exit
    EndFunc   ;==>_X
    Func _MM()
    	$MP = MouseGetPos()
    	MouseMove($MP[0] + $Move, $MP[1] + $Move, $Speed)
    	$MP = MouseGetPos()
    	MouseMove($MP[0] - $Move, $MP[1] - $Move, $Speed)
    EndFunc   ;==>_MM
    Alles anzeigen
  • das problem mit der maus und der minimierung

    • Schnuffel
    • 2. Juni 2025 um 10:46

    meist haben die User keine Adminrechte. Daher gibt es ja Tools wie den „MouseMover“

  • das problem mit der maus und der minimierung

    • Schnuffel
    • 2. Juni 2025 um 09:53

    aber es zeigt sich wieder einmal, das es für den Topic Ersteller besser wäre nach einer Lösung zu seinem Problem zu fragen, als sich selbst eine Lösung auszudenken und dann, ohne die ursächliche Problemstellung zu nennen, an diesem selbstgebauten Problem rumzudocktern.

    Um deinen Bildschirmschoner nicht aktiv werden zu lassen reichen vermutlich 3-4 Zeilen code.

    Eine GUI ist dabei nicht erforderlich. 😁

  • das problem mit der maus und der minimierung

    • Schnuffel
    • 1. Juni 2025 um 12:16

    meine Lösung:

    AutoIt
    #include <ButtonConstants.au3>
    #include <GUIConstantsEx.au3>
    #include <StaticConstants.au3>
    #include <WindowsConstants.au3>
    #include <Misc.au3>
    
    Global $Window = GUICreate("mouse - mouseing it!", 305, 185, -1, -1)
    Global $File = GUICtrlCreateMenu("File")
    Global $StartFile = GUICtrlCreateMenuItem("Start Mouse", $File)
    Global $StopFile = GUICtrlCreateMenuItem("Stop Mouse", $File)
    Global $ExitFile = GUICtrlCreateMenuItem("Exit Mouse", $File)
    Global $Help = GUICtrlCreateMenu("Help")
    Global $Info = GUICtrlCreateMenuItem("Infobox", $Help)
    Global $About = GUICtrlCreateMenuItem("About", $Help)
    Global $Mousefield = GUICtrlCreateGroup("Mousefield", 128, 16, 161, 121)
    GUICtrlCreateGroup("", -99, -99, 1, 1)
    Global $StartCheck = GUICtrlCreateCheckbox("Start Mouse", 24, 32, 81, 17)
    Global $Stop = GUICtrlCreateButton("Reset/Stop", 16, 80, 95, 25)
    Global $ExitBut = GUICtrlCreateButton("EXIT", 16, 112, 95, 25)
    GUISetState(@SW_SHOW)
    Global $windowX = WinGetPos($Window)[0]
    Global $windowY = WinGetPos($Window)[1]
    
    Global $dancing = False
    Global $step = 0
    Global $positions[4][2] = [[15, 15], [118, 15], [118, 90], [15, 90]] ; Relative Positionen in der GUI
    Global $lastMoveTime = TimerInit()
    
    While 1
    	$nMsg = GUIGetMsg()
    
    	Switch $nMsg
    		Case $GUI_EVENT_CLOSE, $ExitBut, $ExitFile
    			Exit
    
    		Case $StartCheck
    			If GUICtrlRead($StartCheck) = 1 Then
    				$dancing = True
    				$step = 0 ; Reset dance
    				$lastMoveTime = TimerInit()
    			EndIf
    
    		Case $StartFile
    			GUICtrlSetState($StartCheck, $GUI_CHECKED)
    			If GUICtrlRead($StartCheck) = 1 Then
    				$dancing = True
    				$step = 0 ; Reset dance
    				$lastMoveTime = TimerInit()
    			EndIf
    
    		Case $Stop, $StopFile
    			$dancing = False
    			GUICtrlSetState($StartCheck, $GUI_UNCHECKED)
    
    
    	EndSwitch
    
    	; Aktiviere die tanzende Maus nur wenn Checkbox gecheckt ist
    	If $dancing Then
    		If TimerDiff($lastMoveTime) > 5000 Then
    			; Hole Koordianten vom der linken oberen Ecke des GUI-Fensters
    			If Not BitAND(WinGetState($Window), 16) Then
    				$windowX = WinGetPos($Window)[0]
    				$windowY = WinGetPos($Window)[1]
    			EndIf
    			; Definiere die Bewegungsposition innerhalb des Fensters(Mousefield)
    			Local $fieldX = 140  ; X position relativ zum GUI-Fenster
    			Local $fieldY = 65    ; Y position relativ zum GUI-Fenster
    			Local $fieldWidth = 161  ; Breite von Mousefield
    			Local $fieldHeight = 121  ; Hoehe of Mousefield
    
    			; Berechne nun die neue Positionen
    			Local $xPos = $positions[$step][0] + $fieldX + $windowX
    			Local $yPos = $positions[$step][1] + $fieldY + $windowY
    
    			; Stelle sicher das die relative Abhaengigkeit gewaehrleistet bleibt.
    			If $xPos < $windowX + $fieldX Then $xPos = $windowX + $fieldX
    			If $yPos < $windowY + $fieldY Then $yPos = $windowY + $fieldY
    			If $xPos > $windowX + $fieldX + $fieldWidth Then $xPos = $windowX + $fieldX + $fieldWidth
    			If $yPos > $windowY + $fieldY + $fieldHeight Then $yPos = $windowY + $fieldY + $fieldHeight
    
    			; Setze den Mauszeiger an die berechnete Stelle
    			MouseMove($xPos, $yPos, 10)
    
    			$step += 1
    			If $step >= UBound($positions) Then $step = 0
    			$lastMoveTime = TimerInit()
    		EndIf
    	EndIf
    WEnd
    Alles anzeigen
  • AutoIt-Hackathon #3 "alte Zeiten"

    • Schnuffel
    • 19. Mai 2025 um 12:10

    da es dieses mal ein live-event war, hat das erste korrekte abgegebene Script gewonnen.

  • AutoIt-Hackathon #3 "alte Zeiten"

    • Schnuffel
    • 11. Mai 2025 um 21:28
    AutoIt
    Func _IntegerToRoman($sInteger)
    	Local $Return, $nAct, $aSign[5][3] = [['', '', ''], ["I", "V", "X"], ["X", "L", "C"], ["C", "D", "M"], ['M', '', '']]
    	For $i = StringLen($sInteger) To 1 Step -1
    		$nAct = StringLeft($sInteger, 1)
    		Switch $nAct
    			Case 1 To 3
    				For $j = 1 To $nAct
    					$Return &= $aSign[$i][0]
    				Next
    			Case 4
    				$Return &= $aSign[$i][0] & $aSign[$i][1]
    			Case 5 To 8
    				$Return &= $aSign[$i][1]
    				For $j = 1 To $nAct - 5
    					$Return &= $aSign[$i][0]
    				Next
    			Case 9
    				$Return &= $aSign[$i][0] & $aSign[$i][2]
    		EndSwitch
    		$sInteger = StringTrimLeft($sInteger, 1)
    	Next
    	Return $Return
    EndFunc   ;==>_IntegerToRoman
    Func _RomanToInteger($sRoman)
    	Local $Return, $aRoman = StringSplit($sRoman, ''), $mMap[]
    	$mMap["I"] = 1
    	$mMap["V"] = 5
    	$mMap["X"] = 10
    	$mMap["L"] = 50
    	$mMap["C"] = 100
    	$mMap["D"] = 500
    	$mMap["M"] = 1000
    	For $i = 1 To $aRoman[0]
    		If $i < $aRoman[0] Then
    			If $mMap[$aRoman[$i + 1]] <= $mMap[$aRoman[$i]] Then
    				$Return += $mMap[$aRoman[$i]]
    				ContinueLoop
    			EndIf
    			If $mMap[$aRoman[$i + 1]] > $mMap[$aRoman[$i]] Then
    				$Return -= $mMap[$aRoman[$i]]
    			EndIf
    		Else
    			$Return += $mMap[$aRoman[$i]]
    		EndIf
    	Next
    	Return $Return
    EndFunc   ;==>_RomanToInteger
    ; Bonus-Aufgabe für Ambitionierte ;-)
    Func _DateToRoman($sDate) ;Input date in the format "YYYY/MM/DD[ HH:MM:SS]", Output in same date-format with roman sign
    	Local $Return
    	If StringLen($sDate) > 10 And StringInStr($sDate, " ") Then
    		Local $aTemp = StringSplit($sDate, ' '), $aDate = StringSplit($aTemp[1], '/'), $aTime = StringSplit($aTemp[2], ':')
    		For $k = 1 To $aDate[0]
    			$Return &= _IntegerToRoman($aDate[$k]) & "/"
    		Next
    		$Return = StringTrimRight($Return, 1) & " "
    		For $k = 1 To $aTime[0]
    			$Return &= _IntegerToRoman($aTime[$k]) & ":"
    		Next
    		$Return = StringTrimRight($Return, 1)
    	Else
    		Local $aDate = StringSplit($sDate, '/')
    		For $k = 1 To $aDate[0]
    			$Return &= _IntegerToRoman($aDate[$k]) & "/"
    		Next
    		$Return = StringTrimRight($Return, 1)
    	EndIf
    	Return $Return
    EndFunc   ;==>_DateToRoman
    Alles anzeigen
  • AutoIt-Hackathon #3 "alte Zeiten"

    • Schnuffel
    • 10. Mai 2025 um 12:04

    Hallo und herzlich willkommen zum AutoIt-Hackathon #3

    Alles was ihr zur Teilnahme braucht, ist das Script, das unten im Code-Block eingefügt ist.
    Kopiert es vollständig in euren Editor und lest euch die Anleitung genau durch.

    Ihr könnt eigene Funktionen erstellen, Globale Variablen deklarieren usw ...

    Gewonnen hat, dessen Script die Tests zu 100% bewältigt und am schnellsten ist.

    Postet eure Lösung hier in diesen Thread. Abschreiben bringt nix, wenn die Lösung richtig ist. ;)

    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):rofl:

    Ich wünsche allen Teilnehmern
    happy coding :party:

    PS: Für künftige Hackathons ist es hilfreich zu wissen, wann die meisten Interessierten Zeit haben.
    Tragt euch bei Interesse in dieses Tool ein, dann kann ich planen. Danke

    Abfrage Zeitfenster Hackathon - nuudel
    Trage hier deine möglichen Zeiten ein, zu denen du an einem Live-Hackathon teilnehmen könntest. Der Zeitraum umfasst i.d.R. 1-2 Std. Die Tage sind nur…
    nuudel.digitalcourage.de
    AutoIt
    #cs 	 		****************** AutoIt Hackathon 2025 ******************
    
    	  Teil 3 - "alte Zeiten"
    	  für AutoIt Version >= 3.3.16.1
    	  Aufgabe:	Erstelle zwei Funktionen: _IntegerToRoman() & _RomanToInteger ( + eine Bonus-Aufgabe _DateToRoman() )
     	 		****************** AutoIt Hackathon 2025 ******************
    			1: _IntegerToRoman($sInteger)	erhält eine Integer Zahl ( 0 < Zahl < 4000 ) und gibt diese als Ausdruck einer römischen Zahl zurück
    				originale Beschreibung: https://leetcode.com/problems/integer-to-roman/description/
    
    				Sieben verschiedene Symbole stellen römische Ziffern mit den folgenden Werten dar:
    					Symbol Wert
    					I 1
    					V 5
    					X 10
    					L 50
    					C 100
    					D 500
    					M 1000
    
    				Römische Ziffern werden durch Anhängen der Umrechnungen von Dezimalstellenwerten vom höchsten zum niedrigsten Wert gebildet.
    				Für die Umwandlung einer Dezimalstelle in eine römische Zahl gelten die folgenden Regeln:
    
    				Wenn der Wert nicht mit 4 oder 9 beginnt, wählen Sie das Symbol des maximalen Wertes, der von der Eingabe subtrahiert werden kann,
    				hängen Sie dieses Symbol an das Ergebnis an, subtrahieren Sie seinen Wert und wandeln Sie den Rest in eine römische Zahl um.
    				Wenn der Wert mit 4 oder 9 beginnt, verwenden Sie die subtraktive Form, die ein Symbol vom folgenden Symbol subtrahiert,
    				z. B. 4 ist 1 (I) weniger als 5 (V): IV und 9 ist 1 (I) weniger als 10 (X): IX.
    				Es werden nur die folgenden subtraktiven Formen verwendet: 4 (IV), 9 (IX), 40 (XL), 90 (XC), 400 (CD) und 900 (CM).
    				Nur Potenzen von 10 (I, X, C, M) können höchstens 3 Mal hintereinander angehängt werden,
    				um Vielfache von 10 darzustellen. Sie können 5 (V), 50 (L) oder 500 (D) nicht mehrfach anhängen.
    				Wenn Sie ein Symbol 4 Mal anhängen müssen, verwenden Sie die subtraktive Form.
    
    				Wandeln Sie eine ganze Zahl in eine römische Zahl um.
    				Beispiel 1:
    					Eingabe: $sInteger = 3749
    					Ausgabe: "MMMDCCXLIX"
    
    					Erläuterung:
    					3000 = MMM als 1000 (M) + 1000 (M) + 1000 (M)
    					 700 = DCC als 500 (D) + 100 (C) + 100 (C)
    					  40 = XL als 10 (X) weniger von 50 (L)
    					   9 = IX als 1 (I) weniger von 10 (X)
    					Hinweis: 49 ist nicht 1 (I) weniger von 50 (L), da die Umrechnung auf Dezimalstellen basiert.
    
    				Beispiel 2:
    					Eingabe: $sInteger = 58
    					Ausgabe: "LVIII"
    
    					Erläuterung:
    					50 = L
    					 8 = VIII
    
    				Beispiel 3:
    					Eingabe: $sInteger = 1994
    					Ausgabe: "MCMXCIV"
    
    					Erläuterung:
    					1000 = M
    					 900 = CM
    					  90 = XC
    					   4 = IV
    
    				Beschränkungen:
    					1 <= $sInteger <= 3999
    
    			2: _RomanToInteger($sRoman) 	erhält eine Ausdruck einer römische Zahl und gibt die Jahreszahl als Integer zurück
    				originale Beschreibung: https://leetcode.com/problems/roman-to-integer/description/
    
    				Die römischen Ziffern werden durch sieben verschiedene Symbole dargestellt: I, V, X, L, C, D und M.
    					Symbol Wert
    					I 1
    					V 5
    					X 10
    					L 50
    					C 100
    					D 500
    					M 1000
    
    				Zum Beispiel wird 2 als II in römischen Zahlen geschrieben, einfach zwei Einsen addiert. 12 wird als XII geschrieben,
    				was einfach X + II ist. Die Zahl 27 wird als XXVII geschrieben, d. h. XX + V + II.
    
    				Römische Ziffern werden normalerweise von links nach rechts von der größten zur kleinsten Zahl geschrieben.
    				Die Zahl für vier ist jedoch nicht IIII. Stattdessen wird die Zahl Vier als IV geschrieben.
    				Da die Eins vor der Fünf steht, subtrahieren wir sie und erhalten vier.
    				Das gleiche Prinzip gilt für die Zahl Neun, die als IX geschrieben wird. Es gibt sechs Fälle, in denen die Subtraktion verwendet wird:
    
    					I kann vor V (5) und X (10) gesetzt werden, um 4 und 9 zu bilden.
    					X kann vor L (50) und C (100) platziert werden, um 40 und 90 zu ergeben.
    					C kann vor D (500) und M (1000) platziert werden, um 400 und 900 zu ergeben.
    
    				Wandeln Sie eine römische Zahl in eine ganze Zahl um.
    
    				Beispiel 1:
    					Eingabe: s = "III"
    					Ausgabe: 3
    					Erläuterung: III = 3.
    
    				Beispiel 2:
    					Eingabe: s = "LVIII"
    					Ausgabe: 58
    					Erläuterung: L = 50, V= 5, III = 3.
    
    				Beispiel 3:
    					Eingabe: s = "MCMXCIV"
    					Ausgabe: 1994
    					Erläuterung: M = 1000, CM = 900, XC = 90 und IV = 4.
    
    				Beschränkungen:
    					1 <= $sRoman.length <= 15
    					s enthält nur die Zeichen ('I', 'V', 'X', 'L', 'C', 'D', 'M').
    					Es wird garantiert, dass s eine gültige römische Zahl im Bereich [1, 3999] ist.
    
    	Bonus Aufgabe:
    			3: _DateToRoman() erhält ein Datum im Format "YYYY/MM/DD[ HH:MM:SS]" wobei eine Zeitangabe optional, aber möglich ist
    				Erstelle eine Funktion	die ein Date-Format im "römischen Format" zurückgibt.
    				Die Trennzeichen sollen dabei unverändert erhalten bleiben.
    
    				zusätzliche Funktionen 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 jeweilige Funktion samt Namen vorgegeben.
    				Diese sind unten ersichtlich, müssen so verwendet werden und aus ihnen muss das Ergebnis als Return erfolgen.
    
          Prüfung:  Die Funktion _Check() beinhaltet beispielhafte Prüfungsdatensätze und jeweils einen Hash der Lösung
    				Die Ausgabe zeigt an, wie viel Prozent dein Script bereits erfüllt.
    				Sobald dein Script 100% korrekt ist, poste dein Script im Thread
    
    	   Sieger:	GEWONNEN HAT, ...
    
    PS:				Die Verwendung von #includes ist gestattet, müssen aber im Script mit angegeben werden!
    
    #ce
    ; Um dein Script zu überprüfen, drücke F5.
    
    ; ================================= entferne alle Leer- und Kommentarzeilen und poste diesen Code-Block im Thread ==================================
    Func _IntegerToRoman($sInteger)
    	Local $Return
    
    	Return $Return
    EndFunc   ;==>_IntegerToRoman
    Func _RomanToInteger($sRoman)
    	Local $Return
    
    	Return $Return
    EndFunc   ;==>_RomanToInteger
    
    ; Bonus-Aufgabe für Ambitionierte ;-)
    Func _DateToRoman($sDate) ;Input date in the format "YYYY/MM/DD[ HH:MM:SS]", Output in same date-format with roman sign
    	Local $Return
    
    	Return $Return
    EndFunc   ;==>_DateToRoman
    ; ================================= entferne alle Leer- und Kommentarzeilen und poste diesen Code-Block im Thread ==================================
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ; Funktion zur Überprüfung des eigenen Scripts. Nicht mit in den Thread laden!
    #include <Crypt.au3>
    _Check_IntegerToRoman()
    _Check_RomanToInteger()
    _Check_DateToRoman()
    
    Func _Check_IntegerToRoman()
    	Local $aPruefDaten[][] = [[], _
    			[1, "0xA83DD0CCBFFE39D071CC317DDF6E97F5C6B1C87AF91919271F9FA140B0508C6C"], _
    			[46, "0x101AC3C99D6FCEDF8C1A6E3EAC18697FB4BEAA4E4510A45C14D5233F3A09D459"], _
    			[728, "0x0934E3E7BF156E0EC2E6535F53A15A8E549315B40CA4EB849DBFD8ABCDB32BD1"], _
    			[1999, "0xC92979E7626148228B837A2904992490E20AFCB7E145F2C15F3B528FDB1BA566"], _
    			[2476, "0xC386049C1C68575AB4C0EA9AE781FF294080179B552619253DB5F92B4C4D0380"], _
    			[3888, "0x567A7E66D8EFD19459873F5836896987ECC6B07BF42C7EB98834B952EA39B0EA"]]
    	Local $aTestdaten[5]
    	Local $correct = 0
    	For $i = 1 To UBound($aPruefDaten) - 1
    		$CryptResultData = _Crypt_HashData(_IntegerToRoman($aPruefDaten[$i][0]), $CALG_SHA_256)
    		If $CryptResultData = $aPruefDaten[$i][1] Then $correct += 1
    	Next
    	ConsoleWrite("Testergebnis _IntegerToRoman: " & 100 / (UBound($aPruefDaten) - 1) * $correct & "%" & @CRLF)
    EndFunc   ;==>_Check_IntegerToRoman
    Func _Check_RomanToInteger()
    	Local $aPruefDaten[][] = [["", ""], _
    			["XXIX", "0x79095D9004930C349E99C30F6C93E7BB5541F6EF7BB6883C04163E94CF82110A"], _
    			["CXXII", "0x4F55412B85445F7D15757C8214BE4581AB8A98AF792A98F3FD2D049FFCCDC494"], _
    			["CCCLIX", "0xD727F912336CA13E8E9BA1372377E3AC970AE44FE3306151E96516970B235659"], _
    			["MCDLV", "0x66B962775512A326EF7A82D11F2CB7EC6A16DCEB2F1A3489373F0119A7F7A021"], _
    			["MMCDXLIX", "0xEF3F5A3D3B8D5019C747679E70654A4A28F8771CD63C5B30C3A5742B6FBA7074"], _
    			["MMMCCCXXXIX", "0x54ACE80191BB37C31A8F7EBEAA062AFD02BE72FBD755637AC68FC1AD2D03B9BB"]]
    	Local $aTestdaten[5]
    	Local $correct = 0
    	For $i = 1 To UBound($aPruefDaten) - 1
    		$CryptResultData = _Crypt_HashData("Testdaten:" & _RomanToInteger($aPruefDaten[$i][0]), $CALG_SHA_256)
    		If $CryptResultData = $aPruefDaten[$i][1] Then $correct += 1
    	Next
    	ConsoleWrite("Testergebnis _RomantoInteger: " & 100 / (UBound($aPruefDaten) - 1) * $correct & "%" & @CRLF)
    EndFunc   ;==>_Check_RomanToInteger
    Func _Check_DateToRoman() ;Date range  = 01.01.0001 - 31.12.3999 (remember, in roman is no "0" !)
    	Local $aPruefDaten[][] = [["", ""], _
    			["01/05/1028", ""0x5CD51BB77D63FFDACB6BFCBC3C6C1D1B3056A3E140DF629CAC6D49D551BE55EA""], _
    			["23/05/2011 12", "0x13D4359153330C8587D7DB313A8C8758DE26B0FAA53FC93DACDBDED553F8694B"], _
    			["05/05/1777 16:22", "0xAFD10C28163A328A2C25783D70457DF4D63928CB00004715D648BB0D889A5703"], _
    			["31/12/2679 14:55:38", "0xDEE1E331FB56FA93C4EA51AACBF578A44149505A7A4239CC2D8D6058DC179BF7"]]
    	Local $aTestdaten[5]
    	Local $correct = 0
    	For $i = 1 To UBound($aPruefDaten) - 1
    		$CryptResultData = _Crypt_HashData("Test:" & _DateToRoman($aPruefDaten[$i][0]), $CALG_SHA_256)
    		If $CryptResultData = $aPruefDaten[$i][1] And $CryptResultData <> '0xE3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855' Then $correct += 1
    	Next
    	ConsoleWrite("Testergebnis _DateToRoman: " & 100 / (UBound($aPruefDaten) - 1) * $correct & "%" & @CRLF)
    EndFunc   ;==>_Check_DateToRoman
    Alles anzeigen
  • array(s) nach daten durchsuchen und zuordnen und damit dann ein neues array anlegen

    • Schnuffel
    • 3. Mai 2025 um 15:07

    hmm, ich würde dir vorschlagen dich zumindest hier eines konkreten Themas anzunehmen und ausschließlich das hier zu besprechen und Lösungen für dabei auftretende Probleme zu finden.

    Wenn du daraus einen Synergie-Effekt erzielst und deine Lernkurve dir in weiteren Themen Hilfestellung leistet, dann gut. Ansonsten wenn das erste Thema fertig ist, dann das nächste. Deine Fragen werden von alleine weniger wenn das Verständnis wächst.

    Du brauchst vermutlich erstmal einen Ansatz, wie man deine Problemstellungen überhaupt digitalisiert um diese auswerten und verarbeiten zu können.

    Welches Frontend schlussendlich davor steht, ob du Farben, Wörter und sonstwas arrangieren und damit "spielen" willst ist nur Nebensache.

    Daher:

    Stelle 1 Projekt von dir ein, stelle deine bisherigen Bemühungen anhand deines Scriptes hier ein und stelle deine Frage.

    Die meisten aktiven Mitglieder sind Lösungsfinder und haben Spaß daran solche Aufgaben zu meistern.

    PS: in der Kürze liegt die Würze. Worauf ich keinen Bock habe ist, mir erstmal ein 2-seitiges Gedankenkonstrukt durchzulesen, um dann festzustellen dass die eigentliche Frage gar nicht behandelt wird. Deshalb mach es kurz und knapp. Das hilft auch, Dinge zu optimieren und komprimieren in Ihrer Betrachtung.

    PS PS: Wir fragen deshalb nach dem Sinn deines Scriptes, da wir White-hats sind und niemandem helfen wollen Scripte zu schreiben, die andere Ärgern oder um sich selbst zu bereichern mit z.B. Bots.

  • array(s) nach daten durchsuchen und zuordnen und damit dann ein neues array anlegen

    • Schnuffel
    • 3. Mai 2025 um 13:08

    mal am Rande die Frage, was möchtest du eigentlich erreichen?
    Ich habe bisher verstanden, dass es Usereingaben und Vorgaben gibt, dass ganze mit Farben und Buchstaben zu tun hat.

    Mehr verstehe ich bisher nicht.
    Vielleicht magst du mir in max. 3 Sätzen ( ;) ) erklären, was du eigentlich programmieren möchtest.

  • Scite - Anzahl an Tabs größer 20

    • Schnuffel
    • 29. April 2025 um 15:05

    Quelle: https://www.autoitscript.com/forum/topic/17…comment-1282689

    Zitat

    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.

  • Datenbank : Teil 1 erstellen einer DB

    • Schnuffel
    • 26. April 2025 um 18:32

    das Zauberwort hier ist "Normalisierung" ;)

    besser gesagt: die 3. Normalform ist Standard

  • AutoIt-Hackathon #2 CypherEnigma

    • Schnuffel
    • 23. April 2025 um 08:58

    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 ;)

  • AutoIt-Hackathon #2 CypherEnigma

    • Schnuffel
    • 23. April 2025 um 08:57

    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

  • AutoIt-Hackathon #2 CypherEnigma

    • Schnuffel
    • 23. April 2025 um 08:12

    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.

  • AutoIt-Hackathon #2 CypherEnigma

    • Schnuffel
    • 22. April 2025 um 20:00

    Ich danke allen Teilnehmern, dass sie sich so für diese Runde
    des Hackathon-Wettbewerb begeistert haben. :rock:

    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

    Teilnehmer32-bit Ergebnis in Sekunden64-bit Ergebnis in Sekunden
    AspirinJunkey5.71898385.32926829
    chesstiger6.749411816.48062599
    Eukalyptus7.181518556.42435041
    Kanashius6.936774366.46164125
    Mars5.8313455.41359282
    Moombasabgebrochen, da 10*2000 Durchläufe ca. 2,7 Std. gedauert hätten
    Schnuffel27.2353469625.91358436
    UEZ6.677574666.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:

    AutoIt
    #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   ;==>_DeCypherEnigma
    Alles anzeigen

    Es 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. :klatschen:

    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.

  • AutoIt-Hackathon #2 CypherEnigma

    • Schnuffel
    • 22. April 2025 um 15:18

    yep, betrachte die als 1 Gruppe und verschiebe dann

  • AutoIt-Hackathon #2 CypherEnigma

    • Schnuffel
    • 22. April 2025 um 14:24

    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

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™