Da hast du recht!
Dann bräucht ma noch einen Flag4, mit dem sich der Benutzer aussuchen kann, ob er ein Array haben will, oder nicht!
Weiters fällt mir grad ein:
Wenn man SubString leer lässt und einen Delimiter definiert (z.B: Leerzeichen), dann sollten alle Zeichen mit Ausnahme des Delimiters gezählt werden.
Wäre das sinnvoll?
lgE
Hi All
Ich starte hiermit mal den µit - Juli und hoffe, daß die Aufgabenstellung interessant ist und weiters, daß diese Funktion nicht schon existiert 
Aufgabe:
Schreibe eine Funktion, welche zählt, wie oft ein Substring in einem String vorkommt!
_StringInStrCount( "String", "SubString" [, $bSens=False [, $bPartial=False [, $sDelimiter='' [, $bRetType=False]]]])
String = String in dem gesucht werden soll
SubString = String nach dem gesucht werden soll
$bSens = Casesensitive True/False
(Sollte klar sein)
$bPartial = Wenn True, dann werden nur die alleinstehenden SubStrings gezählt
( True: "Test Testosteron" ; False: "Test Testosteron")
$sDelimiter = Wenn nicht '' , dann soll der SubString bei diesem Zeichen gesplittet werden und nach allen Teilen gesucht werden.
(SubString='Test Muster':
$sDelimiter='' : 'Test Muster Das ist ein Muster und ein Test'
$sDelimiter=' ' : 'Test Muster Das ist ein Muster und ein Test' (SubString wird in diesem Fall beim Leerzeichen getrennt und nach allen Teilen einzeln gesucht)
$bRetType = False: Gesammtanzahl wird zurückgegeben; True: ein Array mit den Einzelcounts wird zurückgegeben
($aReturn[0] = Anzahl der Einträge, $aReturn[1] = Anzahl des 1 TeilSubStrings ...)
Wenn SubString leer ist, dann werden alle Zeichen gezählt, mit Ausnahme des Delimiters (Flag3)
z.B.: SubString='' Flag3=';' => '1234;5678' = 8 Zeichen
In diesem Fall soll auch bei Array-Rückgabe die Gesammtsumme verwendet werden $aReturn[1]=8
Ich hoffe die Angaben sind verständlich!
Bewertet werden Geschwindigkeit und Größe.
Teilnehmer senden bitte Ihre Funktion an mich per PM.
lgE
EDIT:
_StringInStrCount($sString, $sSearch='', $bSens=False, $bPartial=False, $sDelim='', $bReturn=False)
$sStringzu durchsuchender String
$sSearchSuchbegriff(e)
$bSensTrue = Case Sensitiv / False = nicht Case Sensitiv
$bPartialTrue = Suchbegriff auch als Teilstring / False = Suchbegriff alleinstehend
$sDelimTrenner bei mehreren Suchbegriffen
$bReturnTrue = Rückgabe Array / False = Rückgabe String
Bedingungen:
$sSearch = Leerstring UND $sDelim = Leerstring ==> Rückgabe Anzahl ALLER Zeichen
$sSearch = Leerstring UND $sDelim = String ==> Rückgabe Anzahl ALLER Zeichen OHNE $sDelim
$bReturn = True==> [0]=Anzahl Ergebnisse, [1]..[n]=Anzahl Begriff 1..n
$bReturn = False==> String Anzahl Summe ALLER BegriffeTestSuite:
$sText = "Und Bund rund Undelete und Fundbüro; Und. und! und? und'" & ' und" ' & "Und" & @LF & "Rund" & @CR & "Rund" & @CRLF & "Rund;" & @CRLF & "Aber Aberglaube labern makaber aber"
; -Send -Part +Send -Part +Sens +Part -Sens +Part
;und 8 5 11 15
;aber 2 1 3 5
_Check(1, _StringInStrCount($sText, "und", False, False, "", False), 
_Check(2, _StringInStrCount($sText, "und", True, False, "", False), 5)
_Check(3, _StringInStrCount($sText, "und", True, True, "", False), 11)
_Check(4, _StringInStrCount($sText, "und", False, True, "", False), 15)
_Check(5, _StringInStrCount($sText, "aber", False, False, "", False), 2)
_Check(6, _StringInStrCount($sText, "aber", True, False, "", False), 1)
_Check(7, _StringInStrCount($sText, "aber", True, True, "", False), 3)
_Check(8, _StringInStrCount($sText, "aber", False, True, "", False), 5)
_Check(9, _StringInStrCount($sText, "und;aber", False, False, ";", False), 10)
_Check(10, _StringInStrCount($sText, "und;aber", True, False, ";", False), 6)
_Check(11, _StringInStrCount($sText, "und;aber", True, True, ";", False), 14)
_Check(12, _StringInStrCount($sText, "und;aber", False, True, ";", False), 20)
_Check(13, _StringInStrCount($sText, "und;aber", False, False, ";", True), "2;8;2")
_Check(14, _StringInStrCount($sText, "und;aber", True, False, ";", True), "2;5;1")
_Check(15, _StringInStrCount($sText, "und;aber", True, True, ";", True), "2;11;3")
_Check(16, _StringInStrCount($sText, "und;aber", False, True, ";", True), "2;15;5")
_Check(17, _StringInStrCount($sText, "", False, True, "", False), 119)
_Check(17, _StringInStrCount($sText, "", False, True, " ", False), 104)
Func _StringInStrCount($sString, $sSubString, $bSens = False, $bPartial = False, $sDelimiter = '', $bRetType = False)
EndFunc ;==>_StringInStrCount
Func _Check($i, $j, $k)
Local $sj = "", $sk = ""
ConsoleWrite("Test " & $i & ": ")
Switch StringInStr($k, ";")
Case False
If $j = $k Then
ConsoleWrite(" Richtig: " & @TAB & $j & @LF)
Else
ConsoleWrite(" Falsch: " & @TAB & $j & @TAB & " (richtig wäre: " & $k & ")" & @LF)
EndIf
Case Else
$k = StringSplit($k, ";", 2)
If Not IsArray($j) Then
ConsoleWrite(" Falsch: " & @TAB & " Rückgabe ist kein Array" & @LF)
Return
EndIf
If UBound($j) <> UBound($k) Then
For $l = 0 To UBound($j) - 1
$sj &= " " & $j[$l]
Next
For $l = 0 To UBound($k) - 1
$sk &= " " & $k[$l]
Next
ConsoleWrite(" Falsch: " & @TAB & $sj & @TAB & " (richtig wäre: " & $sk & ")" & @LF)
Return
EndIf
Local $bRichtig = True
For $l = 0 To UBound($j) - 1
If $j[$l] <> $k[$l] Then $bRichtig = False
$sj &= " " & $j[$l]
$sk &= " " & $k[$l]
Next
If $bRichtig Then
ConsoleWrite(" Richtig: " & @TAB & $sk & @LF)
Else
ConsoleWrite(" Falsch: " & @TAB & $sj & @TAB & " (richtig wäre: " & $sk & ")" & @LF)
EndIf
EndSwitch
EndFunc ;==>_Check
Man könnte das auch so machen:
[autoit]While 1
Sleep(1000)
WEnd
Func OnAutoItExit()
If @exitMethod <> 4 Then Exit ; Nachfolgender Code wird nur ausgeführt, wenn Windows heruntergefahren wird...
SplashTextOn("Windows wird heruntergefahren...","Windows wird heruntergefahren...",250,50)
Sleep(1000000)
EndFunc
Allerdings hat man nicht viel Zeit, denn das Script wird nach wenigen Augenblicken (abhängig von den Systemeinstellungen) von Windows gekillt.
evtl kann man den Shutdown noch mit "shutdown.exe -a" unterbrechen!?
lgE
Ich denke mal, bei SciteLite (bei der Autoitinstall dabei) sind nicht alle Funktionen integriert.
Deshalb werden manche nicht blau angezeigt; Und beim drücken auf F1 öffnet sich auch nicht die richtige Seite der Hilfe.
Das Script ansich hätte sicher funktioniert, denn der Interpreter ist unabhängig vom Editor...
lgE
Wenn man nicht nur die Maus, sondern auch jede Tastaturkommandos haben will (so wie beim Bildschirmschoner),
dann kann man folgende Funktion verwenden:
#include <Timers.au3>
[/autoit][autoit][/autoit][autoit]Global $iTimer
[/autoit][autoit][/autoit][autoit]While 1
$iTimer = _Timer_GetIdleTime()
Select
Case $iTimer < 5000
ToolTip("Mache nichts!" & @LF & "Keine Eingabe seit " & Round($iTimer / 1000) & " Sekunden")
Case Else
ToolTip("5 Sekunden überschritten.." & @LF & "Keine Eingabe seit " & Round($iTimer / 1000) & " Sekunden")
EndSelect
Sleep(500)
WEnd
lgE
Hi
Hast du Autoit Version 3.3.0.0 ?
Hast du Scite4Autoit extra installiert?
Auch bei der aktuellen Beta hab ich keine Probleme...
lgE
Hi
Wenn dir die Infos reichen, die du auch via Rechtsklick-Eigenschaften ansehen kannst, dann such mal nach der _ExtProp.au3
Ich würde das allerdings mit ffmpeg.exe machen und die Infos via Stdoutread auslesen.
Folgende Funktion hab ich schnell mal aus meinem Video-Vorschaubild-Generator entnommen.
Mußt du anpassen, damit du an den Codec kommst:
Func _CheckMovieLength($sMovieFile)
Local $sFFmpeg = ""
Local $hFFmpeg = Run('ffmpeg.exe -i "' & $sMovieFile & '"', @ScriptDir, @SW_HIDE, 0x4)
While 1
$sFFmpeg &= StderrRead($hFFmpeg)
If @error Then ExitLoop
WEnd
$sFFmpeg = StringLeft(StringTrimLeft($sFFmpeg, StringInStr($sFFmpeg, "Duration:") + 9),
Local $iTicks = _TimeToTicks(StringLeft($sFFmpeg, 2), StringMid($sFFmpeg, 4, 2), StringMid($sFFmpeg, 7, 2))
Return $iTicks
EndFunc ;==>_CheckMovieLength
lgE
Hir ist mal die Betaversion von meinem Beitrag.
Ein Bild-Puzzle-Spiel
#include <GUIConstantsEx.au3>
#include <Array.au3>
#include <File.au3>
#include <GDIPlus.au3>
#include <EditConstants.au3>
#include <WindowsConstants.au3>
Opt("GUIOnEventMode", 1)
[/autoit] [autoit][/autoit] [autoit]Global $iTile = 0, $iSize, $hLabel[5][5], $aField[5][5][3]
[/autoit] [autoit][/autoit] [autoit]Global $aFiles = _FileListToArray(@ScriptDir, "*.jpg", 1)
_ArrayCombine($aFiles, _FileListToArray(@ScriptDir, "*.bmp", 1))
_ArrayCombine($aFiles, _FileListToArray(@ScriptDir, "*.tif", 1))
_ArrayCombine($aFiles, _FileListToArray(@ScriptDir, "*.gif", 1))
_ArrayCombine($aFiles, _FileListToArray(@ScriptDir, "*.png", 1))
If Not IsArray($aFiles) Or $aFiles[0] < 1 Then
MsgBox(0, "Error", "Keine Bilder gefunden")
Exit
EndIf
_GDIPlus_Startup()
[/autoit] [autoit][/autoit] [autoit]Global $hImage, $iWidth, $iHeight
Global $hPenWhite = _GDIPlus_PenCreate(0x44FFFFFF, 2)
Global $hPenBlack = _GDIPlus_PenCreate(0x44000000, 2)
Global $hBrushBK = _GDIPlus_BrushCreateSolid(0xFF6C99B4)
Global $hGui = GUICreate("SchiebePuzzle", 452, 500)
GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit")
GUISetOnEvent($GUI_EVENT_RESTORE, "_ReDraw")
GUISetBkColor(0x6C99B4)
GUICtrlCreateLabel("", 4, 4, 444, 444)
GUICtrlSetState(-1, $GUI_DISABLE)
GUICtrlSetBkColor(-1, 0x558097)
GUICtrlCreateLabel("", 6, 6, 442, 442)
GUICtrlSetState(-1, $GUI_DISABLE)
GUICtrlSetBkColor(-1, 0x88B8D8)
GUICtrlCreateLabel("", 6, 6, 440, 440)
GUICtrlSetState(-1, $GUI_DISABLE)
GUICtrlSetBkColor(-1, 0x6C99B4)
GUICtrlCreateLabel("Anzahl der Felder:", 10, 468, 90, 20)
Global $hInput = GUICtrlCreateInput(3, 100, 465, 30, 20, $ES_READONLY)
GUICtrlCreateUpdown(-1)
GUICtrlSetLimit(-1, 5, 2)
GUICtrlSetOnEvent(-1, "_SetTile")
GUICtrlCreateButton("Mischen", 160, 465, 80, 20)
GUICtrlSetOnEvent(-1, "_Randomize")
GUICtrlCreateButton("Neues Bild", 260, 465, 80, 20)
GUICtrlSetOnEvent(-1, "_LoadRandomImage1")
GUICtrlCreateButton("Beenden", 360, 465, 80, 20)
GUICtrlSetOnEvent(-1, "_Exit")
GUISetState()
Global $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hGui)
GUIRegisterMsg($WM_PAINT, '_Redraw')
_LoadRandomImage()
_SetTile()
While 1
Sleep(100)
WEnd
Func _MoveField()
Local $iX, $iY, $iNX, $iNY, $iDir
For $i = 0 To $iTile - 1
For $j = 0 To $iTile - 1
If $hLabel[$i][$j] = @GUI_CtrlId Then
$iX = $i
$iY = $j
ExitLoop 2
EndIf
Next
Next
If $aField[$iX][$iY][2] <> 2 Then Return
$iNX = $iX
$iNY = $iY
Select
Case $iX > 0 And $aField[$iX - 1][$iY][2] = 0
$iNX = $iX - 1
$iDir = 1
Case $iX < $iTile - 1 And $aField[$iX + 1][$iY][2] = 0
$iNX = $iX + 1
$iDir = 2
Case $iY > 0 And $aField[$iX][$iY - 1][2] = 0
$iNY = $iY - 1
$iDir = 3
Case $iY < $iTile - 1 And $aField[$iX][$iY + 1][2] = 0
$iNY = $iY + 1
$iDir = 4
EndSelect
For $i = 0 To $iSize Step 5
Switch $iDir
Case 1
_DrawField($iX, $iY, -$i, 0)
Case 2
_DrawField($iX, $iY, $i, 0)
Case 3
_DrawField($iX, $iY, 0, -$i)
Case 4
_DrawField($iX, $iY, 0, $i)
EndSwitch
Sleep(10)
Next
$aField[$iNX][$iNY][0] = $aField[$iX][$iY][0]
$aField[$iNX][$iNY][1] = $aField[$iX][$iY][1]
$aField[$iNX][$iNY][2] = $aField[$iX][$iY][2]
$aField[$iX][$iY][2] = False
GUICtrlSetBkColor($hLabel[$iX][$iY], 0x6C99B4)
_DrawField($iNX, $iNY)
_SetFreeField()
EndFunc ;==>_MoveField
Func _LoadRandomImage1()
_WinAPI_RedrawWindow($hGui)
_LoadRandomImage()
_ReDraw()
EndFunc ;==>_LoadRandomImage1
Func _LoadRandomImage($Orig = False)
Local $iRandom = Random(1, $aFiles[0], 1)
If $iRandom = 0 Or $aFiles[0] = 1 Then $iRandom = 1
If $Orig = False Then $hImage = _GDIPlus_ImageLoadFromFile(@ScriptDir & "\" & $aFiles[$iRandom])
$iWidth = _GDIPlus_ImageGetWidth($hImage)
$iHeight = _GDIPlus_ImageGetHeight($hImage)
For $i = 0 To $iTile - 1
For $j = 0 To $iTile - 1
GUICtrlSetCursor($hLabel[$i][$j], 2)
$aField[$i][$j][0] = $i * $iSize
$aField[$i][$j][1] = $j * $iSize
$aField[$i][$j][2] = 1
Next
Next
$aField[0][0][2] = 0
$aField[1][0][2] = 2
$aField[0][1][2] = 2
GUICtrlSetCursor($hLabel[1][0], 0)
GUICtrlSetCursor($hLabel[0][1], 0)
EndFunc ;==>_LoadRandomImage
Func _Randomize()
GUIRegisterMsg($WM_PAINT, '')
Local $iX = 0, $iY = 0, $iNX, $iNY, $iDir
For $i = 0 To $iTile - 1
For $j = 0 To $iTile - 1
If $aField[$i][$j][2] = 0 Then
$iX = $i
$iY = $j
ExitLoop 2
EndIf
Next
Next
For $c = 1 To 500
Do
$iNX = $iX
$iNY = $iY
$iDir = Random(1, 4, 1)
Select
Case $iDir = 2 And $iX > 0
$iNX = $iX - 1
Case $iDir = 1 And $iX < $iTile - 1
$iNX = $iX + 1
Case $iDir = 4 And $iY > 0
$iNY = $iY - 1
Case $iDir = 3 And $iY < $iTile - 1
$iNY = $iY + 1
EndSelect
Until $iX <> $iNX Or $iY <> $iNY
$aField[$iX][$iY][0] = $aField[$iNX][$iNY][0]
$aField[$iX][$iY][1] = $aField[$iNX][$iNY][1]
$aField[$iX][$iY][2] = $aField[$iNX][$iNY][2]
$aField[$iNX][$iNY][2] = False
GUICtrlSetBkColor($hLabel[$iNX][$iNY], 0x6C99B4)
_DrawField($iX, $iY)
$iX = $iNX
$iY = $iNY
Next
_ReDraw()
_SetFreeField()
GUIRegisterMsg($WM_PAINT, '_Redraw')
EndFunc ;==>_Randomize
Func _SetFreeField()
For $i = 0 To $iTile - 1
For $j = 0 To $iTile - 1
GUICtrlSetCursor($hLabel[$i][$j], 2)
If $aField[$i][$j][2] <> 0 Then $aField[$i][$j][2] = 1
Next
Next
For $i = 0 To $iTile - 1
For $j = 0 To $iTile - 1
If $aField[$i][$j][2] = False Then
If $i > 0 Then
GUICtrlSetCursor($hLabel[$i - 1][$j], 0)
$aField[$i - 1][$j][2] = 2
EndIf
If $i < $iTile - 1 Then
GUICtrlSetCursor($hLabel[$i + 1][$j], 0)
$aField[$i + 1][$j][2] = 2
EndIf
If $j > 0 Then
GUICtrlSetCursor($hLabel[$i][$j - 1], 0)
$aField[$i][$j - 1][2] = 2
EndIf
If $j < $iTile - 1 Then
GUICtrlSetCursor($hLabel[$i][$j + 1], 0)
$aField[$i][$j + 1][2] = 2
EndIf
EndIf
Next
Next
EndFunc ;==>_SetFreeField
Func _DrawField($x, $y, $iOX = 0, $iOY = 0)
If $aField[$x][$y][2] = False Then Return
Local $iX = $aField[$x][$y][0]
Local $iY = $aField[$x][$y][1]
Switch True
Case $iOX > 0
_GDIPlus_GraphicsFillRect($hGraphics, 6 + $x * $iSize, 6 + $y * $iSize, $iOX, $iSize, $hBrushBK)
Case $iOX < 0
_GDIPlus_GraphicsFillRect($hGraphics, 6 + $x * $iSize + $iSize + $iOX, 6 + $y * $iSize, -$iOX, $iSize, $hBrushBK)
Case $iOY > 0
_GDIPlus_GraphicsFillRect($hGraphics, 6 + $x * $iSize, 6 + $y * $iSize, $iSize, $iOY, $hBrushBK)
Case $iOY < 0
_GDIPlus_GraphicsFillRect($hGraphics, 6 + $x * $iSize, 6 + $y * $iSize + $iSize + $iOY, $iSize, -$iOY, $hBrushBK)
EndSwitch
_GDIPlus_GraphicsDrawImageRectRect($hGraphics, $hImage, $iX, $iY, $iSize, $iSize, 6 + $x * $iSize + $iOX, 6 + $y * $iSize + $iOY, $iSize, $iSize)
_GDIPlus_GraphicsDrawLine($hGraphics, 6 + $x * $iSize + $iOX, 7 + $y * $iSize + $iOY, $iSize + 6 + $x * $iSize + $iOX, 7 + $y * $iSize + $iOY, $hPenWhite)
_GDIPlus_GraphicsDrawLine($hGraphics, 7 + $x * $iSize + $iOX, 6 + $y * $iSize + $iOY, 7 + $x * $iSize + $iOX, $iSize + 6 + $y * $iSize + $iOY, $hPenWhite)
_GDIPlus_GraphicsDrawLine($hGraphics, 6 + $x * $iSize + $iOX, $iSize + 5 + $y * $iSize + $iOY, $iSize + 6 + $x * $iSize + $iOX, $iSize + 5 + $y * $iSize + $iOY, $hPenBlack)
_GDIPlus_GraphicsDrawLine($hGraphics, $iSize + 5 + $x * $iSize + $iOX, 6 + $y * $iSize + $iOY, $iSize + 5 + $x * $iSize + $iOX, $iSize + 6 + $y * $iSize + $iOY, $hPenBlack)
EndFunc ;==>_DrawField
Func _SetTile()
If $iTile = GUICtrlRead($hInput) Then Return
GUIRegisterMsg($WM_PAINT, '')
For $i = 0 To 4
For $j = 0 To 4
GUICtrlDelete($hLabel[$i][$j])
Next
Next
$iTile = GUICtrlRead($hInput)
$iSize = Round(440 / $iTile)
For $i = 0 To $iTile - 1
For $j = 0 To $iTile - 1
$hLabel[$i][$j] = GUICtrlCreateLabel("", 6 + $i * $iSize, 6 + $j * $iSize, $iSize, $iSize)
GUICtrlSetCursor(-1, 2)
GUICtrlSetOnEvent(-1, "_MoveField")
Next
Next
_LoadRandomImage(True)
_ReDraw()
GUIRegisterMsg($WM_PAINT, '_Redraw')
EndFunc ;==>_SetTile
Func _ReDraw()
For $i = 0 To $iTile - 1
For $j = 0 To $iTile - 1
_DrawField($i, $j)
Next
Next
EndFunc ;==>_ReDraw
Func _ArrayCombine(ByRef $aArray, $aNew)
If Not IsArray($aNew) Then Return
Local $iArray = UBound($aArray) - 1, $iNew = UBound($aNew) - 1
Local $aReturn[$iArray + $iNew + 1]
For $i = 1 To $iArray
$aReturn[$i] = $aArray[$i]
Next
For $i = 1 To $iNew
$aReturn[$i + $iArray] = $aNew[$i]
Next
$aReturn[0] = $iArray + $iNew
$aArray = $aReturn
EndFunc ;==>_ArrayCombine
Func _Exit()
_GDIPlus_Shutdown()
Exit
EndFunc ;==>_Exit
Ist zwar noch nicht fertig, aber bereits spielbar.
Dazu benötigt man dann noch Bilder (jpg,bmp,tif,png,gif) im Format 440x440...
Zum testen hab ich ein Bild angefügt.
Ja, ich weiß selber, daß dieses Bild nicht unbedingt in ein Kinderspiel passt 
Ich hab aber momentan kein anderes gefunden 
lgE
Hi
2 png Bilder kannst du ganz normal mit GDI+ übereinanderlegen!
Das hab ich (wenn ich mich da richtig erinnere) bei meinem Spiel "Mensch, ärgere dich nicht" auch so gemacht...
lgE
Hi
such mal im englischen Forum nach irrlicht
lgE
Ubuntu macht glücklich :).
Naja, wenn man angewiesen ist auf Software, welche es auf Linux nicht gibt...
z.B. Propellerhead Reason...
Ich hab von meinen Windows-Systemen immer ein Image, welches ich alle paar Monate wieder raufspiele.
So vermeide ich, daß das System zumüllt und damit langsamer und Fehleranfälliger wird.
Hatte schon sehr lange keine Abstürze mehr unter WinXP.
Da ist mir mein Ubuntu schon öfter hängengeblieben.
Bootzeiten: Auf meinem Asus-1000h bootet WinXP merkbar schneller als Ubuntu!
Windows Vista: war der Grund, mich mal mit Linux zu beschäftigen.
Windows 7: hat mich sehr positiv überrascht. 
lgE
Auch Firefox.
Allerdings möchte ich anmerken, daß ich seit Version 3 ganz und gar NICHT mehr so zufrieden damit bin!
lgE
Momentan läuft doch eh µit-light!
Hi
zu 1: $BS_RIGHT = 0x0200
zu 3: folgendes Beispiel aus dem englischen Forum zeigt, wie man die Tabitems einfärben kann.
Du kannst versuchen, es so zu verändern, daß nur die Schriftfarbe grau wird:
#include <GuiConstantsEx.au3>
#include <WindowsConstants.au3>
#include <GuiTab.au3>
Global Const $ODT_TAB = 101
Global Const $ODS_SELECTED = 0x0001
Global Const $ODA_DRAWENTIRE = 0x1
Global Const $ODS_FOCUS = 0x0010
[/autoit] [autoit][/autoit] [autoit]$hGUI = GUICreate("Draw Tab", 300, 200)
[/autoit] [autoit][/autoit] [autoit]$hTab = GUICtrlCreateTab(10, 10, 280, 180, $TCS_OWNERDRAWFIXED)
[/autoit] [autoit][/autoit] [autoit]$TabItem_1 = GUICtrlCreateTabItem("TabItem 1")
GUICtrlCreateLabel("", 10, 33, 277, 155)
GUICtrlSetBkColor(-1, 0xDDAA11)
GUICtrlSetState(-1, $GUI_DISABLE)
$TabItem_2 = GUICtrlCreateTabItem("TabItem 2")
GUICtrlCreateLabel("", 10, 33, 277, 155)
GUICtrlSetBkColor(-1, 0x99BBEE)
GUICtrlSetState(-1, $GUI_DISABLE)
GUICtrlCreateTabItem("")
[/autoit] [autoit][/autoit] [autoit]GUISetState()
[/autoit] [autoit][/autoit] [autoit]GUIRegisterMsg($WM_DRAWITEM, "WM_DRAWITEM")
[/autoit] [autoit][/autoit] [autoit]_GUICtrlTab_SetCurSel($hTab, 1)
_GUICtrlTab_SetCurSel($hTab, 0)
Do
Until GUIGetMsg() = -3
Func WM_DRAWITEM($hWnd, $Msg, $wParam, $lParam)
Local $DRAWITEMSTRUCT
$DRAWITEMSTRUCT = DllStructCreate("uint cType;uint cID;uint itmID;uint itmAction;uint itmState;" & _
"hwnd hItm;hwnd hDC;dword itmRect[4];dword itmData", $lParam)
If DllStructGetData($DRAWITEMSTRUCT, "cType") <> $ODT_TAB Then Return $GUI_RUNDEFMSG
Local $cID = DllStructGetData($DRAWITEMSTRUCT, "cID")
Local $itmID = DllStructGetData($DRAWITEMSTRUCT, "itmID")
Local $itmAction = DllStructGetData($DRAWITEMSTRUCT, "itmAction")
Local $itmState = DllStructGetData($DRAWITEMSTRUCT, "itmState")
Local $hItm = DllStructGetData($DRAWITEMSTRUCT, "hItm")
Local $hDC = DllStructGetData($DRAWITEMSTRUCT, "hDC")
If $itmAction <> $ODA_DRAWENTIRE Then Return $GUI_RUNDEFMSG
Local $iTextColor, $itmText
Switch $itmID
Case 0
$iBrushColor = 0x11AADD
Case 1
$iBrushColor = 0xEEBB99
EndSwitch
DLLCall("gdi32.dll","int","SetBkMode", "hwnd", $hDC, "int", 1)
Local $iBrush = DLLCall("gdi32.dll","hwnd","CreateSolidBrush", "int", $iBrushColor)
$iBrush = $iBrush[0]
Local $iBrushOld = _WinAPI_SelectObject($hDC, $iBrush)
DLLCall("user32.dll","int","FillRect", "hwnd", $hDC, "ptr", DllStructGetPtr($DRAWITEMSTRUCT, "itmRect"), "hwnd", $iBrush)
Local $tBuffer = DllStructCreate("char[256]")
DllStructSetData($tBuffer, 1, "Item" & $itmID)
$itmText = DllStructGetData($tBuffer, 1)
DllStructSetData($DRAWITEMSTRUCT, "itmRect", DllStructGetData($DRAWITEMSTRUCT, "itmRect", 1) + 10, 1)
DllStructSetData($DRAWITEMSTRUCT, "itmRect", DllStructGetData($DRAWITEMSTRUCT, "itmRect", 2) + 5, 2)
DllCall("user32.dll", "int", "DrawText", "hwnd", $hDC, "str", $itmText, "int", StringLen($itmText), _
"ptr", DllStructGetPtr($DRAWITEMSTRUCT, "itmRect"), "int", $DT_LEFT)
_WinAPI_SelectObject($hDC, $iBrushOld)
_WinAPI_DeleteObject($iBrush)
Return $GUI_RUNDEFMSG
EndFunc
lgE
Whow!
Endlich kann ich die ganze Bandbreite von FreeImage nutzen!
Danke
Such mal nach _GDIPlus_BitmapLockBits, wenn du die Bilder zusammenrechnen willst...
oder im engl. Forum nach _GDIPlus_GraphicsDrawImageRectRectTrans, falls es ausreicht, wenn du das 2 Bild mit 50% Transparenz über das andere zeichnen willst...
lgE
So, ich habe nun meinen Solver ziemlich überarbeitet.
Ich verwende nun die Array-Variante, welche um einiges schneller arbeitet.
Den Backtrack hab ich mir von Blackmail abgeschaut, jedoch mit kleinen Änderungen.
Auch sonst sind viele Sachen von euren Solvern in dieses Script eingeflossen!
Von den 48000 Sudokus (Link von Andy), konnte ich alle korrekt in knapp 220min lösen.
GUI kommt erst später mal
viel Vergnügen!
Func _SolveSudoku($sSudoku)
Local $aSudoku, $bSolved = False
$aSudoku = _Sudoku_StringToArray($sSudoku)
$aSudoku = _Sudoku_Solve($aSudoku, $bSolved)
If Not $bSolved Then _Sudoku_BackTrack($aSudoku)
$sSudoku = ""
For $i = 0 To 80
$sSudoku &= $aSudoku[$i][0]
Next
Return $sSudoku
EndFunc ;==>_SolveSudoku
Func _Sudoku_BackTrack(ByRef $aSudoku, $iLevel = 0)
Local $aSudoku_1, $iCell = _Sudoku_BackTrack_GetCell($aSudoku) ; Erste Zelle mit den wenigsten Möglichkeiten
For $val = 1 To 9
If Not $aSudoku[$iCell][$val] Then ContinueLoop ; Zahl ist nicht möglich, also nächste Zahl probieren
$aSudoku_1 = $aSudoku ; Sicherung
_Sudoku_SetCell($aSudoku, $iCell, $val) ; Zelle wird gesetzt
If _Sudoku_BackTrack_Solve($aSudoku) Then Return True ; Falls Sudoku gelöst, dann aus der Rekursion aussteigen
If _Sudoku_BackTrack($aSudoku, $iLevel + 1) Then Return True ; Rekursiv next level
$aSudoku = $aSudoku_1 ; Original wiederherstellen, bevor nächste Zahl probiert wird
Next
Return False ; Wenn alle möglichen Zahlen der Zelle probiert wurden und kein Ergebnis erzielt wurde, dann ein Level zurück
EndFunc ;==>_Sudoku_BackTrack
Func _Sudoku_BackTrack_Solve(ByRef $aSudoku)
Local $aSudoku_1
Do
$aSudoku_1 = $aSudoku
For $i = 0 To 8
_Sudoku_Hidden_Single($aSudoku, _Sudoku_CellsOfRow($i))
_Sudoku_Hidden_Single($aSudoku, _Sudoku_CellsOfCol($i))
_Sudoku_Hidden_Single($aSudoku, _Sudoku_CellsOfBox($i))
Next
While _Sudoku_New_Singles($aSudoku)
_Sudoku_Naked_Single($aSudoku)
WEnd
Until _Sudoku_Compare($aSudoku, $aSudoku_1)
If _Sudoku_Is_Solved($aSudoku) Then Return True
Return False
EndFunc ;==>_Sudoku_BackTrack_Solve
Func _Sudoku_BackTrack_GetCell($aSudoku)
Local $iCnt
For $cnt = 0 To 9 ; die erste Zelle, die $cnt-viele Möglichkeiten besitzt, wird genommen; 0 & 1 könnte man eigentlich überspringen, aber manchmal gibts da einen Fehler !?!?!?
For $cel = 0 To 80
If $aSudoku[$cel][0] > 0 Then ContinueLoop
$iCnt = 0
For $val = 1 To 9
If $aSudoku[$cel][$val] Then $iCnt += 1
Next
If $iCnt = $cnt Then Return $cel
Next
Next
EndFunc ;==>_Sudoku_BackTrack_GetCell
Func _Sudoku_Solve($aSudoku, ByRef $bSolved)
Local $aSudoku_1, $iMethode = 0
Do
$aSudoku_1 = $aSudoku
If $iMethode = 0 Then
_Sudoku_Naked_Single($aSudoku)
If _Sudoku_Is_Solved($aSudoku) Then ExitLoop
$iMethode = 1
If _Sudoku_New_Singles($aSudoku) Then $iMethode = 0
EndIf
If $iMethode = 1 Then
For $i = 0 To 8
_Sudoku_Hidden_Single($aSudoku, _Sudoku_CellsOfRow($i))
_Sudoku_Hidden_Single($aSudoku, _Sudoku_CellsOfCol($i))
_Sudoku_Hidden_Single($aSudoku, _Sudoku_CellsOfBox($i))
Next
If _Sudoku_Is_Solved($aSudoku) Then ExitLoop
$iMethode = 2
If _Sudoku_New_Singles($aSudoku) Then $iMethode = 0
EndIf
If $iMethode = 2 Then
For $i = 0 To 8
_Sudoku_CandidatesOfRow($aSudoku, $i)
_Sudoku_CandidatesOfCol($aSudoku, $i)
_Sudoku_CandidatesOfBox($aSudoku, $i)
Next
$iMethode = 3
If _Sudoku_New_Singles($aSudoku) Then $iMethode = 0
EndIf
If $iMethode = 3 Then
For $i = 0 To 8
_Sudoku_Naked_Multi($aSudoku, _Sudoku_CellsOfRow($i), 2)
_Sudoku_Naked_Multi($aSudoku, _Sudoku_CellsOfCol($i), 2)
_Sudoku_Naked_Multi($aSudoku, _Sudoku_CellsOfBox($i), 2)
Next
$iMethode = 4
If _Sudoku_New_Singles($aSudoku) Then $iMethode = 0
EndIf
If $iMethode = 4 Then
For $i = 0 To 8
_Sudoku_Hidden_Multi($aSudoku, _Sudoku_CellsOfRow($i), 2)
_Sudoku_Hidden_Multi($aSudoku, _Sudoku_CellsOfCol($i), 2)
_Sudoku_Hidden_Multi($aSudoku, _Sudoku_CellsOfBox($i), 2)
Next
$iMethode = 0 ; Auf 5 setzen, wenn man auch triples suchen möchte
If _Sudoku_New_Singles($aSudoku) Then $iMethode = 0
EndIf
If $iMethode = 5 Then
For $i = 0 To 8
_Sudoku_Naked_Multi($aSudoku, _Sudoku_CellsOfRow($i), 3)
_Sudoku_Naked_Multi($aSudoku, _Sudoku_CellsOfCol($i), 3)
_Sudoku_Naked_Multi($aSudoku, _Sudoku_CellsOfBox($i), 3)
Next
$iMethode = 6
If _Sudoku_New_Singles($aSudoku) Then $iMethode = 0
EndIf
If $iMethode = 6 Then
For $i = 0 To 8
_Sudoku_Hidden_Multi($aSudoku, _Sudoku_CellsOfRow($i), 3)
_Sudoku_Hidden_Multi($aSudoku, _Sudoku_CellsOfCol($i), 3)
_Sudoku_Hidden_Multi($aSudoku, _Sudoku_CellsOfBox($i), 3)
Next
$iMethode = 0
EndIf
$bSolved = _Sudoku_Is_Solved($aSudoku)
Until $bSolved Or _Sudoku_Compare($aSudoku, $aSudoku_1)
Return $aSudoku
EndFunc ;==>_Sudoku_Solve
Func _Sudoku_New_Singles($aSudoku)
Local $iCnt
For $i = 0 To 80
$iCnt = 0
For $j = 1 To 9
If $aSudoku[$i][$j] Then $iCnt += 1
Next
If $iCnt = 1 Then Return True
Next
Return False
EndFunc ;==>_Sudoku_New_Singles
Func _Sudoku_Compare($aSudoku, $aSudoku_1)
For $i = 0 To 80
For $j = 0 To 9
If $aSudoku[$i][$j] <> $aSudoku_1[$i][$j] Then Return False
Next
Next
Return True
EndFunc ;==>_Sudoku_Compare
Func _Sudoku_Is_Solved($aSudoku)
For $i = 0 To 80
If $aSudoku[$i][0] = 0 Then Return False
Next
Return True
EndFunc ;==>_Sudoku_Is_Solved
Func _Sudoku_CandidatesOfRow(ByRef $aSudoku, $iIndex)
Local $aBox[3] = [0, 0, 0], $aCells = _Sudoku_CellsOfRow($iIndex)
For $val = 1 To 9
$aBox[0] = 0
$aBox[1] = 0
$aBox[2] = 0
For $cel = 0 To 8
If Not $aSudoku[$aCells[$cel]][$val] Then ContinueLoop
$aBox[Floor($cel / 3)] += 1
Next
If $aBox[0] > 0 And $aBox[1] = 0 And $aBox[2] = 0 Then ; If... ElseIf...EndIf ist hier ein klein wenig schneller als Switch
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetBox($aCells[0]), $val, Mod($iIndex, 3), 3)
ElseIf $aBox[0] = 0 And $aBox[1] > 0 And $aBox[2] = 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetBox($aCells[3]), $val, Mod($iIndex, 3), 3)
ElseIf $aBox[0] = 0 And $aBox[1] = 0 And $aBox[2] > 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetBox($aCells[6]), $val, Mod($iIndex, 3), 3)
EndIf
Next
EndFunc ;==>_Sudoku_CandidatesOfRow
Func _Sudoku_CandidatesOfCol(ByRef $aSudoku, $iIndex)
Local $aBox[3] = [0, 0, 0], $aCells = _Sudoku_CellsOfCol($iIndex)
For $val = 1 To 9
$aBox[0] = 0
$aBox[1] = 0
$aBox[2] = 0
For $cel = 0 To 8
If Not $aSudoku[$aCells[$cel]][$val] Then ContinueLoop
$aBox[Floor($cel / 3)] += 1
Next
If $aBox[0] > 0 And $aBox[1] = 0 And $aBox[2] = 0 Then ; If... ElseIf...EndIf ist hier ein klein wenig schneller als Switch
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetBox($aCells[0]), $val, Mod($iIndex, 3) * 3, 1)
ElseIf $aBox[0] = 0 And $aBox[1] > 0 And $aBox[2] = 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetBox($aCells[3]), $val, Mod($iIndex, 3) * 3, 1)
ElseIf $aBox[0] = 0 And $aBox[1] = 0 And $aBox[2] > 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetBox($aCells[6]), $val, Mod($iIndex, 3) * 3, 1)
EndIf
Next
EndFunc ;==>_Sudoku_CandidatesOfCol
Func _Sudoku_CandidatesOfBox(ByRef $aSudoku, $iIndex)
Local $aRow[3] = [0, 0, 0], $aCol[3] = [0, 0, 0], $aCells = _Sudoku_CellsOfBox($iIndex)
For $val = 1 To 9 ; Alle Zahlen
$aRow[0] = 0
$aRow[1] = 0
$aRow[2] = 0
$aCol[0] = 0
$aCol[1] = 0
$aCol[2] = 0
For $cel = 0 To 8 ; Alle Zellen
If Not $aSudoku[$aCells[$cel]][$val] Then ContinueLoop
$aRow[Mod($cel, 3)] += 1 ; Zähle in welchen Reihen die Zahl vorkommt
$aCol[Floor($cel / 3)] += 1 ; Zähle in welchen Spalten die Zahl vorkommt
Next
If $aRow[0] > 0 And $aRow[1] = 0 And $aRow[2] = 0 Then ; If... ElseIf...EndIf ist hier ein klein wenig schneller als Switch
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetRow($aCells[0]), $val, Mod($iIndex, 3) * 3, 1)
ElseIf $aRow[0] = 0 And $aRow[1] > 0 And $aRow[2] = 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetRow($aCells[1]), $val, Mod($iIndex, 3) * 3, 1)
ElseIf $aRow[0] = 0 And $aRow[1] = 0 And $aRow[2] > 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetRow($aCells[2]), $val, Mod($iIndex, 3) * 3, 1)
EndIf
If $aCol[0] > 0 And $aCol[1] = 0 And $aCol[2] = 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetCol($aCells[0]), $val, Floor($iIndex / 3) * 3, 1)
ElseIf $aCol[0] = 0 And $aCol[1] > 0 And $aCol[2] = 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetCol($aCells[3]), $val, Floor($iIndex / 3) * 3, 1)
ElseIf $aCol[0] = 0 And $aCol[1] = 0 And $aCol[2] > 0 Then
_Sudoku_Candidates_Remove($aSudoku, _Sudoku_CellGetCol($aCells[6]), $val, Floor($iIndex / 3) * 3, 1)
EndIf
Next
EndFunc ;==>_Sudoku_CandidatesOfBox
Func _Sudoku_Candidates_Remove(ByRef $aSudoku, $aCells, $iValue, $iNot1, $iNotPlus = 0)
Local $iNot2, $iNot3
$iNot2 = $iNot1 + $iNotPlus
$iNot3 = $iNot2 + $iNotPlus
For $i = 0 To 8
If $i = $iNot1 Or $i = $iNot2 Or $i = $iNot3 Then ContinueLoop
$aSudoku[$aCells[$i]][$iValue] = 0
Next
EndFunc ;==>_Sudoku_Candidates_Remove
Func _Sudoku_Hidden_Multi(ByRef $aSudoku, $aCells, $iLevel)
Local $aCell[10], $iValues, $iCnt
For $val = 1 To 9 ; Alle Zahlen
$aCell[$val] = 0
For $cel = 0 To 8 ; Alle Zellen
If $aSudoku[$aCells[$cel]][0] = $val Then ContinueLoop
If Not $aSudoku[$aCells[$cel]][$val] Then ContinueLoop
$iCnt += 1 ; Zähle, in wie vielen Zellen die Zahl vorkommt
$aCell[$val] = BitOR($aCell[$val], 2 ^ $cel) ; Speichere die Zellen, in welchen die Zahl vorkommt in $aCell
Next
If $iCnt <> $iLevel Then $aCell[$val] = 0
Next
For $i = 1 To 9
If $aCell[$i] = 0 Then ContinueLoop ; Nur weitermachen, wenn Zahl in genau $iLevel Zellen gefunden wurde
$iCnt = 0
$iValues = 0
For $j = $i To 9
If $aCell[$i] <> $aCell[$j] Then ContinueLoop
$iCnt += 1
$iValues = BitOR($iValues, 2 ^ $j)
Next
If $iCnt <> $iLevel Then ContinueLoop ; Nur weitermachen, wenn es genau $iLevel Zahlen in $iLevel Zellen gibt
For $j = $i To 9
If Not BitAND($aCell[$i], 2 ^ $j) Then ContinueLoop ; Nur weitermachen, wenn es die Zellen mit den Zahlen sind
For $val = 1 To 9
If BitAND($iValues, 2 ^ $val) Then ContinueLoop
$aSudoku[$aCells[$j]][$val] = 0
Next
Next
Next
EndFunc ;==>_Sudoku_Hidden_Multi
Func _Sudoku_Hidden_Single(ByRef $aSudoku, $aCells)
Local $iCnt
For $val = 1 To 9 ; Suche alle Zahlen
$iCnt = 0
For $cel In $aCells ; In allen Zellen
If $aSudoku[$cel][0] = $val Then ContinueLoop 2
If $aSudoku[$cel][$val] Then $iCnt += 1
Next
If $iCnt <> 1 Then ContinueLoop ; Nur weitermachen, wenn Zahl genau in 1 Zelle gefunden wurde
For $cel In $aCells
If Not $aSudoku[$cel][$val] Then ContinueLoop
_Sudoku_SetCell($aSudoku, $cel, $val)
ContinueLoop 2
Next
Next
EndFunc ;==>_Sudoku_Hidden_Single
Func _Sudoku_Naked_Multi(ByRef $aSudoku, $aCells, $iLevel = 2)
Local $aValues[9], $iCnt
For $cel = 0 To 8 ; Alle Zellen
$iCnt = 0
$aValues[$cel] = 0
For $val = 1 To 9 ; Zähle, wie viele Zahlen in der Zelle vorkommen
If $aSudoku[$aCells[$cel]][$val] Then $iCnt += 1
Next
If $iCnt <> $iLevel Then ContinueLoop ; nur weitermachen, wenn genau $iLevel Zahlen vorkommen
For $val = 1 To 9
If $aSudoku[$aCells[$cel]][$val] Then $aValues[$cel] = BitOR($aValues[$cel], 2 ^ $val) ; Zahlen in $aValues speichern
Next
Next
For $i = 0 To 8
If $aValues[$i] = 0 Then ContinueLoop
$iCnt = 0
For $j = $i To 8
If $aValues[$i] = $aValues[$j] Then $iCnt += 1 ; Zähle, ob es genau $iLevel Zellen mit den gleichen Zahlen gibt
Next
If $iCnt <> $iLevel Then ContinueLoop ; Nur weitermachen, wenn genau $iLevel Zellen mit den gleichen $iLevel Zahlen gefunden wurden
For $val = 1 To 9
If Not BitAND($aValues[$i], 2 ^ $val) Then ContinueLoop
For $j = $i To 8
If $aValues[$i] = $aValues[$j] Then ContinueLoop ; Nur weitermachen, wenn es sich nicht um eine der gefundenen Zellen handelt
$aSudoku[$aCells[$j]][$val] = 0
Next
Next
Next
EndFunc ;==>_Sudoku_Naked_Multi
Func _Sudoku_Naked_Single(ByRef $aSudoku)
Local $iCnt
For $cel = 0 To 80 ; Suche in allen Zellen
If $aSudoku[$cel][0] > 0 Then ContinueLoop
$iCnt = 0
For $val = 1 To 9 ; nach allen Zahlen
If $aSudoku[$cel][$val] Then $iCnt += 1
Next
If $iCnt <> 1 Then ContinueLoop ; Wenn NICHT 1 mal gefunden, dann Schleife von vorne (nachfolgender Code wird nur ausgeführt, wenn Zahl 1mal gefunden wurde)
For $val = 1 To 9
If Not $aSudoku[$cel][$val] Then ContinueLoop
_Sudoku_SetCell($aSudoku, $cel, $val)
ContinueLoop 2
Next
Next
EndFunc ;==>_Sudoku_Naked_Single
Func _Sudoku_SetCell(ByRef $aSudoku, $iIndex, $iValue)
$aSudoku[$iIndex][0] = $iValue
For $i = 1 To 9
$aSudoku[$iIndex][$i] = 0
Next
For $i In _Sudoku_CellGetRow($iIndex)
$aSudoku[$i][$iValue] = 0
Next
For $i In _Sudoku_CellGetCol($iIndex)
$aSudoku[$i][$iValue] = 0
Next
For $i In _Sudoku_CellGetBox($iIndex)
$aSudoku[$i][$iValue] = 0
Next
EndFunc ;==>_Sudoku_SetCell
Func _Sudoku_StringToArray($sSudoku)
Local $aReturn[81][10], $aSudoku = StringSplit($sSudoku, "", 2)
For $i = 0 To 80
$aReturn[$i][0] = $aSudoku[$i]
If $aSudoku[$i] > 0 Then ContinueLoop
For $j = 1 To 9
$aReturn[$i][$j] = 1
Next
Next
For $i = 0 To 80
If $aSudoku[$i] > 0 Then _Sudoku_SetCell($aReturn, $i, $aSudoku[$i])
Next
Return $aReturn
EndFunc ;==>_Sudoku_StringToArray
Func _Sudoku_CellsOfRow($iIndex) ; Return = alle Zellen einer Reihe ( $iIndex = 0-8 )
Local $aReturn[9]
For $i = 0 To 8
$aReturn[$i] = $iIndex * 9 + $i
Next
Return $aReturn
EndFunc ;==>_Sudoku_CellsOfRow
Func _Sudoku_CellGetRow($iIndex) ; Return = alle Zellen einer Reihe einer bestimmten Zelle ( $iIndex = 0-80 )
Local $aReturn[9]
For $i = 0 To 8
$aReturn[$i] = Floor($iIndex / 9) * 9 + $i
Next
Return $aReturn
EndFunc ;==>_Sudoku_CellGetRow
Func _Sudoku_CellsOfCol($iIndex) ; Return = alle Zellen einer Spalte ( $iIndex = 0-8 )
Local $aReturn[9]
For $i = 0 To 8
$aReturn[$i] = $iIndex + $i * 9
Next
Return $aReturn
EndFunc ;==>_Sudoku_CellsOfCol
Func _Sudoku_CellGetCol($iIndex) ; Return = alle Zellen einer Spalte einer bestimmten Zelle ( $iIndex = 0-80 )
Local $aReturn[9]
For $i = 0 To 8
$aReturn[$i] = Mod($iIndex, 9) + (9 * $i)
Next
Return $aReturn
EndFunc ;==>_Sudoku_CellGetCol
Func _Sudoku_CellsOfBox($iIndex) ; Return = alle Zellen einer Box ( $iIndex = 0-8 )
Local $aReturn[9], $iCnt = -1
For $i = 0 To 2
For $j = 0 To 2
$iCnt += 1
$aReturn[$iCnt] = Floor($iIndex / 3) * 27 + Mod($iIndex, 3) * 3 + $i + ($j * 9)
Next
Next
Return $aReturn
EndFunc ;==>_Sudoku_CellsOfBox
Func _Sudoku_CellGetBox($iIndex) ; Return = alle Zellen einer Box einer bestimmten Zelle ( $iIndex = 0-80 )
Local $aReturn[9], $iCnt = -1
For $i = 0 To 2
For $j = 0 To 2
$iCnt += 1
$aReturn[$iCnt] = Floor(Mod($iIndex, 9) / 3) * 3 + Floor($iIndex / 27) * 27 + $i + (9 * $j)
Next
Next
Return $aReturn
EndFunc ;==>_Sudoku_CellGetBox
lge
Ich habe angefangen, meinen Solver auf $aSudoku[81][9] - Array umzuschreiben. (statt BitAnd & Co)
Das geht relativ problemlos und die Geschwindigkeit nimmt deutlich zu
Weiters hab ich auch angefangen einen Logic-Backtracker zu schreiben, denn mein bisheriger ist ein Bruteforce-Algo.
Er funktioniert schon, jedoch benötigt er 20 mal solange, wie eure Algos 
Da muß ich eure Scripte wohl noch genauer studieren
lgE
Die Methode mit BitAnd, BitOr und BitXor ist schneller als StringInStr und StringReplace.
Allerdings auch langsamer als so ein Array: $aSudoku[9][9][9] ($aSudoku[x][y][val])
Ich kann mich leider nicht mehr erinnern, weshalb ich nicht das Array genommen hab?!?
Irgendeinen Grund hatte es...
SpeedTest:
Global $iCnt = 100
Global $aSudoku[9][9][9], $sSudoku[9][9], $bSudoku[9][9], $iTimer
For $i = 0 To 8
For $j = 0 To 8
For $k = 0 To 8
$aSudoku[$i][$j][$k] = 1
$sSudoku[$i][$j] &= $i
$bSudoku[$i][$j] = BitOR($bSudoku[$i][$j], 2 ^ $i)
Next
Next
Next
$iTimer = TimerInit()
For $i = 1 To $iCnt
For $iValue = 0 To 8
For $k = 0 To 8
For $l = 0 To 8
If $aSudoku[$k][$l][$iValue] Then ContinueLoop
Next
Next
Next
Next
ConsoleWrite("ARRAY" & @TAB & "Möglichkeit vorhanden " & TimerDiff($iTimer) & @LF)
$iTimer = TimerInit()
For $i = 1 To $iCnt
For $iValue = 0 To 8
For $k = 0 To 8
For $l = 0 To 8
If StringInStr($sSudoku[$k][$l], $iValue) Then ContinueLoop
Next
Next
Next
Next
ConsoleWrite("STRING" & @TAB & "Möglichkeit vorhanden " & TimerDiff($iTimer) & @LF)
$iTimer = TimerInit()
For $i = 1 To $iCnt
For $iValue = 0 To 8
For $k = 0 To 8
For $l = 0 To 8
If BitAND($bSudoku[$k][$l], 2 ^ $iValue) Then ContinueLoop
Next
Next
Next
Next
ConsoleWrite("BIT" & @TAB & "Möglichkeit vorhanden " & TimerDiff($iTimer) & @LF)
ConsoleWrite(@LF)
[/autoit] [autoit][/autoit] [autoit]$iTimer = TimerInit()
For $i = 1 To $iCnt
For $iValue = 0 To 8
For $k = 0 To 8
For $l = 0 To 8
$aSudoku[$k][$l][$iValue] = 0
Next
Next
Next
Next
ConsoleWrite("ARRAY" & @TAB & "Möglichkeit löschen " & TimerDiff($iTimer) & @LF)
$iTimer = TimerInit()
For $i = 1 To $iCnt
For $iValue = 0 To 8
For $k = 0 To 8
For $l = 0 To 8
$sSudoku[$k][$l] = StringReplace($sSudoku[$k][$l], $iValue, "")
Next
Next
Next
Next
ConsoleWrite("STRING" & @TAB & "Möglichkeit löschen " & TimerDiff($iTimer) & @LF)
$iTimer = TimerInit()
For $i = 1 To $iCnt
For $iValue = 0 To 8
For $k = 0 To 8
For $l = 0 To 8
If BitAND($bSudoku[$k][$l], 2 ^ $iValue) Then $bSudoku[$k][$l] = BitXOR($bSudoku[$k][$l], 2 ^ $iValue)
Next
Next
Next
Next
ConsoleWrite("BIT" & @TAB & "Möglichkeit löschen " & TimerDiff($iTimer) & @LF)
Naja - Mein Script ist auch mit der vermeintlich schnelleren Methode langsamer als deines
Mein reiner Backtracker benötigt für das 1 BT-Sudoku aus dem Benchmark über 30 min!
dafür löst er die restlichen (vom Benchmark) ziemlich schnell.
Mit anderen Sudokus hab ich den gar nicht ausprobiert...
Wenn ich mal mehr Zeit hab, werd ich mir eure Solver mal genauer ansehen -bin schon gespannt
lgE
