Beiträge von Xorianator

Um welche Website handelt es sich dabei?
Nur der Quellcode wird hier wenig weiterhelfen und das Ganze sieht sehr dubios aus (im Sinne von: Es ist nicht im Interesse des Erstellers, dass du die Seite als Roboter bedienst)

Zitat von Oscar

Bei Zufallsdaten ist es schwierig einen geeigneten Pivotwert zu finden

Quickselect wäre doch eine Möglichkeit, wenn man es mit dem approximierten Median of medians verwendet. Dann hast du zwar nicht den exakten Median (zumindest gibt es kein Garant dafür), aber bist ziemlich nah dran und die Komplexität ist Linear.

AspirinJunkies Idee gefällt mir auch, heuristisch dürftest du damit fast immer richtig liegen.

Zitat von alpines

Ich hab ein kleines Beispielprogramm geschrieben und das zeigt das ganze auch schön:

C

#include <stdio.h>
#include <stdlib.h>

int main()
{
    const int TEST_SIZE = 5000;

    void* pSpaceMalloc = malloc(TEST_SIZE);
    void* pSpaceCalloc = calloc(TEST_SIZE, 1);

    int counterMalloc = 0;

    char* pMalloc = (char*)(pSpaceMalloc);

    for (int i = 0; i < TEST_SIZE; i++)
    {
        if (*pMalloc != 0) counterMalloc++;
        pMalloc += 1;
    }

    printf("Non-Zeroes Malloc: %d\n", counterMalloc);


    int counterCalloc = 0;

    char* pCalloc = (char*)(pSpaceCalloc);

    for (int i = 0; i < TEST_SIZE; i++)
    {
        if (*pCalloc != 0) counterCalloc++;
        pCalloc += 1;
    }

    printf("Non-Zeroes Calloc: %d", counterCalloc);
    getchar();

    return 0;
}

Alles anzeigen

Code

Non-Zeroes Malloc: 18
Non-Zeroes Calloc: 0

Danke, mir war ja bewusst, dass der Effekt existiert, sonst hätte ich nicht gefragt. War mir nur nicht bewusst, dass calloc() uns dieses unsauberen Effekts entledigt.

Zitat von alpines

Dafür gibt es ja calloc. malloc stellt dir nur den Speicher zur Verfügung, zur Sicherheit sollte man diesen mit Nullen überschreiben.

Danke, wieder was gelernt

Ist es denn 100% gewährleistet, dass der Speicher für das Bool auch wirklich 0 ist? Ich meine es gab da was, dass man nicht gewährleisten kann, was im Speicher drinnen steht. Würde das dann nicht im Extremfall zum Ausbleiben von gefundenen Pixeln führen?

Zitat von alpines

Ich weiß allerdings nicht ob BitAnd() oder die einfache Subtraktion (mit kurzer Prüfung im voraus) schneller ist.

In jedem Falle ist BitAND richtig, so viel vorweg. Ich habe es jetzt ein paar Mal mit Beidem durchlaufen lassen, das BitAnd dauert um die 100ms länger (1700 vs 1800).

Soweit ich das jetzt "gemessen" habe, ist das Bottleneck die DllStruct. Schneller als mit alpines' Array wirst du es nicht hinbekommen, es sei denn man nimmt ein Hashset, so wie ich das sehe hast du das aber in der ursprünglichen Version schon getan.

Zitat von alpines

Mit Arrays (vorausgesetzt es existiert keine Transparenz, da das sonst die Arraygrößen sprengt) schaffe ich es in rund 1300ms.

Den Speicherverbrauch von 80 Megabyte ignorieren wir mal

Code

$iW * $iH = 708197 px
Zeit: 1366 ms
Anzahl der Farben: 99394

AutoIt

#include <GDIPlus.au3>

Global $sImagefile = @ScriptDir & '\test.jpg'
Global $aColor[0xFFFFFF]

_GDIPlus_Startup()
Global $hImage = _GDIPlus_BitmapCreateFromFile($sImagefile)
$iTimer = TimerInit()
$iCount = _GetUniqueColors($hImage)
ConsoleWrite('Zeit: ' & Int(TimerDiff($iTimer)) & ' ms' & @CR)
ConsoleWrite('Anzahl der Farben: ' & $iCount & @CR)
_GDIPlus_BitmapDispose($hImage)
_GDIPlus_Shutdown()
Exit

Func _GetUniqueColors(ByRef $hImage)
    $iColorCounter = 0

    Local $iW, $iH, $tBitmapData, $pScan0, $tPixel, $iOffset, $iColor, $oUnique = ObjCreate('Scripting.Dictionary')
    $iW = _GDIPlus_ImageGetWidth($hImage)
    $iH = _GDIPlus_ImageGetHeight($hImage)
    $tBitmapData = _GDIPlus_BitmapLockBits($hImage, 0, 0, $iW, $iH, $GDIP_ILMREAD, $GDIP_PXF32ARGB)
    $pScan0 = DllStructGetData($tBitmapData, 'Scan0')
    $tPixel = DllStructCreate('uint[' & $iW * $iH & '];', $pScan0)
    ConsoleWrite('$iW * $iH = ' & $iW * $iH & ' px' & @CRLF)
    For $iY = 0 To $iH - 1
        $iOffset = $iY * $iW + 1
        For $iX = 0 To $iW - 1
            $iColor = DllStructGetData($tPixel, 1, $iOffset + $iX) - 0xFF000000
            $aColor[$iColor] += 1
            If $aColor[$iColor] = 1 Then $iColorCounter += 1
        Next
    Next
    _GDIPlus_BitmapUnlockBits($hImage, $tBitmapData)
    $tPixel = 0
    Return $iColorCounter
EndFunc

Alles anzeigen

Schöne Lösung, mit einem klitzekleinen Fehler:

Das Array braucht eine Größe von 0xFFFFFF + 1, da du sonst kein Weiß drinnen hast.

Ich unterstelle hier mal ganz kühn böse Absicht, denn:

1. Wer eine eigene Website hat, sollte im Stande sein, den Code zu verändern

2. Ist auch das Warten, welches er beschreibt, sehr einfach erledigt.

€: (Ich sollte zu Ende denken und dann den Post Knopf drücken) - Deshalb wäre es gut, wenn du die Website hier verlinkst oder Screenshots bereit stellst.

Die letzte Frage ohnehin wäre aber sowieso: Was willst du erreichen (XY Problem), denn alles was du mit AutoIt in deiner Website machen kannst, kannst du auch mit PHP.

Keine persönliche Erfahrung, im Umfeld jedoch nutzen einige einen Mac und konnten ohne Probleme alles zocken, was man zocken kann. Daher denke ich, dass es auch bei anderen Programmen gleich aussieht und es keinerlei Probleme verursachen sollte.

Im Falle von Bootcamp liegt Windows als solches vor, nicht als Emulation, es gibt keinen Man-In-The Middle, alle Zugriffe erfolgen direkt. Es ist quasi wie jeder andere Rechner der Windows drauf hat.

"Ob wer aus meiner Liste in deren Tagesliste auftaucht" sag das doch gleich: Die URL ist dann https://trauer.rheinpfalz.de/traueranzeigen/_/_/_/0/06-10-2017/06-10-2017/0/1, wobei das Grüne das Startdatum ist und das Rote das Enddatum.

Ah, ja, nette Idee, natürlich. Wenn man schon die Elemente wissen will, dann doch gleich die Teilmengenbeziehung. Mir kam erstmal nur das Element in den Sinn

Sehr schön

Setzt natürlich voraus, dass der Anwender weiß, dass es auf einem Dictionary geschieht.

Sehr schöne UDF, kann ich nicht lesen oder fehlt tatsächlich ein Contain? Das wäre dann nämlich noch ganz interessant zu wissen

Wenn ich mich jetzt nicht vertan habe, dann müsste das der 4 Zeiler sein:

Func _set_contains(ByRef $o_Set1, $element)
    If Not __set_IsSet($o_Set1) Then Return SetError(1)
    Return $o_Set1.Exists($element)
EndFunc   ;==>_set_Intersect

Anmerkung 2 : Das kann natürlich auch jeder selbst schreiben, als Einzeiler, ich dachte nur, der Vollständigkeit halber wäre eine Prüfung x ∈ M vielleicht nicht verkehrt.

Zitat von Paul01

Den Ansatz versteh ich jz schon hinten und vorne nicht mehr...

Wie kommst du auf diese URL? Wenn ich die von heute anzeigen möchte habe ich folgede URL:

https://trauer.rheinpfalz.de/traueranzeigen/_/_/_/_/1/1

Also du gehst dann mit Regex rein aber was genau du da machst, versteh ich nicht..

Ahja, die URL. Nun, long story short:

Wenn man die Suche auf deiner in Beitrag 1 angegebenen URL nimmt, ohne etwas einzugeben, dann landet man bei eben genannter URL. Probiere es einfach mal selbst aus

Um jetzt raus zu finden, wie man die Seiten durch gehen kann, schaut man einfach den Unterschied von 2 Seiten in der URL an.

https://trauer.rheinpfalz.de/traueranzeigen/_/_/_/0/0/1
https://trauer.rheinpfalz.de/traueranzeigen/_/_/_/0/0/2

Das scheint also der Zähler zu sein, mit dem man die Seiten der Todesanzeigen durch iterieren kann. "Leider" bauen sie ihre Traueranzeigen nicht von Hinten nach Vorne auf, sonst wäre eine Aktualisierung einfacher, wenn man nach einer Weile den Datensatz updaten will.

Den Rest mit dem RegEx haben dir die beiden Anderen schon beantwortet.

Ich habe dir hier mal einen kleinen Ansatz da gelassen, viel Erfolg!

#include <Array.au3>
Local $Counter = 1
$IES = BinaryToString(InetRead("https://trauer.rheinpfalz.de/traueranzeigen/_/_/_/0/0/" & $Counter))
Local $Matches = StringRegExp($IES, '(?s)#828172">Traueranzeige (.*?)<.*?labelSearchItem">\* (.*?) - &dagger; (.*?)<', 3)

Local $InfoArry[Int(UBound($Matches)/3)]
For $i = 0 to UBound($Matches) - 1 Step 3
    $InfoArry[$i / 3] = $Matches[$i] & "|" & $Matches[$i + 1] & "|" & $Matches[$i + 2]
Next

_ArrayDisplay($InfoArry)

Herzkichsten Glühstrumpf. Danke, dass du uns erhalten bist und hoffentlich lange bleibst

Ich warte mal wieder mit einem kleinen Snippet auf, heute geht es um ein LinearFeedbackShiftRegister.

Erstmal: Wozu braucht man das überhaupt? LFSR werden dazu genutzt um schnell Pseudo-Zufallszahlen zu generieren. Diese sind streng deterministisch, deshalb bietet es sich überhaupt nicht an, so etwas zur Schlüsselerzeugung (Kryptografie) zu verwenden, wird aber dennoch in diesem Bereich genutzt, jedoch nicht zur Schlüssel Generierung sondern zur Rauscherzeugung. Wer mehr wissen möchte, der lese sich bitte in Wikipedia den Artikel durch Linear Rückgekoppeltes Schieberegister.

Der Code ist unspektatkulär, die Kommentare auf englisch, weil ich das gerade mehr gewohnt bin, wer Langeweile hat kann ja mal ein bisschen damit rumspielen.

Das Ganze ist in Hardware natürlich wesentlich schöner umzusetzen, da man pro Takt genau ein Schlüsselbit generieren kann.

#include <Array.au3>
; LFSR Generator
Func _GenerateLFSR($LFSRvector, $key, $count = 0)

    Local $degree = UBound($LFSRvector)
    Local $findSequence = False

    If StringLen($key) <> UBound($LFSRvector) Then                                ;Vector has to be same size as key
        Return -1
    EndIf
    If $count = 0 Then                                                            ;count = 0 => We search for the longest
        $count = 2 ^ ($degree)                                                    ;sequence until it repeats itself
        $findSequence = True                                                    ;Longest sequence possible is apparantly
    EndIf                                                                        ;2^m - 1, therefore we have to compute
;                                                                                ;2^m steps to compare (or look for = 2^m)
    Local $repeat
    Local $xorFlipFlop                                                            ;Feedback Register
    Local $keyArray = StringSplit($key, "")                                        ;
    Local $outputArray[$count][$degree + 1]                                     ;Last column will be output

    For $i = 0 To $degree - 1 Step 1                                            ;Initialize Array (Hardware Implemenatation:
        $outputArray[0][$i] = $keyArray[$i + 1]                                    ;    Initialize Flip Flops)
    Next

    $outputArray[0][$degree] = $keyArray[$degree]                                ;s0 = k0

    For $row = 1 To $count - 1 Step 1                                            ;Simulates a clock
        $xorFlipFlop = 0                                                        ;Feedback, will be computed while setting new registers
        For $column = 1 To $degree - 1 Step 1                                    ;Set all registers except the feedback one
            $outputArray[$row][$column] = $outputArray[$row - 1][$column - 1]    ;New[i] = Old[i - 1]
            If ($LFSRvector[$column] == 1) Then                                    ;Check whether pi = 1, so if the current bit will shift back
                $xorFlipFlop += $outputArray[$row - 1][$column]                    ;If so, add
            EndIf
        Next
        $outputArray[$row][$degree] = $outputArray[$row][$degree - 1]            ;Set Output = Last register
        $outputArray[$row][0] = Mod($xorFlipFlop, 2)                            ;Set feedback register = XOR (which is congruent m1odulus 2)
        If $findSequence Then                                                    ;Check whether we need to find the sequence or not
            $repeat = true                                                        ;Initialize whether it's repetition or not
            For $i = 0 To $degree Step 1                                        ;Iterate through all registers
                 If $outputArray[0][$i] <> $outputArray[$row][$i] Then            ;Compare bitwise
                    $repeat = false                                                ;If unequal, it does not repeat
                    ExitLoop                                                    ;Can stop loop on first occurence
                EndIf
            Next
            If $repeat Then
                ReDim $outputArray[$row][$degree + 1]                            ;Cut Array, because we just need the unique sequence
                Return $outputArray
            EndIf
        EndIf
    Next

    Return $outputArray
EndFunc   ;==>_GenerateLFSR

Dim $LFSRvector[3] = [0, 1, 1]
_ArrayDisplay(_GenerateLFSR($LFSRvector, "100", 0))

Anmerkung: Wem gerade eine effizientere Implementierung in Software einfällt, der möge diese gerne teilen Ich brauchte nur ein schnelles Script, da ich keine Lust hatte die Tabellen von Hand aufzustellen.

Ich plädiere für eine längere Nachrichtenlänge in der Shoutbox. Muss ja nicht so sein, dass man einen Roman schreiben kann, nur hat diese sich verkürzt, oder irre ich?

Dass das per Skript geht ist mir klar, ich hätte aber gerne eine generelle Alternative ohne Skript, sofern möglich. Danke für die GMonkey Option dennoch, Aspirin.

Raupi sie hat sich vorhin einfach von selbst ausgegraut, während ich eine Nachricht schrieb und das war gerade mal ein paar Sekunden zwischen "aktivieren" und "ausgrauen". Aber Danke.

Ist es möglich ein Design zur Verfügung zu stellen bei dem die Top Bar nicht 50px unten ist, sondern 0px und das Padding des Main auch auf 0px gesetzt wird, sprich: Alles rutscht 50px nach oben?