nicht schön, aber selten 
$text="H=E4tten H=FCte ein =DF im Namen, w=E4ren sie m=F6glicherweise keine H=FCte="&@crlf&" mehr,"&@crlf&"sondern H=FC=DFe."
[/autoit][autoit][/autoit][autoit]$text=stringreplace($text,"="&@crlf,"")
[/autoit][autoit][/autoit][autoit]$pos=0
do
$pos=stringinstr($text,"=",1,1,$pos+1)
$QP=stringmid($text,$pos+1,2) ;hex
$text=StringRegExpReplace($text,"(?s)="&$QP,chr(dec($QP)))
until $pos=0
msgbox(0,0,$text)
[/autoit]ja, da er nicht wußte, daß der erste Post freigeschaltet werden muss, hat er den nochmal erstellt....er konnte ihn auch nicht in der Suche bzw Filtern finden
Hallo,
schau dir mal in der Hilfe die
AutoItSetOption()
[/autoit]-Funktion an. Und als Parameter den MouseCoordMode
Wenn du alle Menüpunkte einrahmen willst, musst du die Funktion leicht abändern
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <GuiMenu.au3>
#Include <WinAPI.au3>
$hGui = GUICreate("MenuGUI", 400, 100)
GUICtrlCreateMenu("Menu 1")
GUICtrlCreateMenu("Menu 2")
GUICtrlCreateMenu("Menu 3")
GUISetState(@SW_SHOW)
$hMenu = _GUICtrlMenu_GetMenu($hGui)
for $i=0 to _GUICtrlMenu_GetItemCount($hMenu)
_GuiCtrlMenu_ItemBorder($hgui,$i,0xF000FE)
next
WinActivate($hGui)
[/autoit] [autoit][/autoit] [autoit]Do
$Msg = GUIGetMsg()
Until $Msg = $GUI_EVENT_CLOSE
Func _GuiCtrlMenu_ItemBorder($hGui, $iItem, $iColor, $iWidth = 2)
#cs ---------------------------------------------------------------
$hGui : Handle of menu's GUI.
iItem : Menu entry number, starting at 0 for the first entry.
$iColor : Border color (RGB).
$iWidth : Border width (pixel).
The color 0x010101 is reserved for transparent background color.
You have to include the UDF GuiMenu.au3.
#ce ---------------------------------------------------------------
Global $__GuiCtrlMenu_hBorder
Local Const $iBkColor = 0x010101
Local $hMenu, $MH, $I, $aPos, $X = 0, $W = 0, $H = 0, $aRes
If $iColor = $iBkColor Then
Return SetError(1, 1, 0)
EndIf
GUISetState(@SW_LOCK, $hGui)
;~ If IsHWnd($__GuiCtrlMenu_hBorder) And WinExists($__GuiCtrlMenu_hBorder) Then
;~ GuiDelete($__GuiCtrlMenu_hBorder)
;~ $_GuiCtrlMenu_hBorder = 0
;~ EndIf
$aRes = DllCall("user32.dll", "int", "GetSystemMetrics", "int", 15) ; $SM_CYMENU
$MH = $aRes[0]
For $I = 0 To $iItem
$aPos = _GUICtrlMenu_GetItemRect($hGui, _GUICtrlMenu_GetMenu($hGui), $I)
$X += $W
$W = $aPos[2] - $aPos[0]
$H = $aPos[3] - $aPos[1]
Next
$__GuiCtrlMenu_hBorder = GUICreate("", $W, $H, $X, -$MH, $WS_POPUP+$WS_DISABLED, $WS_EX_LAYERED+$WS_EX_MDICHILD, $hGui)
GUISetBkColor($iBkColor)
GUICtrlSetDefBkColor($iColor)
GUICtrlCreateLabel("", 0, 0, $W, $iWidth)
GUICtrlCreateLabel("", 0, 0, $iWidth, $H)
GUICtrlCreateLabel("", 0, $H - $iWidth, $W, $iWidth)
GUICtrlCreateLabel("", $W - $iWidth, 0, $iWidth, $W)
DllCall("user32.dll", "bool", "SetLayeredWindowAttributes", _
"hwnd", $__GuiCtrlMenu_hBorder, _
"dword", $iBkColor, _
"byte", 255, _
"dword", 0x3)
GUISetState()
GUISetState(@SW_UNLOCK, $hGui)
WinActivate($hGui)
Return 1
EndFunc
PAAAADDDDIIIIIIEEEEHHHH!!!!!!!!!!!!!
Mach ein Fass auf, lass es ordentlich krachen und dann geh zu deinem Boss und lass dir erst mal ne Gehaltserhöhung geben 
Glücklichen Herzwunsch!
Naja, da kann man aber mal anfangen zu optimieren und ggf auch die Kompression einbauen
Hi,
die Bitmaps auf der Platte zu speichern sollte ja kein Problem sein. Dann entweder etwas eigenes Basteln oder z.B. sowas benutzen.
Das AVI-Format ist zwar nicht das Gelbe vom Ei (ungeeignet fürs Streaming) aber ziemlich simpel aufgebaut...Die Bilder in so einen Container reinzustopfen kann so schwer ja nicht sein^^. Für den Sound gibts ja auch Profis hier im Forum (zu eukalyptus rüberwink)
Ich mach mich mal bzgl AVI schlau....
Es geht doch ohne Arrays...
$Dateiname="testdatei.txt"
[/autoit] [autoit][/autoit] [autoit]filedelete($Dateiname) ;bestehende testdatei löschen
filewrite($Dateiname,"zeile1"&@crlf&"zeile2"&@crlf&"zeile3"&@crlf) ;testdatei füllen
$inhalt=fileread($Dateiname) ;gesamten Dateiinhalt lesen
msgbox(0,"Inhalt",$inhalt)
$inhalt=stringreplace($inhalt,"zeile2"&@crlf,"") ;Inhalt bearbeiten, 2. Zeile löschen
[/autoit] [autoit][/autoit] [autoit]filedelete("testdatei.tmp") ;temporäre Datei löschen
filewrite("testdatei.tmp",$inhalt) ;Inhalt in temporäre Datei schreiben
FileCopy("testdatei.tmp",$dateiname,1) ;Datei umbenennen
filedelete("testdatei.tmp") ;temporäre Datei löschen
;man könnet natürlich deleten und direkt in die neue Datei schreiben, aber wenn dabei etwas schiefgeht( z.B. stromausfall), sind alle Daten weg...
shellexecute($dateiname)
[/autoit]Nunja, 1 Terabyte = 10^12 Byte = 1.000.000.000.000 Byte * 8 Bit / Byte = 8*10^12 Bit.
Im Prinzip müsste man also nur noch herausfinden, welche Primzahl in der Nähe von 8*10^12 ist. Bis 10^12 gibts eine Liste der Primzahlen übrigens hier
Die Wurzel von 8e12 ist irgendwo bei 2,83 Millionen, die Primzahlen bis dorthin bekommt man auch schon mit AutoIt in relativ kurzer Zeit heraus...
Und dann gibts ja noch die BIGINT.UDF, mit der man dann einfach die möglichen Primzahlen kleiner8*10^12 auf Prim prüft 
Im Primzahl-µIt hatte ich ein Verfahren vorgestellt, nicht jede Zahl in der Liste zu speichern, sondern die Vielfachen von 2,3 und 5 zu eliminieren. Das spart ca. 3/4 Speicherplatz! Wenn man sich die grafische Darstellung der Primzahlen im oben vorgestellten Script anschaut, wäre das die Eliminierung der "weissen senkrechten Balken". Denn das sind alles Vielfache von 2,3 oder 5.
#include <String.au3>
#include <Array.au3>
;Sieb von Eratosthenes, komprimiert
;
Global $z
Global $limit = 1299709 ;alle Primzahlen bis zum Limit finden
$arraysize = (Int($limit / 30) + 1) * 8 ;Array zur Aufnahme der möglichen Primzahlen, alle Vielfachen von 2,3 und 5 werden nicht berücksichtigt
Dim $a[$arraysize]
;der Vorteil ist, man braucht nur 1/4 des Speicherplatzes für das Sieb
;es werden in diesem komprimierten Sieb alle Vielfachen von 2,3 und 5 nicht berücksichtigt, daraus ergibt sich eine "Matrix" mit möglichen Primzahlen
;Zahlen Spalte
; 0 1 2 3 4 5 6 7
;Zeile
;0 1 7 11 13 17 19 23 29 in dieser Zeile stehen die Spaltenindizes
;1 31 37 41 43 47 49 53 59
;2 61 67 71 73 77 79 83 89
;3 91 97
; Formel zur Berechnung der möglichen Primzahlen:
; Prim = Zeilenanzahl * 30 + Spaltenindex Spaltenindex(0)=1 usw...
Dim $spaltenindex[8] ;
$spaltenindex[0] = 1
$spaltenindex[1] = 7
$spaltenindex[2] = 11
$spaltenindex[3] = 13
$spaltenindex[4] = 17
$spaltenindex[5] = 19
$spaltenindex[6] = 23
$spaltenindex[7] = 29
;dann folgt ein Array, in dem die Spaltenindizes(+1) den Primzahlen von 0-30 zugeordnet werden
Dim $b[31] = [0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 4, 0, 0, 0, 5, 0, 6, 0, 0, 0, 7, 0, 0, 0, 0, 0, 8, 0]
;jede Vielfache der Primzahl soll aus der Matrix eliminiert werden, in der Matrix stehen aber nur Vielfache der Primen von 7 bis 29
;also wird nur die Zahl aus der Matrix eliminiert, bei der gilt:
;$b[Rest] <> 0 wobei Rest = mod ( Vielfaches der Prim , 30 )
;
;die Vielfachen der Primzahlen werden eliminiert, indem an ihre Position in der Matrix eine Zahl (zur Verdeutlichung das Vielfache) geschrieben wird
;Ist das Sieb fertiggestellt, sind die Arrayelemente mit 0 die Primzahlen, alle anderen sind eliminierte Vielfache
$tt = TimerInit()
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]$a[1]=1
$flag = 0
$primstring = ""
For $x = 0 To $arraysize ;Anzahl aller möglichen Primzahlen in der Matrix
For $y = 0 To 7 ;jedes Element in der Zeile
If $a[$y + 1 + ($x * 8)]<>0 Then ContinueLoop ;nur Elemente mit 0 sind Primzahlen
$prim = $x * 30 + $spaltenindex[$y] ;das ist die Primzahl
$qprim = $prim ^ 2 ;alle Vielfachen ab dem Quadrat dieser Primzahl eliminieren...
If $qprim > $limit Then ExitLoop 2 ;wenn Quadrat der Primzahl > Wurzel aus limit, dann besteht das sieb nur noch aus Primzahlen
$r = Mod($qprim, 30) ;mod der Zahl liefert den Rest
$d = Int($qprim / 30) ;int/30 liefert die Zeile der Zahl
If $b[$r] <> 0 Then ;wenn Zahl ein Vielfaches eines der Spaltenindizes, dann alle weiteren Vielfachen eliminieren
$a[$b[$r] + ($d * 8)] = $prim ;Im Arraydisplay sieht man sehr schön die eliminierten Vielfachen
$t=timerinit()
$w=0
For $m = $qprim To $limit Step $prim ;alle Vielfachen aus der Matrix eliminieren
$r = Mod($m, 30)
$d = Int($m / 30)
If $b[$r] <> 0 Then
$a[$b[$r] + ($d * 8)] = $prim
EndIf
$w+=1 ;anzahl eliminierter Zahlen = Vielfache der Prim
Next
$m=timerdiff($t)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $m = ' &$prim&" "&$w&" "& $m & @crlf & '>Error code: ' & @error & @crlf) ;### Debug Console
endif
Next
Next
$m = TimerDiff($tt)
Msgbox(0,"Komprimiertes Sieb von Eratosthenes"," Primzahlen in "&int($m)&" Millisekunden!" & @CRLF &"Bitte im Anschluss kurz auf das Arraydisplay warten...."&@crlf&"Im Arraydisplay sind in der zweiten Spalte alle leeren Felder Primzahlen, ansonsten steht in der 2. Spalte ein Teiler der Zahl in der linken Spalte")
_ArrayDisplay($a)
$primstring = "2" & @CRLF & "3" & @CRLF & "5" & @CRLF
$n = 3
For $i = 1 To $arraysize - 2
If $a[$i + 1] = 0 Then ;Primzahl im Sieb gefunden
$r = Mod($i, 
$d = Int($i /
$n += 1
$primstring &= $d * 30 + $spaltenindex[$r] & " " & $n & @CR ;Ausgabe der Primzahlen
EndIf
Next
ConsoleWrite($primstring)
Exit
Um also eine Zahl auf Prim zu prüfen reicht es, von der Zahl die 8 Spaltenindizes 1,7,11,13,17,19,23,29 zu subtrahieren und das Ergebnis durch 30 zu teilen. Ist dieses Ergebnis in allen Fällen <>0, dann ist diese Zahl nicht in der "Tabelle" enthalten, also definitiv nicht prim.
Man kann aber noch weiter vereinfachen!
Die "Tabelle" der möglichen Primzahlen sieht ja so aus:
;Zahlen Spalte; 0 1 2 3 4 5 6 7;Zeile;0 1 7 11 13 17 19 23 29 in dieser Zeile stehen die Spaltenindizes;1 31 37 41 43 47 49 53 59;2 61 67 71 73 77 79 83 89;3 91 97; Formel zur Berechnung der möglichen Primzahlen:; Prim = Zeilenanzahl * 30 + Spaltenindex Spaltenindex(0)=1 usw...Die letzte Ziffer der möglichen Primzahl ist immer identisch mit der letzten Ziffer der Zahl in der Zeile 0.
Wenn man also Zahl=1234557 auf Prim prüfen würde, müsste man nur zwei Tests durchführen, um zu ermitteln, ob diese Zahl überhaupt eine Primzahl sein kann!
If mod(Zahl-7,30)<>0 then keine_primzahl
If mod(Zahl-17,30)<>0 then keine_primzahl
1234557 ist somit keine Primzahl!
Ist die Zahl also in der "Tabelle" enthalten, könnte es eine Primzahl sein, und es muss nur noch durch die in der Tabelle nicht vielfachen (also den Primzahlen) bis zur Wurzel der Zahl geteilt werden. Dieses Verfahren reduziert die Anzahl der Berechnungen enorm!
Da eine "Zeile" der Tabelle genau 8 Zahlen enthält, könnte man ein komprimiertes Sieb erstellen, bei dem 1 Bit in einem Byte festlegt, ob die Zahl eine Primzahl ist oder nicht 
Byte1 = "00000000" ;erste Zeile alle Primzahlen 1,7,11,13,17,19,23,29
Byte2 = "00000100" ;49 ist keine Primzahl
Byte3 = "00001000" ;77 ist keine Primzahl
uswusf. (die Bits kann man setzen wie man möchte, ob "regulär" von rechts nach links oder von links nach rechts(dann entspricht es der Tabelle) ist schnurz...)
Wer jetzt Lust bekommen hat, kann ja die Tabelle in Bytes packen und sich ein komprimiertes Sieb "auf Platte" legen.
Dann muss man, um festzustellen, ob eine Zahl eine Primzahl ist nur noch das Bit an der Position
Byte = int(Zahl/30)
Bit = $b[ mod(zahl,30)-1] ;$b=[0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 4, 0, 0, 0, 5, 0, 6, 0, 0, 0, 7, 0, 0, 0, 0, 0, 8, 0]
testen...
Falls Bit=-1, ist die Zahl keine Primzahl.
Und das kostet nicht mal Speicher, denn mit FileSetPos() zieht man sich nur das eine zu testende Byte aus der Datei!
Um z.B. eine zufällige Primzahl zu erzeugen, liest man ein zufällliges Byte aus der Datei. Ist dieses Byte<>0xFF ( 11111111 heisst ja, keine Primzahl enthalten), dann das nächste 0-Bit im Byte suchen und die zufällige Primzahl ist gefunden.
...eine "grafische" Lösung zur Ermittlung der Primzahlen^^
Dauert zwar bissl, aber dafür hat man am Ende eine feine Bitmap mit allen Primzahlen.(Maus bewegen nicht vergessen^^)
Da man (Monochrom)-Bitmaps in nahezu jeder Größe speichern kann, hat man so immer eine "Primzahltabelle" dabei.
Ein "_isprime()" reduziert sich somit auf ein "Pixelgetcolor"
#include <WinAPI.au3>
#include <String.au3>
#include <Misc.au3>
;Sieb des Eratosthenes, grafisch
AutoItSetOption("PixelCoordMode", 2)
AutoItSetOption("MouseCoordMode", 2)
$gdi32 = DllOpen("gdi32.dll")
$u32_dll = DllOpen("user32.dll")
;maximale Fenstergrösse ermitteln und so einstellen, daß ein "Primzahlmuster" entsteht
$VirtualDesktopWidth = DllCall($u32_dll, "int", "GetSystemMetrics", "int", 78) ;sm_virtualwidth
$Width = ($VirtualDesktopWidth[0] - Mod($VirtualDesktopWidth[0], 210)) - 210 ;210 = 2*3*5*7 das Produkt der ersten 4 primzahlen
$VirtualDesktopHeight = DllCall($u32_dll, "int", "GetSystemMetrics", "int", 79) ;sm_virtualheight
$Height = $VirtualDesktopHeight[0] - 100
$maximum = $Width * $Height ;maximale Größe der Primzahl
[/autoit] [autoit][/autoit] [autoit]$hgui = GUICreate("", $Width, $Height, 0, 0)
$hwnd = WinGetHandle($hgui) ;Handle der Gui, braucht man für pixelgetcolor()
$hdc = _WinAPI_GetDC($hwnd) ;Devicecontext, braucht man für _Pixelsetcolor()
$pic = GUICtrlCreateGraphic(0, 0, $Width, $Height) ;die "Grafik"
GUICtrlSetBkColor($pic, 0) ;Hintergrundfarbe schwarz
GUISetState()
;alle schwarzen Pixel der Grafik sind Primzahlen, also müssen alle Vielfachen der gefundenen Primzahlen
;mit einer Farbe markiert werden. 0 und 1 sind per Definition keine Primzahlen,
;also werden diese Pixel in der Grafik weiß markiert
_pixelsetcolor($hdc, 0, 0, 0xFFFFFF) ;0 ist per Definition keine Primzahl
_pixelsetcolor($hdc, 1, 0, 0xFFFFFF) ;1 ist per Definition keine Primzahl
$Anzahlprim = 1 ;Anzahl der Primzahlen
$flag = 1 ;wenn Sieb gefüllt ist, wird $flag =0, dann sind alle Primzahlen im Sieb gefunden
$action = " Eliminieren der Vielfachen von "
For $i = 2 To $maximum ;alle Zahlen ab 2 auf Prim testen
$y = Int($i / $Width) ;y-koordinate des Pixels
$x = $i - $Width * $y ;x-koordinate des Pixels
If $flag = 0 Then ;wenn das Sieb gefüllt ist , werden die Primzahlen unter dem Mauszeiger angezeigt
$mauspos = MouseGetPos()
If $mauspos[0] > 0 And $mauspos[1] > 0 And $mauspos[0] < $Width And $mauspos[1] < $Height and PixelGetColor($mauspos[0] - 1, $mauspos[1] - 1, $hwnd) <> 0xFFFFFF Then
ToolTip($mauspos[0] - 1 + $Height * ($mauspos[1] - 1)& " ist eine Primzahl")
endif
EndIf
If PixelGetColor($x, $y, $hwnd) <> 0 Then ContinueLoop ;falls pixelfarbe<>0, dann ist es keine Primzahl, da als Vielfache mit einer Farbe markiert
_pixelsetcolor($hdc, $x, $y, 0x0000FF) ;primzahlen rot markieren, um die aktuelle Position im Sieb zu zeigen
WinSetTitle($hgui, "", "Sieb des Eratosthenes, Aktuelle Primzahl: " & $i & " Anzahl Primzahlen bisher: " & $Anzahlprim & $action & $i)
$Anzahlprim = $Anzahlprim + 1 ;Anzahl der gefundenen Primzahlen +1
If $i > Sqrt($maximum) And $flag Then ;wenn die Wurzel des Maximums überschritten ist, dann ist das Sieb gefüllt!
$flag = 0 ;ab nun können unter dem Mauszeiger die Primzahlen angezeigt werden
$action = " Primzahlen rot markieren: "
WinSetTitle($hgui, "", "Das Sieb ist gefüllt, alle weißen Pixel sind Vielfache einer Primzahl. Alle schwarzen Pixel sind keine Vielfachen einer Primzahl, also sind sie Primzahlen! Leertaste drücken...")
Do
Sleep(50)
Until _IsPressed("20") ;warten, bis Leertaste gedrückt wurde
EndIf
For $prim = $i * $i To $maximum Step $i ;alle vielfachen der Primzahl eliminieren
$y = Int($prim / $Width) ;y-koordinate des Pixels
$x = $prim - $Width * $y ;x-koordinate des Pixels
_pixelsetcolor($hdc, $x, $y, 0xFFFFFF) ;vielfache werden markiert mit weißer Farbe
Next
Next
MsgBox(0, "Primzahlen", "Man könnte dieses Sieb als Bitmap speichern und als Sieb für die Ermittlung der Primzahlen bis " & $maximum ^ 2 & " verwenden!")
Exit
Func _pixelsetcolor($dc, $x, $y, $color) ;pixel mit color an koordinaten setzen
DllCall($gdi32, "long", "SetPixel", "long", $dc, "long", $x, "long", $y, "long", $color)
EndFunc ;==>_pixelsetcolor
Man könnte die Datei ja so anlegen, daß die gesetzten Bits die Primzahlen ergeben....Frage an die Gemeinde, wie ist die größte "Primzahl" bzw wie viele Primzahlen sind es, die sich so auf einer 1 Terabyte-Platte darstellen lassen würden?^^
Anstatt sich aufzuregen, sollte man mal nachdenken, welche Möglichkeiten es gibt:
- haben beide "Strings" die identische Länge?
- sind beide "Strings" überhaupt im identischen Format?
- ist die binary() beider Ergebnisse unterschiedlich, wenn ja , wo
- kopieren der Strings in den Scite-Editor und Einschalten der Leerzeichen und Zeilenenden
...und und und
@Shadow, FINIT sollte man benutzen, wenn man den Prozessor und die Register in einen definierten Ausgangsstatus bringen muss. Um mal eben ein Register zu benutzen ist das nicht nötig. Wenn man viel und oft mit den Float-Registern arbeitet, dann ist es natürlich sinnvoll, vorher alles zurückzusetzen. Dann kann einem nicht "aus Versehen" eins der Register mit Werten dazwischenpfuschen, die man garnicht erwartet.
Wie du sicher schon gemerkt hast, ist der DIV ein sehr "teurer" Befehl, er kostet so um die 70-80 Takte, also ist es immens wichtig,so viele Divisionen wie möglich einzusparen.
Da die Sprungvorhersage "Branch Prediction" des Prozessors bei jedem Durchlauf in deiner inneren Schleife (dem "inner Loop") zu 50% falsch liegt (wird die Schleife verlassen oder nicht) macht man das sogenannte "loop unrolling". Das heisst, die Schleife geht beispielsweise nicht
for i=1 to 100
a=a+1
next
sondern
for i=1 to 25
a=a+1
a=a+1
a=a+1
a=a+1
nextBerechnen muss man zwar jedes Element weiterhin, aber da der Prozessor die nächsten Befehle ALLE sicher kennt, kann er diese Befehle optimal in seine Pipelines einsortieren. Das erhöht die "Schwuppdizität"
Wollte das halt wissen weil es viele noobs gibt die einen Code einfach nehmen und diesen dann als ihren ausgeben.
Echt? In China ist ein Sack Reis umgefallen...
Es soll sogar Leute geben, deren Script besteht ausschliesslich aus der Arbeit (UDF´s) von anderen...
Weil Sicherheit sollte gewehrleistet werden
Wann hast du dich das letzte Mal mit "Sicherheit" im Bezug auf Computer auseinandergesetzt? Lade dir einen beliebigen Debugge/Disassembler aus dem Netz und analysiere den Code. KEIN Programm kann sich dagegen schützen! Seit anbeginn aller Zeiten wird Reverse Engeneering betrieben, und die Schlaumeier, welche dachten, man könne Krypto-Algorithmen einfach in Hardware gegossen auf Chips "sicher" machen, hatten vorher noch nie etwas von einer Schleifmaschine und einem Mikroskop gehört...NICHTS in, um und an einem Computer ist sicher! Man kann es dem "Angreifer" schwer machen, aber gänzlich aussperren kann man ihn nicht.
Und um mal zum eigentlichen Thema zu kommen, was ist an deinem Programm so besonderes, daß du es mit allen Mitteln schützen musst? Sind dort irgendwelche besonders "geheimen" Algorithmen am Werk, unterliegt dein Script irgendwelchen Geheimhaltungsanforderungen seitens deines Arbeitgebers oder enthält es wichtige Firmendaten? Wohl kaum 
Wenn du nicht willst, daß dein Code benutzt wird, veröffentliche ihn nicht!
Naja, es reagiert auf die Position der Maus, wenn du mit dem Mauszeiger die Bildschirmränder abfährst, siehst du ja das Ergebnis...
ist das irgendwie nutzbar zu machen sagen wir das es z.b. auf audio reagiert?
wieso nicht, ersetze die Mauspositionen mit den Pegeln eines Audio-Outputs, und das wars...
oder ist das nur n just4fun script
Nein, damit kann man die Weltherrschaft erlangen....nimmst du Drogen?
@Shadow, sehr nice, aber du verschenkst extrem viel Zeit bei unnötigen Berechnungen
Eigentlich musst du nur die ungeraden Zahlen bis zur Wurzel der vermeintlichen Primzahl untersuchen.
Weiterhin müsste eine Abfrage abfangen, ob die eingegebene Zahl > 2^31 ist, denn bei deiner Funktion dürfen (siehe DIV) nur vorzeichenbehaftete Integer (int) als Primzahlen verwendet werden!
_("use32")
_("mov esi,[esp+4]");parameter speichern -->eax
_("mov ebx,2");püfen ob durch 2 teilbar
_("mov eax,esi");wenn es geht, immer mit registern statt mit speicher arbeiten!
_("xor edx,edx");modulo vorbereiten
_("div ebx");durchführen
_("cmp edx,0");prüfen ob es durch 2 teilbar ist
_("je ende1");wenn das so ist dann springe zum ende (keine primzahl)
_("fild dword[esp+4]") ;integerzahl laden 32 bit in ST0
_("fsqrt") ;wurzel aus ST0
_("fistp dword[esp+4]") ;wurzel speichern
_("mov ebx,[esp+4]");zähler ebx (es wird durch ebx geteilt)
;falls int(wurzel) =gerade zahl, dann um 1 erhöhen
_("shr ebx,1") ;/2
_("inc ebx") ;+1
_("shl ebx,1") ;*2
_("inc ebx") ;+1 immer ungerade Zahl! eins größer als wurzel(zahl)
_("for:");schleifenlabel
_("sub ebx,2");zähler dekrementieren, nur ungerade teiler
_("xor edx,edx")
_("div ebx");durchführen
_("cmp edx,0");und auswerten
_("je ende1");keine primzahl
_("mov eax,esi");eax wieder auf den richtigen wert setzen
_("cmp ebx,3");prüfen ob zahl durch die geteilt wird 3 ist (2 hatten wir oben schon)
_("jne for");sonst schleife wiederholen
_("mov eax,1");ende: ist primzahl
_("ret 4");ende
_("ende1:");label für ende: keine primzahl
_("mov eax,ebx");keine primzahl eax gibt den teiler zurück
_("ret 4");ende
Func _($str) ; Nur für die bequemlichkeit
Fasmadd($Fasm, $str)
EndFunc ;==>_
habe mal dein Programm mit Wurzel und nur den ungeraden Teilern erweitert
Wo ist denn das Problem?
Die entsprechende Funktion selbst implementieren und fertig...
Suche hilft....[ gelöst ] Externe IP auslesen?