Beiträge von Mars

**Mars**

Ergänzung zum Template: Ggf prüfen, ob der String nachher wirklich identisch mit dem Input ist.

Frage zu den Bedingungen:

- Man kann davon ausgehen, dass "nicht nur der Text aus der Aufgabenstellung" bei der Bewertung ausprobiert wird oder? Welche "Art" von Text wird verwendet werden? (z.B. Base64String, Der Dateiinhalt einer Win32.exe, ein Foto, oder die lateinische Wikipedia?)

- Kann man davon ausgehen, dass "zu langsame" Algorithmen nicht teilnehmen können? Ich habe vor langer Zeit mal etwas gebastelt (ein adaptiver Huffman Codierer mit coolem Tree der sich dynamisch anpasst), der läuft aber mit ca. 1 BYTE pro Sekunde^^ Also vermute ich, dass der Algorithmus in nativem AutoIt (ohne Dllcalls) mit sagen wir mal: 128+Byte/s klarkommen muss (habe ich jetzt willkürlich geraten), sonst kann er nicht teilnehmen.

- Mit welcher Inputgröße muss man rechnen? Wenn ich z.B. weiß, dass es nur Strings kleiner als 200 Zeichen werden (Beispiel!), dann wird es kritisch soetwas wie eine Initialisierung am Anfang der komprimierten Daten zu haben (z.B. eine Wahrscheinlichkeitstabelle die mit dem zu komprimierenden String berechnet wurde. Die nimmt vorne schon ein bisschen Platz weg (selbst wenn es nur 2Bit/Eintrag sind) und bei "nur" 200 Zeichen lohnt sich das uust nicht. Bei 1000 aber z.B. schon).

M

**Mars**

Zitat von Lambdax
Code
if Not ($sA & $sB & $sC & $sD) Then
ginge auch. Lief bei mir am schnellsten

Der "&" Operator interpretiert beide Seiten automatisch als String und fügt diese zusammen. "True" ist aber nicht gleich True, und "1" ist nicht gleich 1 und "0" ist nicht gleich "".

Was du da machst sind im Prinzip 2 Sachen:
1. Füge a, b, c, d als String zusammen. "" & "" & "" & "" = ""
2. If Not ("") Then -> Das checkt in dem Fall ob irgendeiner der Strings nicht leer ist.

Wo das funktioniert: Wenn du ganz genau weißt welche Typen verwendet werden, und du tatsächlich "leere Strings" als "False" oder als "0" verwenden willst.
Wo das nicht funktioniert: Überall sonst. Angenommen $sA = 0, dann ist der Ausdruck: If Not ("0") Then. "0" ist aber kein "leerer String" und wird daher nicht als "False" interpretiert.

M

**Mars**

Sehr interessant. Bei mir läufts ohne Probleme. Habe es natürlich nicht Nachts um halb 12 getestet, aber Mittags um halb 12 gehts

**Mars**

Vor Jahren hieß es mal, dass Windows 10 ARM auf zahlreichen Geräten installierbar ist. Habe eben mal gegoogelt: Sieht nicht so aus als könnte man das "einfach so" installieren. Habe eigentlich erwartet, dass inzwischen geht, scheint aber nicht so zu sein

**Mars**

Andy : Danke, ich dachte schon bei mir spinnt etwas. Dachte eigentlich ich hätte 6 Kerne und nur einen Browser nebenbei offen (ohne Videoplayback) und <5% cpu Last während dem Test, da war ich irgendwie in der Annahme, dass das Skript einen eigenen Kern bekommt und dementsprechend immer gleichschnell abläuft... Hatte (mit Last auf der CPU) jetzt auch Durchläufe die mehr als 10x länger gebraucht haben (Da stand dann nicht mehr 5000ns, sondern 50000ns...)

Dann schätze ich, dass der Thread abgehandelt ist. Fazit: AutoIt verlangsamt ne nach Zustand des restlichen PCs willkürlich ausgewählte Funktionen um willkürliche Faktoren.

Oscar : Auch hier vielen Dank, die Version ist für meinen Anwendungsfall sogar noch besser, da die Daten bereits vorab in einer Struct liegen und damit der SetData Schritt entfällt

**Mars**

Ja, das sind die Ergebnisse, die ich bei mir auch erwartet hätte (Racer, Musashi, Bitnugger). Also, dass BitShift & BitAnd immer am schnellsten sind. Aus irgendwelchen Gründen ist BitShift + BitAnd bei mir (wenn man die Schleife auskommentiert) mit einer gewissen Wahrscheinlichkeit (klappt nicht immer, aber oft... 50% chance auf das "schlechte" Ergebnis) wesentlich langsamer als es sein sollte. Die Operationen werden mehrere zehntausendmal ausgeführt, beste/schlechteste Ergebnisse werden verworfen und das "gemittelte Drittel in der Mitte" ergibt das Timingergebnis. Stochastische Aussetzer sind damit mehr oder weniger ausgeschlossen.

Dann steht es jetzt 3:1 dafür, dass mein PC seltsam ist

**Mars**

Moin,

Im Zuge von Optimierungen (ja... aus irgendwelchen Gründen macht es mir Spaß AutoIt für Sachen zu verwenden für die es nicht geeignet ist) habe ich mal wieder ein paar Zeiten gestoppt.

Beim Timing kommen aber aus irgendwelchen Gründen sehr verschiedene Ergebnisse heraus (ich öffne kein Windows Fenster/Msgbox, es ist also nicht der Skriptverlangsamungsbug der damit zusammenhängt).

Code: Ergebnis 1

_01 10770ns  +85.2% ->| int32 bitand & bitshift
_02  9712ns  +67.1% ->| int32 bitand & bitshift (array als int)
_2A  9528ns  +63.9% ->| int32 bitand & bitshift (ternärer operator umgestellt, array als int)
_2B  9115ns  +56.8% ->| int32 bitshift & bitand (array als int)
_2C  9067ns  +56.0% ->| int32 bitshift & bitand (array als int)
_2D  9376ns  +61.3% ->| int32 bitshift & bitand (array als int)
_03  7917ns  +36.2% ->| int32 stringoperationen (array als int)
_04 10340ns  +77.9% ->| int32 stringoperation für Alpha, rest bitoperationen (array als int)
_05  5905ns   +1.6% ->| int32 struct (byte[4] access index, array als int)
_5A  6973ns  +19.9% ->| int32 struct (byte;byte;byte;byte access element, array als int)
_5B  5814ns   +0.0% ->| int32 struct (byte[4] access index via name, array als int)

Alles anzeigen

Code: Ergebnis 2

_01  6334ns  +33.9% ->| int32 bitand & bitshift
_02  5283ns  +11.7% ->| int32 bitand & bitshift (array als int)
_2A  5072ns   +7.2% ->| int32 bitand & bitshift (ternärer operator umgestellt, array als int)
_2B  4730ns   +0.0% ->| int32 bitshift & bitand (array als int)
_2C  4774ns   +0.9% ->| int32 bitshift & bitand (array als int)
_2D  4956ns   +4.8% ->| int32 bitshift & bitand (array als int)
_03  7871ns  +66.4% ->| int32 stringoperationen (array als int)
_04  5884ns  +24.4% ->| int32 stringoperation für Alpha, rest bitoperationen (array als int)
_05  5947ns  +25.7% ->| int32 struct (byte[4] access index, array als int)
_5A  6954ns  +47.0% ->| int32 struct (byte;byte;byte;byte access element, array als int)
_5B  5810ns  +22.8% ->| int32 struct (byte[4] access index via name, array als int)

Alles anzeigen

Diese beiden Ergebnisse tauchen beide bei mir reproduzierbar (mit einer gewissen Chance) auf.

Ergebnis 1: Wenn ich im Skript Zeile 82 und 84 auskommentiere taucht vermehrt Ergebnis 1 auf.
Ergebnis 2: Wenn ich im Skript Zeile 82 und 84 einkommentiere taucht vermehrt Ergebnis 2 auf.

(Obwohl diese Zeilen (also eine For-Schleife von 0 bis 0) ansich keinen Einfluss haben sollten)

Der Unterschied ist hier die Ausführungsgeschwindigkeit von BitOperationen, die brauchen plötzlich 2-3x so lange. Alle anderen Operationen laufen ähnlich schnell ab.

Entweder sehe ich meinen offensichtlichen Fehler nicht, oder da ist irgendwas im Gange was ich nicht verstehe...

Deshalb möchte ich in die Runde fragen ob dasselbe Verhalten noch bei anderen Leuten auftritt.

PS: Ich verwende AutoIt Version 3.3.14.5, habe noch keine anderen Versionen getestet.

AutoIt: Skript

#include-once
#include <Array.au3>

Global $BENCH[0][4]

Func Add($xFunc, $sDescription = '')
    Local $u = UBound($BENCH)
    ReDim $BENCH[$u+1][UBound($BENCH, 2)]
    $BENCH[$u][0] = $xFunc
    $BENCH[$u][1] = 0.0
    $BENCH[$u][2] = 0 ; Akkumulierte Millisekunden
    $BENCH[$u][3] = $sDescription
EndFunc

Func Timing($n = 150)
    Local $a = $BENCH
    If $n = 0 Then Return $a
    Local $r
    For $i = 1 To $n Step 1
        $r = Random(0, UBound($a) - 1, 1)
        $a[$r][1] += Call($a[$r][0])
        $a[$r][2] += 1
    Next
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][1] /= $a[$i][2]
    Next
    Return $a
EndFunc

Func Bench($n = 10)
    Local $t = Timing(0), $a[$n][UBound($t)]
    For $i = 0 To $n - 1 Step 1
        $t = Timing()
        For $ii = 0 To UBound($t) - 1 Step 1
            $a[$i][$ii] = $t[$ii][1]
        Next
    Next
    Local $aCenter[UBound($t)][UBound($t, 2)], $throwAway = Int(UBound($a)/3)
    For $i = 0 To UBound($t) - 1 Step 1
        _ArraySort($a, 1, 0, 0, $i)
        For $ii = $throwAway To UBound($a) - $throwAway - 1 Step 1
            $aCenter[$i][1] += $a[$ii][$i] / (UBound($a) - 2 * $throwAway)
        Next
    Next
    Local $m = $aCenter[0][1]
    For $i = 1 To UBound($aCenter) - 1 Step 1
        If $m > $aCenter[$i][1] Then $m = $aCenter[$i][1]
    Next
    ConsoleWrite('Benchmark Result' & @CRLF)
    For $i = 0 To UBound($aCenter) - 1 Step 1
        $aCenter[$i][0] = FuncName($t[$i][0])
        $aCenter[$i][2] = '+' & StringFormat('%.1f', 100 * ($aCenter[$i][1] / $m - 1)) & '%'
        $aCenter[$i][1] = StringRight('     ' & StringFormat('%.0f', 1000000.0 * $aCenter[$i][1]), 5) & 'ns'
        $aCenter[$i][3] = $t[$i][3]
        ConsoleWrite($aCenter[$i][0] & ' ' & $aCenter[$i][1] & ' ' & StringRight('       ' & $aCenter[$i][2], 7) & ' ->| ' & $aCenter[$i][3] & @CRLF)
    Next
    Return $aCenter
EndFunc




;~ #include "Benchmark.au3"

; Ziel: Zerlege eine Farbe gegeben als int32 (oder uint32, in AutoIt als int64) in ARGB in ein Array[4] als array[i][.] = [A, R, G, B].
; Alle Werte von A, R, G, B sind positive Integer im Bereich [0, 255].

; Bitoperationen in AutoIt sind 32Bit only, es wird also schwer da aus uint32 einen Vorteil zu ziehen (das minus entfällt bei uint)

Add(_01, 'int32 bitand & bitshift')
Add(_02, 'int32 bitand & bitshift (array als int)')
Add(_2A, 'int32 bitand & bitshift (ternärer operator umgestellt, array als int)')
Add(_2B, 'int32 bitshift & bitand (array als int)')
Add(_2C, 'int32 bitshift & bitand (array als int)')
Add(_2D, 'int32 bitshift & bitand (array als int)')
Add(_03, 'int32 stringoperationen (array als int)')
Add(_04, 'int32 stringoperation für Alpha, rest bitoperationen (array als int)')
Add(_05, 'int32 struct (byte[4] access index, array als int)')
Add(_5A, 'int32 struct (byte;byte;byte;byte access element, array als int)')
Add(_5B, 'int32 struct (byte[4] access index via name, array als int)')

;~ For $_ = 0 To 0 Step 1
    Bench(10)
;~ Next

Func _01()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
    Next
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][0] = BitShift(BitAND($c[$i], 0xFF000000), 24) + ($c[$i] < 0 ? 256 : 0)
        $a[$i][1] = BitShift(BitAND($c[$i], 0xFF0000), 16)
        $a[$i][2] = BitShift(BitAND($c[$i], 0xFF00), 8)
        $a[$i][3] = BitAND($c[$i], 0xFF)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _02()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][0] = BitShift(BitAND($c[$i], 0xFF000000), 24) + ($c[$i] < 0 ? 256 : 0)
        $a[$i][1] = BitShift(BitAND($c[$i], 0xFF0000), 16)
        $a[$i][2] = BitShift(BitAND($c[$i], 0xFF00), 8)
        $a[$i][3] = BitAND($c[$i], 0xFF)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _2A()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][0] = $c[$i] > 0 ? BitShift(BitAND($c[$i], 0xFF000000), 24) : BitShift(BitAND($c[$i], 0xFF000000), 24) + 256
        $a[$i][1] = BitShift(BitAND($c[$i], 0xFF0000), 16)
        $a[$i][2] = BitShift(BitAND($c[$i], 0xFF00), 8)
        $a[$i][3] = BitAND($c[$i], 0xFF)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _2B()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next ; Bitand bei Alpha nötig für das Minus
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][0] = BitAND(BitShift($c[$i], 24), 0xFF)
        $a[$i][1] = BitAND(BitShift($c[$i], 16), 0xFF)
        $a[$i][2] = BitAND(BitShift($c[$i], 8), 0xFF)
        $a[$i][3] = BitAND($c[$i], 0xFF)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _2C()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][0] = $c[$i] > 0 ? BitShift($c[$i], 24) : BitShift($c[$i], 24) + 256
        $a[$i][1] = BitAND(BitShift($c[$i], 16), 0xFF)
        $a[$i][2] = BitAND(BitShift($c[$i], 8), 0xFF)
        $a[$i][3] = BitAND($c[$i], 0xFF)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _2D()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][0] = BitShift($c[$i], 24) + ($c[$i] < 0) * 256
        $a[$i][1] = BitAND(BitShift($c[$i], 16), 0xFF)
        $a[$i][2] = BitAND(BitShift($c[$i], 8), 0xFF)
        $a[$i][3] = BitAND($c[$i], 0xFF)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _03()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    Local $o = ''
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $o = Hex($c[$i], 8)
        $a[$i][0] = Int('0x' & StringLeft($o, 2))
        $a[$i][1] = Int('0x' & StringMid($o, 3, 2))
        $a[$i][2] = Int('0x' & StringMid($o, 5, 2))
        $a[$i][3] = Int('0x' & StringRight($o, 2))
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _04()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $a[$i][0] = Int('0x' & StringLeft(Hex($c[$i], 8), 2))
        $a[$i][1] = BitShift(BitAND($c[$i], 0xFF0000), 16)
        $a[$i][2] = BitShift(BitAND($c[$i], 0xFF00), 8)
        $a[$i][3] = BitAND($c[$i], 0xFF)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _05()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    Local $p = DllStructCreate('int')
    Local $q = DllStructCreate('byte[4]', DllStructGetPtr($p)) ; BGRA Byte order
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        DllStructSetData($p, 1, $c[$i])
        $a[$i][0] = DllStructGetData($q, 1, 4)
        $a[$i][1] = DllStructGetData($q, 1, 3)
        $a[$i][2] = DllStructGetData($q, 1, 2)
        $a[$i][3] = DllStructGetData($q, 1, 1)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _5A()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    Local $p = DllStructCreate('int')
    Local $q = DllStructCreate('byte;byte;byte;byte', DllStructGetPtr($p)) ; BGRA Byte order
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        DllStructSetData($p, 1, $c[$i])
        $a[$i][0] = DllStructGetData($q, 4)
        $a[$i][1] = DllStructGetData($q, 3)
        $a[$i][2] = DllStructGetData($q, 2)
        $a[$i][3] = DllStructGetData($q, 1)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Func _5B()
    Local $c[99], $a[99][4], $t = 0.0, $u = 0.0
    For $i = 0 To UBound($c) - 1 Step 1
        $c[$i] = BitShift(Random(0, 0xFFFF, 1), -16) + Random(0, 0xFFFF, 1)
        $a[$i][0] = 0
        $a[$i][1] = 0
        $a[$i][2] = 0
        $a[$i][3] = 0
    Next
    Local $p = DllStructCreate('int a')
    Local $q = DllStructCreate('byte a[4]', DllStructGetPtr($p)) ; BGRA Byte order
    $t = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1
        $p.a = $c[$i]
        $a[$i][0] = $q.a(4)
        $a[$i][1] = $q.a(3)
        $a[$i][2] = $q.a(2)
        $a[$i][3] = $q.a(1)
    Next
    $t = TimerDiff($t)
    $u = TimerInit()
    For $i = 0 To UBound($a) - 1 Step 1

    Next
    $u = TimerDiff($u)
    Return ($t - $u)/99.0
EndFunc

Alles anzeigen

lg

M

**Mars**

Ja ich hab auch biontech bekommen. Wirklich anmelden musste ich mich auch nicht (also nicht besonders lange vorher). Habe einfach beim Hausarzt gesagt: Ich hab bock. Und 2 Tage später hatte ich den ersten Termin. Also vollkommen problemlos ohne alles.

Windows 11 ist auch witzig, weil mein PC angeblich die Anforderungen nicht unterstützt (dabei ist er wirklich gut). Deshalb lasse ich das jetzt auch erstmal ruhen^^

**Mars**

Habe das hier garnicht geschrieben, aber inzwischen (seit 1 Monat) bin ich 2x geimpft.

Ich hatte das mit mir selbst so ausgemacht, dass ich mich impfen lasse, sollten die Fallzahlen nach dem Juli (wo sie am Tiefpunkt waren) wieder sehr stark ansteigen. Weil ich davon ausgegangen bin, wenn ja so viele leute geimpft sind, vielleicht steigt die Fallzahl "nicht" wieder an. War aber nicht so. Und im Endeffekt war es mir zu blöd und ich habs einfach gemacht...^^

**Mars**

Guten Tag,

ich weiß, dass dieses Thema inzwischen fast eine Dekade alt ist, aber da ich durch Zufall beim Basteln wieder auf diese UDF gestoßen bin dachte ich: vielleicht gibt es ja eine neuere Version (neuer als 05.10.14), die ihren Weg in die Öffentlichkeit nur nicht gefunden hat. Insgesamt ist die UDF schon ziemlich nützlich, ein paar Sachen wurden aber noch nicht gewrappt die man ansich schon braucht (z.B. für Lines: StartCap, EndCap, LineJoin etc. Wenn man will, dass etwas "gut" aussieht kann man nicht immer mit flach abgeschnittenen Linien arbeiten). Ich bin recht zuversichtlich, dass ich die fehlenden Funktionen auch selbst wrappen kann (würde versuchen dem Stil von eukalyptus treu zu bleiben und das dann hier posten, falls mich die Arbeitswut überkommt... erwartet da lieber nicht zu viel^^), falls es dahingehend noch nichts gibt.

Edit: Habe mit meinem Beispiel genau ins Schwarze getroffen. LineJoin, und Caps sind in der UDF schon drin, habe sie nur übersehen, weil keine einzige StrokeStyle.Methode gewrappt wurde (wobei das auch alles nur "getter" sind)

lg

Mars

**Mars**

Der funktioniert nicht, weil $aFormations ein Array vom Typ [2][n] ist. Stattdessen möchtest du wahrscheinlich ein Array vom Typ [n] verwenden. Dafür muss aus dem $aFormations = [[ ... ], [ ... ]] ein [ ... ] werden. Also müsstest du die Arrays in Arrays nochmal kapseln.

AutoIt

Global $aFormations = [ _
        Array( _
            Array("GK", 1, 2, 3), _ ; 3-4-1-2
            Array("CB", 0, 2, 6), _
            Array("CB", 0, 1, 3, 4, 5), _
            Array("CB", 0, 2, 8), _
            Array("CM", 2, 5, 6, 7), _
            Array("CM", 2, 4, 7, 8), _
            Array("LM", 1, 4, 9), _
            Array("CAM", 4, 5, 9, 10), _
            Array("RM", 3, 5, 10), _
            Array("ST", 6, 7, 10), _
            Array("ST", 7, 8, 9) _
        ), _
        Array( _
            Array("GK", 1, 2, 3), _ ; 3-4-2-1
            Array("CB", 0, 2, 6), _
            Array("CB", 0, 1, 3, 4, 5), _
            Array("CB", 0, 2, 7), _
            Array("CM", 2, 5, 6, 8), _
            Array("CM", 2, 4, 7, 9), _
            Array("LM", 1, 4, 8), _
            Array("RM", 3, 5, 10), _
            Array("LF", 4, 6, 9), _
            Array("RF", 5, 7, 9), _
            Array("ST", 8, 9) _
        )]

Alles anzeigen

Damit ist $aFormations ein 1D Array welches je Element eine Formation enthält.
Eine Formation ist ein 1D Array welches Positionen enthält.
Eine Position ist ein 1D Array welches die Positionsdaten (Name + Kanten) enthält.

**Mars**

AutoIt hat leider keine Methode um ein Array aus Arrays zu definieren. Wenn man die [[1,2], [3]] Syntax verwendet wird automatisch ein 2x2 Array erstellt, wobei Array[1][1] leer ist. Was man eigentlich will ist ein Array der Länge 2, welches ein Array der Länge 2 und ein Array der Länge 1 enthält.

Der Trick über eine Funktion ist leider performancetechnisch ziemlich langsam, da hier zuerst ein viel zu großes Array erstellt wird, welches zu allem Überfluss auch noch bis zum Ende hin gefüllt wird. Zusammen mit dem Overhead durch Funktionsaufruf und ReDim ist das ziemlich lahm... Sowas sollte man also eigentlich nicht in Inner-Loops verwenden (sagte er, und verwendet es in 11 Fach verschachtelten For-Schleifen).

Der Zugriff auf ein Array im Array ist sehr performant, wenn man ByRef auf das Element zugreift. Arrays werden bei Zuweisung mittels Gleichzeichen (in AutoIt) kopiert, hier muss man also etwas vorsichtig sein und schauen auf welchen Daten man eigentlich gerade arbeitet (Original, oder Kopie).

AutoIt: Beispiel

Global $b = [1, 2, 3], $c = [4, 5, 6, 7, 8], $a = [$b, $c]

Print($a)

For $e in $a
    For $i = 0 To UBound($e) - 1 Step 1
        $e[$i] += 1 ; Das bewirkt nichts, $e ist eine Kopie -> langsam bei großen Arrays.
    Next
Next

Print($a)

For $i = 0 To UBound($a) - 1 Step 1
    For $ii = 0 To UBound($a[$i]) - 1 Step 1
;~         ($a[$i])[$ii] += 1 ; Syntax Error, selbst mit au3check disabled gibt es hier einen illegal text error. Wer weiß ob das ByRef oder ByVal wäre...
    Next
Next

For $i = 0 To UBound($a) - 1 Step 1
    Inc($a[$i]) ; ByRef zugriff. Hier wird wirklich gerechnet. Der inner Loop muss aber in der Funktion sein.
Next

Print($a)

Func Inc(ByRef $x) ; ByRef
    For $i = 0 To UBound($x) - 1 Step 1
        $x[$i] += 1
    Next
EndFunc

Func Print(ByRef $aa)
    For $i = 0 To UBound($aa) - 1 Step 1
        For $ii = 0 To UBound($aa[$i]) - 1 Step 1
            ConsoleWrite(($aa[$i])[$ii] & ' ') ; Zugriff auf SubArray durch Klammerung.
        Next
        ConsoleWrite(@CRLF)
    Next
EndFunc

Alles anzeigen

**Mars**

Man kann ganz billig "alle" Positionen ablaufen. Eine rekursive Version davon ist z.B:

AutoIt

;~ Global $aPerm[1*2*3*4*5*6*7*8*9*10], $iCounter = 0, $aSingle = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] ; Dauert ein paar Sekunden
Global $aPerm[1*2*3*4], $iCounter = 0, $aSingle = [1, 2, 3, 4]

HeapPermutation($aSingle, UBound($aSingle), UBound($aSingle))

ConsoleWrite('Permutation Counter: ' & $iCounter & @CRLF)

For $i = 0 To 999 Step 1
    If $i >= UBound($aPerm) Or Not IsArray($aPerm[$i]) Then Exit
    PrintArray($aPerm[$i])
Next

Func HeapPermutation(ByRef $a, $s, $n)
    If $s = 1 Then
        $aPerm[$iCounter] = $a
        $iCounter += 1
        Return
    EndIf
    For $i = 0 To $s - 1 Step 1
        HeapPermutation($a, $s - 1, $n)
        If IsInt($s/2) Then
            Swap($a[$i], $a[$s - 1])
        Else
            Swap($a[0], $a[$s - 1])
        EndIf
    Next
EndFunc

Func Swap(ByRef $a, ByRef $b)
    Local $c = $a
    $a = $b
    $b = $c
EndFunc

Func PrintArray(ByRef $a)
    For $ii = 0 To UBound($a) - 1 Step 1
        ConsoleWrite($a[$ii] & ' ')
    Next
    ConsoleWrite(@CRLF)
EndFunc

Alles anzeigen

Hier werden jetzt "alle" Kombinationen durchlaufen. Da der Torwart IMMER Position 0 hat (und auch sonst nirgends spielt) lassen wir den aus der Permutation heraus, sodass es nur noch 10! tatsächlich relevante Kombinationen gibt. Davon sind aber die allermeisten ungültig (da nicht jeder Spieler überall spielen kann).

Weil ich neugierig war ob der "ich nehme einfach unmengen For-Loops und lehne mich zurück" Ansatz klappt habe ich es kurz implementiert... Entweder ist da was falsch, oder es gibt wesentlich weniger gültige Permutationen als ich gedacht habe... Bei so viel Zahlensalat habe ich mich bestimmt irgendwo vertippt

AutoIt

#include <Array.au3>

Global $aPerm[3628800], $iCounter = 0

Global $aSpielerPositionen = [ _
        Array(0, 9), _ ; Torwart immer bei 0, aber ab und zu will er die Sau rauslassen an Position 9
        Array(1, 2, 3), _
        Array(2, 4, 6), _
        Array(4, 5, 8), _
        Array(1, 5, 10), _
        Array(3, 7, 8), _
        Array(5, 6, 0), _ ; Ersatztorwart. Spielt am liebsten an Pos 5 und 6, aber zur Not auch ins Tor...
        Array(4, 5, 6, 7, 8), _
        Array(8, 9, 10), _
        Array(8, 9, 10), _
        Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)] ; Der letze Spieler ist Jesus, der kann überall spielen.

Magic()

ConsoleWrite('Permutationen: ' & $iCounter & @CRLF)
For $i = 0 To $iCounter - 1 Step 1
    PrintArray($aPerm[$i])
Next

; Jetzt kommt die BESTE Methode das zu lösen
Func Magic()
    Local $a
    Local $0_ = 0, $1_ = 0, $2_ = 0, $3_ = 0, $4_ = 0, $5_ = 0, $6_ = 0, $7_ = 0, $8_ = 0, $9_ = 0, $10_ = 0
    For $0 = 0 To UBound($aSpielerPositionen[0]) - 1 Step 1
        $0_ = ($aSpielerPositionen[0])[$0]

        For $1 = 0 To UBound($aSpielerPositionen[1]) - 1 Step 1
            $1_ = ($aSpielerPositionen[1])[$1]
            If $1_ = $0_ Then ContinueLoop

            For $2 = 0 To UBound($aSpielerPositionen[2]) - 1 Step 1
                $2_ = ($aSpielerPositionen[2])[$2]
                If $2_ = $1_ Or $2_ = $0_ Then ContinueLoop

                For $3 = 0 To UBound($aSpielerPositionen[3]) - 1 Step 1
                    $3_ = ($aSpielerPositionen[3])[$3]
                    If $3_ = $2_ Or $3_ = $1_ Or $3_ = $0_ Then ContinueLoop

                    For $4 = 0 To UBound($aSpielerPositionen[4]) - 1 Step 1
                        $4_ = ($aSpielerPositionen[4])[$4]
                        If $4_ = $3_ Or $4_ = $2_ Or $4_ = $1_ Or $4_ = $0_ Then ContinueLoop

                        For $5 = 0 To UBound($aSpielerPositionen[5]) - 1 Step 1
                            $5_ = ($aSpielerPositionen[5])[$5]
                            If $5_ = $4_ Or $5_ = $3_ Or $5_ = $2_ Or $5_ = $1_ Or $5_ = $0_ Then ContinueLoop

                            For $6 = 0 To UBound($aSpielerPositionen[6]) - 1 Step 1
                                $6_ = ($aSpielerPositionen[6])[$6]
                                If $6_ = $5_ Or $6_ = $4_ Or $6_ = $3_ Or $6_ = $2_ Or $6_ = $1_ Or $6_ = $0_ Then ContinueLoop

                                For $7 = 0 To UBound($aSpielerPositionen[7]) - 1 Step 1
                                    $7_ = ($aSpielerPositionen[7])[$7]
                                    If $7_ = $6_ Or $7_ = $5_ Or $7_ = $4_ Or $7_ = $3_ Or $7_ = $2_ Or $7_ = $1_ Or $7_ = $0_ Then ContinueLoop

                                    For $8 = 0 To UBound($aSpielerPositionen[8]) - 1 Step 1
                                        $8_ = ($aSpielerPositionen[8])[$8]
                                        If $8_ = $7_ Or $8_ = $6_ Or $8_ = $5_ Or $8_ = $4_ Or $8_ = $3_ Or $8_ = $2_ Or $8_ = $1_ Or $8_ = $0_ Then ContinueLoop

                                        For $9 = 0 To UBound($aSpielerPositionen[9]) - 1 Step 1
                                            $9_ = ($aSpielerPositionen[9])[$9]
                                            If $9_ = $8_ Or $9_ = $7_ Or $9_ = $6_ Or $9_ = $5_ Or $9_ = $4_ Or $9_ = $3_ Or $9_ = $2_ Or $9_ = $1_ Or $9_ = $0_ Then ContinueLoop

                                            For $10 = 0 To UBound($aSpielerPositionen[10]) - 1 Step 1
                                                $10_ = ($aSpielerPositionen[10])[$10]
                                                If $10_ = $9_ Or $10_ = $8_ Or $10_ = $7_ Or $10_ = $6_ Or $10_ = $5_ Or $10_ = $4_ Or $10_ = $3_ Or $10_ = $2_ Or $10_ = $1_ Or $10_ = $0_ Then ContinueLoop

                                                $aPerm[$iCounter] = Array($0_, $1_, $2_, $3_, $4_, $5_, $6_, $7_, $8_, $9_, $10_)
                                                $iCounter += 1

                                            Next
                                        Next
                                    Next
                                Next
                            Next
                        Next
                    Next
                Next
            Next
        Next
    Next
    ReDim $aPerm[$iCounter]
EndFunc   ;==>Magic

Func PrintArray(ByRef $a)
    For $ii = 0 To UBound($a) - 1 Step 1
        ConsoleWrite($a[$ii] & ' ')
    Next
    ConsoleWrite(@CRLF)
EndFunc   ;==>PrintArray

Func Array($a = 0, $b = 0, $c = 0, $d = 0, $e = 0, $f = 0, $g = 0, $h = 0, $i = 0, $j = 0, $k = 0)
    Local $1 = [$a, $b, $c, $d, $e, $f, $g, $h, $i, $j, $k]
    ReDim $1[@NumParams]
    Return $1
EndFunc   ;==>Array

Alles anzeigen

**Mars**

Das was du aufgeschrieben hast ist im Prinzip eine kondensierte Version der Matrix mit einer festen Breite von 5 + Zusatzinformationen. Ich habe einfach aus Gewohnheit eine volle Matrix vorgeschlagen, das ist hier wahrscheinlich nicht unbedingt besser...

Wenn du schon mit Knoten und Kanten loslegen willst: Nachbarschaftsbasierte Suchalgorithmen in ungerichteten Graphen (das ist dein Stichwort )

Dazu gibt es wunderbare Literatur (PS: ich hatte in dem Fach nur eine 3.... ). Ein "Knoten" ist hier eine "Zulässige Lösung", also z.B. eine Liste mit 11 Spielern. Ein "Nachbar" ist eine Zulässige Lösung bei der eine kleine Variation vorgenommen wurde (z.B. 2 Spieler vertauscht). Ein Suchalgorithmus schaut sich jetzt die "Kosten" (das ist die Evaluationsfunktion/Zielfunktion um zu bewerten wie "gut" dein Team ist) im Graphen für den eigenen Knoten (irgendein Startknoten, z.B. eine zufällig zusammengewürfelte, aber zulässige Liste von 11 Spielern), sowie die benachbarten Knoten an und geht dann einen Schritt in eine "vielversprechende" Richtung (z.B. immer zum "besten" Nachbarn, oder zufallsbasiert mit 50% chance zum "besten", mit 25% zum 2t "besten", mit 12,5% zum 3t... usw.).

Easy

**Mars**

Das Sieht für mich nach einem klassischen Optimierungsproblem aus.

Habe (für genau dieses Problem) jetzt nichts programmiert, ich kann aber kurz beschreiben wie man es macht.

Benötigte Variable:

$InternerZustand[11][...] = Aktuelle Konstellation deiner Spieler (z.B. in einem [11][...] Array)

$BesterInternerZustand[2] = [0] -> Zwischenspeichern des bisher besten berechneten internen Zustands, [1] -> Wert der Zielfunktion für diesen Zustand.

$LetzteAenderung[2][2] (für 2 Spieler hier Beispielhaft)

[0][0] Position(Index) von SpielerX in InternerZustand VOR der Variation

[0][1] Position(Index) von SpielerX in InternerZustand NACH der Variation

[1][0] Position(Index) von SpielerY in InternerZustand VOR der Variation

[1][1] Position(Index) von SpielerY in InternerZustand NACH der Variation

Benötigte Funktionen:

Funktion zur Evaluation des (kompletten) internen Zustands zu einem einzigen int oder float Wert, der sich vergleichen lässt. Eine Konstellation mit dem Wert 5.6123 ist schlechter als eine Konstellation mit dem Wert 7.6543. Die Zielfunktion zu finden ist bei vielen Optimierungsproblemen der härteste Teil, ich glaube das geht hier aber recht einfach. Als Hilfmittel (zur Kantenbeschreibung) ist hier eine 11x11 Matrix geeignet an deren Stelle überall eine 1 steht wo eine Kante existiert und eine 0, wenn keine Kante vorhanden ist. (z.B. es gibt eine Kante zwischen [0] und [4], dann ist in der Matrix bei [0][4] eine 1).

Funktion zur Variation des internen Zustands. z.B. 2er Vertauschung (Nimm 2 zufällige Spieler, tausche ihren Platz), oder 3er Vertauschung (Nimm 3 zufällige Spieler, verteile sie Zufällig)

Jetzt machst du folgendes:

Starte mit "irgendeiner" gültigen Konstellation (Fachjargon: Gültige Lösung), am besten verteilt man die Spieler Zufällig, sodass bei jedem Funktionaufruf ein anderer Startwert vorliegt.

Berechne die Zielfunktion (Evaluation, hier kommt z.B. 3.123 heraus)

Speichere diese Konstellation + Wert der Zuelfunktion in BesterInternerZustand.

Loop

Variiere (z.B. 2er oder 3er Vertauschung) den Internen Zustand EIN Mal.

Denke daran die Änderung zu speichern, also wo waren die beiden Spieler vorher, wo sind sie jetzt?

Berechne die Zielfunktion

Schaue ob der Wert der Zielfunktion besser ist als der "beste" Wert

Wenn ja -> Speichere Aktuellen InternenZustand und Wert der Zielfunktion in BesterInternerZustand

Wenn nö -> Mache die Änderung rückgängig

Abbruchkriterium

EndLoop

Als Abbruchkriterium kann man z.B. einen Zähler einbauen: Wenn sich nach z.B. 500 Schritten nichts mehr verbessert hat ist man fertig.

Das Entspricht jetzt einer Nachbarschaftssuche "ohne Tricks".

Warum ist ggf eine 3er Kombination auch sinnvoll?

Das ist jetzt nur ein Erfahrungswert: Manchmal fressen sich "zu kleine" Variationen fest und eine tatsächliche Verbesserung kann nicht mehr erzielt werden, wenn nur "ein wenig" variiert wird. Dafür gibt es verschiedene Lösungsansätze:

- Größere Variation zulassen (das wäre jetzt z.B. die 3er Vertauschung)

- Mehrere Variationen in Folge anwenden (z.B. 2, 3, viele Vertauschungen und erst danach auf die Zielfunktion schauen)

- Kleine Verschlechterungen zulassen (wird die Zielfunktion nur "etwas" schlechter? Dann kann man ggf trotzdem auf diesem Weg laufen)

- etc.

Ich würde das wie oben beschrieben programmieren und dann z.B. 500 Instanzen Laufen lassen. (also die Optimierung als Ganzes 500x mit zufälligen Startwerten durchführen) und das beste Ergebnis davon verwenden.

Da 11 Fakultät "nur" 40Mio sind kann man das auch mit BruteForce lösen. Das wird in AutoIt vielleicht ziemlich langsam, wenn du aber noch andere Sprachen draufhast (z.B. Java (argh), C, C++, etc) müsste das eine Sache von Sekunden sein bis man das gebruteforced hat.

Edit: Das ist ne super (teil) Hausaufgabe für neue Info-Studenten. Das merk ich mir... hehehe

lg

Mars

**Mars**

Sehr interessanter "erster" Beitrag in einem Programmierer Hilfe & Support Forum.

Back to Topic:
Irgendwann im laufe des letzten Jahres kam Genshin Impact heraus. Das sah nicht nur gut aus, sondern spielte sich auch gut. Es ist allerdings "kein" Onlinespiel, es gibt einen Multiplayer, der ist aber eher rudimentär und nicht auf Masse (hunderte andere Spieler), sondern auf eine sehr kleine Auswahl (Spieler betreten deine Welt auf Anfrage, man ist also üblicherweise zu 2t unterwegs) ausgelegt.

**Mars**

Wenn die Namensgebung nur so einfach wäre wie bei wissenschaftlichen Abschlussarbeiten: "Exponentiallogarithmische Schreibweise zur Erfassung von Zahlen außerhalb des Double Wertebereichs". Mit dem Namen liest zwar keiner deine Bachelorarbeit, aber der Prof ist glücklich

**Mars**

Wer kennt sie nicht
Strg+Copieren

Strg+Xusschneiden
Strg+Vinfügen
Strg+Zückgängig (ist ein typisch Deutsches Wort... Rückgängig... 1R 1ü 1c 1k 3g 1ä 1n 1i. Konsonantenschlacht mit Sonderzeichen)
Strg+Yiederherstellen

**Mars**

Moin,

Anbei ist eine UDF die intern mit folgender Schreibweise Arbeitet: 1e10.994604967679 statt 9.8765432e10. Die "Zahl" wird als als Logarithmus zur Basis 10 gespeichert. Die eigentliche Zahl ergibt sich damit zu Sign * 10 ^ Double. Mit dieser Schreibweise lassen sich relativ große (1e99999 z.B.) und auch sehr kleine Zahlen gut darstellen. Für exakte Ergebnisse ist diese Methode natürlich ungeeignet, da ist es besser mit BigInt oder BigNum zu rechnen, aber wenn die Genauigkeit "nur so pi mal 7 Nachkommastellen" stimmen muss, dann findet man hier vielleicht was man sucht.

Ich habe die UDF vorerst "ENumber" getauft (wollte eigentlich BigNum, aber das gibt es ja schon ), oder LogNum (aber das klang irgendwie doof). Also ist es jetzt ENum (E = exponential), damit ist der Name wenigstens "fast" richtig.

In der UDF sind einige Rechenmethoden (+ - * / ^ etc) enthalten. Fortschreitendes wie Fakultät, Binomialkoeffizient, uvm. habe ich aber noch nicht angefasst, da mir das auch zu viel Arbeit ist "alle" Anwendungsfälle ausgiebig zu testen. Ich habe versucht möglichst alle exeptions (und sowas wie "positive 0 und negative 0") 1 zu 1 nachzubilden um den in AutoIt üblichen Rechenregeln zu entsprechen. Ein paar Funktionen arbeiten dennoch anders, z.B. rational power(x, y) = x^y. AutoIt schummelt hier und nimmt y einfach als Integer, wenn es "nah genug" an einem Integer liegt, damit kann man auch negative Zahlen potenzieren, was diese UDF aber nicht kann.

Wenn jemand Funktionen beisteuern, testen, die UDF nutzen, (z.B. um ein Incremental-Idle-Game zu basteln wo es wahnsinnig riesige Zahlen gibt), Änderungen vornehmen, etc. will. Immer her damit, ich bin für jede Kritik und jeden Verbesserungsvorschlag offen.

lg

M

**Mars**

Die Sprache ist derzeit kräftig am degenerieren. Da ich hauptsächlich mit Leuten aus der Uni zu tun habe ist das für mich kaum bemerkbar, aber sobald man dieses Millieu verlässt fragt man sich was hier überhaupt gerade passiert. Das Gendern ist bei uns (TU-Darmstadt) zum Glück noch nicht allgegenwärtig, in offiziellen Schreiben von "Oben" aber bereits vorhanden. Was ich bei dem ganzen Kram nicht verstehe ist: Frauen fühlen sich angeblich von der neutralen Ansprache "Student", "Arbeiter", "Ingenieur" etc. nicht angesprochen, Männer sollen sich aber von "Student*in" oder von "StudentIn" angesprochen fühlen? Damit verschiebt man das "Problem" doch nur auf die andere Seite, anstatt es zu lösen?

Mal abgesehen davon, dass kaum jemand noch (anständiges) Deutsch spricht^^ Wenn man im Zug sitzt und hört was da gesprochen wird versteht man kein Wort.

Beiträge von Mars

[Wettbewerb] String komprimieren

Mehrfachbedingung vernünftig gestalten

AutoIt-Spritpreis

Tablet von Samsung

Irgendwas stimmt mit der Ausführungsgeschwindigkeit nicht...

Irgendwas stimmt mit der Ausführungsgeschwindigkeit nicht...

Irgendwas stimmt mit der Ausführungsgeschwindigkeit nicht...

Corona - endlich impfen

Corona - endlich impfen

Direct2D UDF

Beschreibung von Punkten und ihren Kanten zu anderen Punkten

Beschreibung von Punkten und ihren Kanten zu anderen Punkten

Beschreibung von Punkten und ihren Kanten zu anderen Punkten

Beschreibung von Punkten und ihren Kanten zu anderen Punkten

Beschreibung von Punkten und ihren Kanten zu anderen Punkten

Spielt ihr Online Spiele?

Logarithmusschreibweise für extrem große Zahlen

Umfrage: Welchen Shortcut bevorzugst du für "Redo"?

Logarithmusschreibweise für extrem große Zahlen

Interessanter Artikel von Wolfgang Thierse