ortogonale Zuordnung von Varibalen

**Alina**

Ich habe da so eine Idee, die ich versuche irgendwie von der Therie auf Papier zumindest hin zu bekommen.

Erklärung / Spielaufbau:

Ich habe ein Spielfeld von: waagerecht 30 x senkrecht 46 Feldern. Damit habe ich 1380 bestimmbare Positionen.
Nun soll durch Zufall eine Position ausgesucht werden, die aber waagerecht nicht in der ersten oder letzten Zeile
sein darf und auch nicht in der ersten oder letzten Spalte. Das sollte / ist mit Radom machbar.
Nun sollen von dieser ermittelten Position vier Positionen bestimmt werden die folgende Kriterien erfüllen:
jeweils ein Wert muss in der gleichen Spalte über der Position sein und, einer rechts davon, einen da drunter und
einer links davon.
Nun haben wir schon Position X, den ich mal mit der deutschen Bezeichnung "Schwarzer Peter" betitel und die
vier Positionen, die ich mal "Kreuzpositionen" betitel.
Nun kommen noch drei weitere Positione dazu, die folgende Kriterien erfüllen müssen: Die drei Positionen dürfen
sich nicht im 90 Grad Winkeln selber kreuzen, noch sich mit den vier "Kreuzpositionen" im 90 Grad Winkel.

Nun haben wir folgende Positionen, die wie folgt befüllt werden:
1 x Schwarzer Peter (fünfstellige beliebige Zahl, die keine Primzahl ist)
4 x Kreuzposition (fünfstellige Primzahlen)
3 x weitere Position (fünfstellige Primzahlen)
1372 x sonstige fünfstellige Zahlen, die jedoch keine Primzahlen sein dürfen.

fünfstellige Zahl = 00000 - 99999

Der Spass daran ist es, im KOPF die Primzahlen zu finden, sie im Kopf miteinander zu verbinden (ortogonale
Zuordnung) und die einzige Position zu finden, wo sich vier der sieber Primzahlen im 90 Grad Winkel kreuzen.
Die Frage ist immer: wo ist der "Schwarze Peter"?

So, das ganze klappt auf dem Papier, aber dann weiß man ja selber die Lösung, was ja doof ist.

Mal ein Bild zu optischen Erlärung:
Die roten Verbindungen werden nur im Kopf gezogen, genauso wie das finden der blauen und des schwarzen
Position.
black_peter_verbunden.jpg

WIE SOLL MAN DA RICHTIG VORGEHEN ???

**Andy**

Hallo Alina,

wenn ich das richtig verstanden habe lautet die Spielanweisung:
"Finde den schwarzen Peter, der keine Primzahl ist. In der Spalte des schwarzen Peter befinden sich GENAU 2 Primzahlen, in der Reihe des schwarzen Peter befinden sich GENAU 2 Primzahlen"

Was ich nicht verstanden habe ist die Sache mit den 3 weiteren Primzahlen, deren Position imho völlig unerheblich dabei ist, den schwarzen Peter zu finden!

Umzusetzen ist das ganze relativ einfach, du musst nur die 5 Punkte "schwarzer Peter" ausfüllen und dann dessen Reihe und Spalte ausfüllen, allerdings ohne Primzahlen!
Dann wird das restliche Spielfeld (es ergeben sich 4 Quadranten) mit den übrigen Zahlen von oben nach unten ausgefüllt.
Einzige Regel ab jetzt! Es darf keine NICHT-Primzahl geben, in dessen Reihe und Spalte jeweils eine Primzahl ist, denn das wäre automatisch ein "schwarzer Peter". Daher würde ich das Spielfeld "zufällig" mit den weiteren Primzahlen füllen, und zwar so, dass sich kein "schwarzer Peter" ergeben kann! Alle anderen "nicht-Primzahlen" kannst du nun gefahrlos auf die restlichen Felder verteilen, es wird sich nie ein schwarzer Peter ergeben....

//EDIT
Von 0 bis 99999 gibt es 9592 Primzahlen, die lassen sich selbst auf meinem langsamen Rechner innerhalb von 2-3 Millisekunden berechnen.
Vorgehen also folgendermaßen:
- Schwarzer_Peter_bestimmen (aus zufälliger nicht Primzahl und 4 Primzahlen)
- im restlichen Spielfeld zufällig alle weiteren Nicht-Primzahlen verteilen
- Damit es schwieriger wird, zufällig x (Schwierigkeitsgrad!) Primzahlen verteilen, dabei darauf achten, dass in deren Reihe und Spalte kein weiterer Schwarzer Peter entsteht.

**Alina**

Andy:

Du hast es genau richtig verstanden, also habe ich es doch nicht zu blond erklärt.
Die drei weiteren Primzahlen so wie von Dir vermutet da, damit es schwieriger wird.

Bist Du dir da sicher mit 9592 möglichen Primzahlen?
Das würde bedeuten, das ich als ersten die Primzahlen in ein Arry schreibe. Danach eine zufällige
Zahl zwischen 1 und 1065 auswählen. Das Array ist dann die erste Primzahl. Danach 6x immer
plus 1065 und schon habe ich die 7 Primzahlen.

Ja, das könnte funktionieren. Das muss ich mal im Hintergrund behalten.

**autoBert**

Zitat von Alina

Bist Du dir da sicher mit 9592 möglichen Primzahlen?

@'MatthiasG. hat eine func (_MathEx_CreatePrimes Erstellt Primzahlen), damit kannst du dies ganz leicht überprüfen:

AutoIt: Demo _MathEx_CreatePrimes

#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Res_Fileversion=1.2.0.2
#AutoIt3Wrapper_Res_SaveSource=y
#AutoIt3Wrapper_Res_Language=1031
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****


#include <Array.au3>
#include <File.au3>


$sFile='Primes.txt'
$hFile=FileOpen($sFile,2)
$tdStart=TimerInit()
$aPrimes = _MathEx_CreatePrimes(99999)
FileWriteLine($hFile,@CRLF&'Primes searched in 2-99999')
FileWriteLine($hFile,' Primes found in '& TimerDiff($tdStart)/1000 & ' sec')
FileClose($hFile)
$aPrimes[0]=$aPrimes[0]&' Primes found in '& TimerDiff($tdStart)/1000 & ' sec'
_FileWriteFromArray($sFile,$aPrimes)
_ArrayDisplay($aPrimes,'Primes searched in 2-99999')
ShellExecute($sFile)


; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_CreatePrimes
; Beschreibung...: Gibt ein Array voller Primzahlen zurück.
; Syntax.........: _MathEx_CreatePrimes($number)
; Parameter......: $number - Zwischen 2 und $number werden die Primzahlen gesucht
; Rückgaben......: Erfolg - Gibt ein Array zurück. Im 0ten Element steht die Anzahl an Zahlen, im Rest die Primzahlen selbst.
;                  Fehler - Gibt 0 zurück, wenn $number kein Integer ist oder kleiner als 2 ist
; Autor(en)......: AutoBert <AutoBert at autoit dot de>, Progandy <Progandy at autoit dot de>,
;                  Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_CreatePrimes($number)
	If Not IsInt($number) Or $number < 2 Or $number > 16777215 Then Return 0
	$number += 3
	Local $array_mathex_gestrichen[$number - 2]
	For $i = 0 To $number - 3
		$array_mathex_gestrichen[$i] = False
	Next
	Local $i = 2
	While $i * $i <= $number
		If Not $array_mathex_gestrichen[$i] Then
			For $j = $i * $i To $number - 3 Step $i
				$array_mathex_gestrichen[$j] = True
			Next
		EndIf
		$i = $i + 1
	WEnd
	Local $integer_mathex_anzahl = 0
	For $i = 2 To $number - 3
		If Not $array_mathex_gestrichen[$i] Then $integer_mathex_anzahl += 1
	Next
	Local $array_mathex_primzahlen[$integer_mathex_anzahl + 1], $integer_mathex_aktuell = 1
	$array_mathex_primzahlen[0] = $integer_mathex_anzahl
	For $i = 2 To $number - 3
		If Not $array_mathex_gestrichen[$i] Then
			$array_mathex_primzahlen[$integer_mathex_aktuell] = $i
			$integer_mathex_aktuell += 1
		EndIf
	Next
	Return $array_mathex_primzahlen
EndFunc   ;==>_MathEx_CreatePrimes

Alles anzeigen

und siehe da Andy wird durch diese Funktion bestätigt: "9592 Primes found in 1.33128914455116 sec"

'

**Andy**

!

Ich dachte aber eher an diese (meine) Funktion

AutoIt

#AutoIt3Wrapper_UseX64=n


;~ #include <assembleit2_64.au3>




Local $maximum = 99999   ;50000000        ;1299709


$t = TimerInit()
$primzahlen = _PrimeAsm($maximum) ;Assembler aufrufen, code assemblieren, in den Speicher schreiben und ausführen
$m = TimerDiff($t)




StringReplace($primzahlen, @CR, @CR, 0, 1) ;alle CR im String zählen.....auch AutoIt hat SPEEEEED^^
$anzahlprim = @extended  ;hätte man auch vom Assembler zurückgeben lassen können^^


MsgBox(262144, "Primzahlen bis " & $maximum, $anzahlprim & " Primzahlen in " & Int($m) & " Millisekunden, Ausgabe der Zahlen folgt in Console....")
ConsoleWrite($primzahlen & @CRLF)




FileDelete("Primzahlen_asm.dat")
FileWrite("Primzahlen_asm.dat", $primzahlen)
ShellExecute("Primzahlen_asm.dat")






Exit








Func _PrimeAsm($limit)   ;code by Andy@AutoIt.de


    Local $tStruct = DllStructCreate("uint Limit;uint Limes;char Mem[" & $limit + 10 & "]") ;char, dann kann man nachher schön mit den stringfunktionen suchen
    DllStructSetData($tStruct, "Mem", "001") ;die ersten 3 Zahlen setzen, 0=0 1=0 2=1 , 2 ist die erste Primzahl")
    DllStructSetData($tStruct, "Limit", $limit) ;limit in die Struct schreiben
    DllStructSetData($tStruct, "Limes", Floor(Sqrt($limit)) + 1) ;wurzel aus limit in die struct schreiben




    Local $asm_code = "0x558B6C24088B5D00B803000000C74405083130313083C00439D876F18D7D0889FE8B4D00BB0300000089D8F7E0C604063001D839C87EF683C30239CB7736803C1E3175F3535189D8BB0A00000031C931D2F7F3665280C10109C075F366580C30AAE2F9C6070D83C701595B3B5D047CB939CB7CC3C607005DC3"
;~     $asm_code = _AssembleIt2("retbinary", "_primzahlen", "ptr", DllStructGetPtr($tStruct)) ; Assembler aufrufen, um code für dllcalladdress zu bekommen
;~     ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $asm_code = ' & $asm_code & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console


    Local $asm_struct = DllStructCreate("byte[" & StringLen($asm_code) / 2 - 1 & "]") ;speicher für asm-code bereitstellen...
    DllStructSetData($asm_struct, 1, $asm_code) ;...und mit code beschreiben


    DllCallAddress("none:cdecl", DllStructGetPtr($asm_struct), "ptr", DllStructGetPtr($tStruct)) ;asm-code aufrufen


;~     $Ret = _AssembleIt2("uint", "_primzahlen", "ptr", DllStructGetPtr($tStruct)) ; Assembler aufrufen, wenn man das dllcalladdress-gedöns garnicht braucht
;~     ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $Ret = ' & $Ret & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
    $pstring = "2" & @CR & "3" & @CR ;2 und 3 sind die ersten Primzahlen
    $pstring &= DllStructGetData($tStruct, "Mem") ;alle Primzahlen aus der struct in den string schreiben


    Return $pstring      ;und zurückgeben


EndFunc                  ;==>_PrimeAsm




#cs _primzahlen


    use32


    push ebp             ; ebp des aufrufenden Programms retten
    mov ebp, dword[ESP+08h]  ; "unseren" ebp setzen auf den Anfang unserer Struct
    ;dann ist...
    ;    [EBP+0h]  der erste Parameter (Limit) , da UINT ist er 4 Bytes lang, daher ist der nächste Parameter bei...
    ;    [EBP+04h] der 2 Parameter (Limes), auch 4 Byte lang...daher findet man den 3. Parameter, unsere struct bei...
    ;    [EBP+08h] der Anfang des Speicherbereichs Mem
    ;ich verwende die Hex-Zahlen, um bei verschiedenen Assemblern einen Standard zu haben, der Windowstaschenrechner ist Gold wert^^


    mov ebx,dword[ebp+0h]  ; Limit
    mov eax,3            ; 3 ist die nächste Primzahl




    Fill:                ; Schleifenanfang
    mov dword[ebp+08h+eax],30313031h    ; an die Speicherstelle in der Struct den String "1010"
    add eax,4            ; eax=eax+4        ;geht auch mit einem rep stosw^^                10
    cmp eax,ebx          ; vergleiche eax mit $limit
    jbe Fill             ; Jump if below or equal (wenn <=) nach Fill, ansonsten weiter
    ;in der struct steht nun 001101010101010101010.....alle vielfachen von 2 sind 0, die erste 0 ist die 0, 2 ist die erste Primzahl!


    ;startadresse Struct Prim holen
    ;~     mov edi, ebp                  ; an ebp steht der erste Parameter, wir brauchen aber die Adresse von ebp+8
    ;~     add edi, 8                    ; ebp+8 ist die adresse des ersten bytes der struct Mem
    lea edi,[ebp+8]
    mov esi, edi         ; ESI=anfang Mem
    mov ecx,dword[EBP+0h]  ; do until limit
    mov ebx,3            ; ebx=aktuelle Zahl in der struct struct[1]=speicher[0] !!!!!!
    L0:
    mov eax,ebx          ; eax=ebx=aktuelle primzahl
    mul eax              ;nächstes vielfaches der prim = quadrat der primzahl
    ;****************************************
    ;ACHTUNG, das Erbebnis von mul ist EDX:EAX also wird auch das edx-register verändert!
    ;*****************************************
    L1:
    mov byte[esi+eax],30h  ;jedes vielfache der Primzahl in der struct zu "0" machen
    add eax,ebx          ;eax=eax+ebx vielfaches der Primzahl        20
    cmp eax,ecx          ; Vielfaches mit limit vergleichen
    jle L1               ; solange eax < limit, die Vielfachen löschen
    L2:                  ;nächste Primzahl holen
    add ebx,2            ;2 zahlen weiter springen ,3,5,7,9,11,13,15....
    cmp ebx,ecx          ;dword[EBP+0h]           ; vgl aktuelle position mit dem Ende von Mem
    ja exit              ;wenn Ende erreicht, exit
    cmp byte[esi+ebx],31h  ;ist an dieser stelle in der struct eine primzahl?
    jne L2               ;wenn nicht, nächste zahl wählen
    ;************************************************************
    ;aus einer Zahl(Registerinhalt) einen ZiffernString machen: http://dcla.rkhb.de/umwandlung/int2dez.html
    ;und in die Primstruct schreiben
    ;wird dieser Bereich auskommentiert, wird ein String aus nullen und einsen zurückgegeben 0=keine Prim 1=Prim
    ;dann können mit den AutoIt-Stringbefehlen die Primzahlen und deren Anzahl ausgelesen werden
    push   ebx           ;alle benötigten Register sichern
    push   ecx           ;alle benötigten Register sichern
    mov eax, ebx         ;Zahl laden
    mov ebx, 10          ; Divisor
    xor ecx, ecx         ;ECX=0 (Anzahl der Ziffern)
    Schleife_1:
    xor edx, edx
    div ebx              ; EDX:EAX / EBX = EAX Rest EDX
    push dx              ; LIFO
    add cl,1             ; ADD soll schneller sein als INC
    or  eax, eax         ; AX = 0?
    jnz Schleife_1       ; nein: nochmal
    Schleife_2:
    pop ax               ; gepushte Ziffern zurückholen
    or al, 00110000b     ; Umwandlung in ASCII
    stosb                ; Nur AL nach [EDI] (EDI ist ein Zeiger auf den String)
    loop Schleife_2      ; bis keine Ziffern mehr da sind
    mov byte [edi],0Dh   ;CR  CarriageReturn, man könnte auch ein Komma (ascii=2C) einsetzen, dazu noch ein nullbyte als EndOfString
    add edi,1            ;ein Byte weiter
    pop   ecx            ;Register wiederherstellen
    pop   ebx            ;Register wiederherstellen
    ;************************************************************Ende Ziffer aus Register


    cmp ebx,dword[EBP+04h] ; vgl aktuelle position mit der wurzel der listengrösse
    jl L0                ; solange ebx < wurzel listengrösse, gehe vielfache eliminieren


    ;jetzt ist die Mem-Struct völlig gefüllt aber die Primzahlen sind nur bis Limes in der Prim-Struct!
    ;also muss der Rest auch noch eingetragen werden
    cmp ebx,ecx          ;dword[EBP+0h]           ; vgl aktuelle position mit dem Ende von Mem
    jl L2                ; solange ebx < limit, gehe vielfache eliminieren bzw "1"en in zifferfolgen umwandeln


    exit:                ;
    mov byte [edi],00h   ;nullbyte als EndOfString anfügen, damit hinter den Zahlen nicht die übrigen 0en und 1en stehen
    pop ebp              ; ebp des aufrufenden Programms restaurieren


    ret                  ; und zurück, in eax steht das Ergebnis


#ce

Alles anzeigen

Das war mal eine "aus dem Ärmel" geschüttelte Version für ein µ-It, um den Faktor 1000 in der Geschwindigkeit gegenüber AutoIt auszutesten
Man beachte, es dauert wesentlich länger, die Daten aus dem Speicher in einen String zu schreiben bzw. in eine Datei, als die Primzahlen nach dem über 2000 Jahre alten Sieb des Erathosthenes zu ermitteln....wer mag, kann ja mal das Limit auf 50 Millionen setzen. Da dauert die Primzahlermittlung incl. die Umwandlung aller Primzahlen in einen String auf meinem Rechner ca. 2 Sekunden.

**Andy**

Zitat von Alina

Das würde bedeuten, das ich als ersten die Primzahlen in ein Arry schreibe. Danach eine zufällige
Zahl zwischen 1 und 1065 auswählen. Das Array ist dann die erste Primzahl. Danach 6x immer
plus 1065 und schon habe ich die 7 Primzahlen.

So kompliziert würde ich das garnicht machen....
Die Primzahlen hast du doch sowieso schon, also ist die zufällige Primzahl doch $primzahl=$primzahlenarray[random(1,ubound($primzahlenarray)-1,1)), welche du einfach an eine zufällige Position im Spielfeld schreibst.
Dann brauchst du nur noch eine Funktion _Test_auf_Schwarzer_Peter(). Wenn diese eben geschriebene Primzahl einen weiteren "Schwarzen Peter" verursachen würde, dann setze sie einfach an eine andere Position.....

**Alina**

@autoBert:
Sieht gut aus. Habe ja bereits eine Primzahlberechnung gehabt, aber die schauen ich mir gerne zusätzlich an.

@Andy:
Wie Du es gepostet hast ($maximum = 99999), sagt er, das er 0 Millisekunden benötigt hat.
Bei 500000 benötigt er: 5 Millisekunden und es sind 41538 Prim's.
Habe gerade den $maximum mal auf "50000000". Und er läuft und läuft und läuft weiter.

asm? ich dachte immer, das es ASM nicht mehr gibt und nur noch von "alt gesessenen" genutzt wird.
Da habe ich aber reingeschaut und ich verstehe da nicht viel. Habe verstanden das es da
paar "Aufrufe" gibt, die abzuleiten sind vom "Batch'en / Dos'sen", aber das war es auch.
mov = verschieben
cmp = vergleichen
push = sichern
xor = ein Vergleich
ebx = Register (Speicherplatz?)
div = Division
add = Addition
pop = Aufruf (dann wäre ja aufrufen = poppen LOL)
dword = doppeltes Wort ( 2x word = 1 dword, habe ich mal irgendwo gelesen oder gehört?)

Irgendwann hat man mir mal diese Sachen XOR / OR / AND / AND OR versucht zu erklären an Hand von
Lichtschaltern. Sorry, da sind dann irgendwann bei mir die Leuchten ausgegangen. Ich glaube, das ist
wieder so eine Sache, die verstanden wird oder nicht, aber wenn, dann richtig.

So, ich möchte dann mal weiter machen.

Schönen Samstag !!!

**Andy**

Zitat von Alina

asm? ich dachte immer, das es ASM nicht mehr gibt und nur noch von "alt gesessenen" genutzt wird.

fast richtig, "alt Eingesessene" gab es schon immer, genau wie es schon immer einen Grund gab, die vorhandene Hardware optimal auszunutzen. Assembler hat aber ganz- und garnichts mit "alt" zu tun, gerade im Gegenteil, wenn man moderne Features von Prozessoren nutzen will/muss, bleibt einem meist nichts anderes übrig als mit Assembler zu programmieren da die "modernen" Compiler viele Prozessorbefehle (noch) nicht implementiert haben.

Es ist schon seltsam, noch nie gab es so schnelle Prozessoren wie heute, und trotzdem steigt der Anteil an Assemblerprogrammen (auch Programmierern?! ) in letzter Zeit wieder an:
http://www.heise.de/developer/meld…in-3263014.html

Viele Programmierer müssen sich aber mit Blick auf die Ausführungsgeschwindigkeit ihrer Programme absolut keine Gedanken machen, der Prozessor dümpelt sowieso meist nur im Idle rum, der schnellste Tastaturakrobat schafft es nicht mal, einen Prozessor aus dem Schlafmodus zu holen.
Such mal nach "Prozessorlast" hier im Forum, da wird der Irrsinn offensichtlich! Da werden >4Ghz Prozessoren gekauft, damit man "Leistung" hat, und wenn bei diesen Prozessoren die Last über 3% steigt, fängt das große Zittern an. Da werden dann "Sleep()"-Befehle eingebaut, damit das Hochleistungsgerät bei 1%%% der Maximalleistung arbeitet.
Dort, wo Code mit Blick auf Geschwindigkeit oder/und Größe optimiert werden MUSS, wird immer noch Assembler eingesetzt, s. bspw. hier: https://en.wikipedia.org/wiki/Assembly_…e#Current_usage

[OT]
Wenn ich einen Blick in die Zukunft von Assembler werfe, dann sehe ich dessen Ende auf den gängigen Rechnerarchitekturen (seitens Otto-Normal-Programmierern). Es wird bald soweit sein, dass Code nur noch in "abgeschotteten" Bereichen im Speicher laufen wird, der nicht einmal Zugriff von Disassemblern/Debuggern erlaubt. Das Märchen von den Vorteilen von Open-Source wie "Freiheit, offene Quellen, finden von Bugs und Anpassung auf eigene Bedürfnisse" ist seit Jahren schon ausgeträumt, 85% der Nutzer geben keine/geringere Lizenzkosten als Hauptaugenmerk für die Verwendung von Open-Source an. Von diesen 85% hat nicht mal 1% auch nur die Möglichkeit, Sourcecode auszuwerten, geschweige denn zu optimieren/verbessern/auf eigene Bedürfnisse anzupassen!
Die Zukunft wird aus völlig "zugenagelten" Rechnern bestehen, die unter der absoluten Kontrolle der Hersteller (Hardware und BS) stehen. Dem User wird ein kleiner Bereich gestattet in dessen eng gesteckten Grenzen er agieren darf, da wird es keine eigenen Bootloader/Treiber/Systemprogramme mehr geben. Brave new world...[OT]

Zitat von Alina

paar "Aufrufe" gibt, die abzuleiten sind vom "Batch'en / Dos'sen", aber das war es auch.

naja, mit BATCH/DOS hat das absolut nichts zu tun, mov, cmp, usw. sind Prozessorbefehle, welche mit den Prozessor-Registern arbeiten. Also direkt am offenen Herzen des Rechners. Kein Netz, kein doppelter Boden, jeder kleinste Fehler führt zum Crash!

Zitat von Alina

Irgendwann hat man mir mal diese Sachen XOR / OR / AND / AND OR versucht zu erklären an Hand von
Lichtschaltern.

https://de.wikipedia.org/wiki/Logikgatter
Wenn man die Funktion begriffen hat, bieten sich dem Programmierer in einigen Situationen große Vorteile bzgl. Codelänge und Geschwindigkeit. Guck mal in die AutoIt-Beispiele, in denen Styles und ExStyles verwendet werden, je nach Anwendung spart da ein einziger BitOR()-Befehle viele Zeilen Code.
Man hat bspw. auch die Möglichkeit, die Zustände von 32(64) Checkboxen/Lichtschaltern in einer einzigen 32(64)-Bit-Variablen zu speichern.

AutoIt

$schalter = 2009356218             ;eine variable
For $i = 0 To 31                   ;32 Zustände
    If BitAND($schalter, 2 ^ $i) Then
        $zustand = "an"
    Else
        $zustand = "aus"
    EndIf
    ConsoleWrite("Lichtschalter " & $i & " ist " & $zustand & @CRLF)
Next


ConsoleWrite(@CRLF & @CRLF)


;oder "neumodischer" mit ternären Operatoren
For $i = 0 To 31                   ;32 Zustände
    ConsoleWrite("Lichtschalter " & $i & " ist " & (BitAND($schalter, 2 ^ $i) ? "an" : "aus") & @CRLF)
Next

Alles anzeigen

**Alina**

Moin Andy.

Das werde ich mir alles gleich mal in der Ruhe ansehen. DANKE !