Beiträge von Yjuq

Versuch's mal mit _IEGetObjById().

Danke, ehrlich gesagt war dies ein Teilproblem was ich bei Aufgabe 12 hatte.
Hab da schon einige dort gelöst

Ach Sorry, ich habe ja ganz vergessen zu erklären wie ich darauf gekommen bin.
Also, als ich Bernd sein Lösungsvorschlag gesehen habe, habe ich bemerkt dass man das Problem auch grafisch darstellen kann. Daraufhin habe ich es einfach mal mit einen simplen Baumdiagramm versucht. Nehmen wir also mal die Zahl 360 = 2^3 * 3^2 * 5^1 als Beispiel. Entsprechend würde so das Baumdiagramm aussehen:

N
       +---------|---------+
      /          |          \
   [2^1]       [2^2]       [2^3]
   /   \       /   \       /   \
[3^1] [3^2] [3^1] [3^2] [3^1] [3^2]
  |     |     |     |     |     |
[5^1] [5^1] [5^1] [5^1] [5^1] [5^1]

Nun kann man die Produktregel anwenden um die Anzahl der möglichen Kombinationen zu ermitteln. In diesem Fall wäre dass 3*2*1 = 6 Kombinationen. Allerdings muss man auch die Kombinationen beachten die sich nur aus zwei oder einem Element zusammensetzen. Nimmt man als Exponenten die Zahl 0 hinzu, so kann man bestimmte Primfaktoren einfach ausblenden. z.B. bei A * B^0 * C = A * B. Deshalb werden die Exponenten in den Rechnungen nochmals um eins erhöht. Daraus folgt für unser Beispiel: (3 +1) * (2 +1) * (1 +1) = 24 Möglichkeiten.

Stimmt, jetzt wo du es sagst. Dann ließe sich das aber auch komplett anders berechnen.
Nehmen wir an N steht für eine natürliche Zahl, p für ein Primfaktor und e für den Exponenten.

N = p_1 ^ e_1 * p_2 ^ e_2 * p_3 ^ 3_3 * ...

Demnach sind also die Anzahl der Teiler folgende:
T(N) = (e_1 +1) * (e_2 +1) * (e_3 +1) * ...

Also kann man den Code noch minimieren:

Func _GetComb(ByRef $aiFact)
Local $iSize = UBound($aiFact)
Local $iFact = 1
Local $iC

For $iC = 0 To UBound($aiFact) -1
$iFact *= $aiFact[$iC] +1
Next

Return $iFact
EndFunc

Ja, die Funktion ist tatsächlich schneller.
Aber was ist der Hintergrundgedanke von Zeile 13?
Irgendwie kann ich das nicht nachvollziehen.

Servus, ich konnte das Problem jetzt lösen.
Wenn man sich alle Faktoren als eine Menge vorstellt, so beinhaltet der Faktor 2^5 eine Menge von A = {2^1; 2^2; 2^3; 2^4; 2^5}. Ich habe mir diese Vorstellung zu Nutze gemacht indem ich einfach alle möglichen Kombinationen für die Mengen (die Anzahl der Primfaktoren) durchgegangen bin. Danach musste ich nur noch die Anzahl der darin beinhalteten Elemente in der Menge miteinander multiplizieren. So erhielt ich die Möglichen Kombinationen die mit den Elementen in den Mengen zu bilden wahren. Irgendwie so ähnlich wie das kartesische Produkt.

Hier das Ergebnis:

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

#include <Array.au3>

Global $aiNumFact = _GetNumbPrimeFact(2162160)
ConsoleWrite(_GetComb($aiNumFact) & @CRLF)

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Func _GetNumbPrimeFact($iNumb)
Local $aiFact[Int(Sqrt($iNumb))]
Local $iDiv = 3
Local $iCount, $fSqrt

If Not Mod($iNumb, 2) Then
While Not Mod($iNumb, 2)
$aiFact[0] += 1
$iNumb /= 2
WEnd
$iCount = 1
EndIf

$fSqrt = Sqrt($iNumb)
While $iNumb <> 1 And $iDiv <= $fSqrt
If Not Mod($iNumb, $iDiv) Then
$aiFact[$iCount] = 1
$iNumb /= $iDiv
While Not Mod($iNumb, $iDiv)
$aiFact[$iCount] += 1
$iNumb /= $iDiv
WEnd
$fSqrt = Sqrt($iNumb)
$iCount += 1
EndIf
$iDiv += 2
WEnd

If $iNumb <> 1 Then
$aiFact[$iCount] = 1
$iCount += 1
EndIf

ReDim $aiFact[$iCount]
Return $aiFact
EndFunc

Func _GetComb(ByRef $aiFact)
Local $iSize = UBound($aiFact)
Local $iC, $asComb, $iN, $aiSplit, $iFact, $iR, $iSum

For $iC = 1 To $iSize
$asComb = _ArrayCombinations($aiFact, $iC, '|')

For $iN = 1 To $asComb[0]
$aiSplit = StringSplit($asComb[$iN], '|')
$iFact = 1

For $iR = 1 To $aiSplit[0]
$iFact *= $aiSplit[$iR]
Next

$iSum += $iFact
Next
Next

Return $iSum +1
EndFunc

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Ach Danke, die 3 Kombinationen habe ich tatsächlich vergessen. Also sind es demnach 24 Teiler die die Zahl 360 hat.

@Peter:
Leider weiß ich nicht was ich mit den Links anfangen soll. z.B. erklärt mathepower.com dass ein mögliches Verfahren ist, alle Zahlen auszuprobieren und zu prüfen ob diese restlos teilbar ist. Ich selber habe ja bereits ein effektiveres Verfahren gefunden, jedoch scheitert es noch an der Umsetzung da ich versuche jede erdenkliche Kombination aus den Primfaktoren zu bestimmen. Sind es 3 verschiedene Primfaktoren können jeweils die 3 Faktoren alleine stehen, in 2er Grüppchen oder in einer 3er Gruppe multipliziert werden. Das sind also schon 7 mögliche Kombinationen die daraus gebildet werden können.

A*B*C Als Primfaktoren → A, B, C, A*B, A*C, B*C, A*B*C (7 Teiler)

Nun ist aber noch die Schwierigkeit da, dass diese noch zusätzlich Exponenten besitzen, das Bedeutet dass sich die Anzahl der möglichen Kombinationen erhöht. Jedoch weiß ich nicht wie man dies nun am besten berechnet.

@edit:
Bevor ich es vergessen bernd. Dein Beispielskript oben funktioniert auch nicht richtig. Ich habe mal die Zahl 2162160 getestet, sind 320 Teiler, die Funktion gibt aber nur 70 aus. Dieses Skript habe ich dazu verwendet:

$iNumb = 2162160
$iCount = 0

For $i = 1 To $iNumb
If Not Mod($iNumb, $i) Then $iCount += 1
Next

ConsoleWrite($iCount & @CRLF)

Aber so würde ich das halt ungern lösen da es Zeitfressend ist.

Hallo ihr Lieben, ich habe ein etwas mathematisches Problem für euch. Ich versuche die Anzahl aller möglichen Teiler für eine natürliche Zahl zu finden. Dazu zerlege ich eine beliebige Zahl in ihre Primfaktoren, daraus kann man die Teiler bilden. Z.B. für die Zahl 360 sind die Primfaktoren 2^3 * 3^2 * 5. Die Teiler kann man nun durch geschicktes kombinieren der Primfaktoren ermitteln. Hier eine Liste aller Teiler für die Zahl 360:

2^1 = 2
2^2 = 4
2^3 = 8
3^1 = 3
3^2 = 9
5^1 = 5


2^1 * 3^1 = 6
2^2 * 3^1 = 12
2^3 * 3^1 = 24
2^1 * 5^1 = 10
2^2 * 5^1 = 20
2^3 * 5^1 = 40
3^1 * 5^1 = 15
3^2 * 5^1 = 45


2^1 * 3^1 * 5^1 = 30
2^2 * 3^1 * 5^1 = 60
2^3 * 3^1 * 5^1 = 120
2^1 * 3^2 * 5^1 = 90
2^2 * 3^2 * 5^1 = 180
2^3 * 3^2 * 5^1 = 360

Zusätzlich muss noch die 1 als Teiler beachtet werden, insgesamt existieren also 21 mögliche Teiler für die Zahl 360. Die Frage ist jedoch nun, wie man das am besten ausrechnet? Man benötigt im Grunde ja nur die Anzahl der Primfaktoren (3) und die Anzahl der Exponenten jedes Primfaktor (3, 2 und 1). Folgenden Ansatz habe ich bisher, jedoch ist die Funktion _GetComb() falsch da ich nicht richtig rechne. Diese Funktion soll mir letztendlich nur die Anzahl der Teiler zurückgeben, welche das sind ist letztendlich für meine Zwecke egal. Hier der Sourcecode:

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

#include <Array.au3>

Global $aiNumFact = _GetNumbPrimeFact(360)
_ArrayDisplay($aiNumFact) ; Anzahl der Exponenten ist korrekt! 3, 2 und 1...

; Hier müsste eigentlich 21 heraus kommen...
ConsoleWrite(_GetComb($aiNumFact) & @CRLF)

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Func _GetNumbPrimeFact($iNumb) ; Exponenten der Primfaktoren bestimmen
Local $aiFact[Int(Sqrt($iNumb))]
Local $iDiv = 3
Local $iCount, $fSqrt

If Not Mod($iNumb, 2) Then
While Not Mod($iNumb, 2)
$aiFact[0] += 1
$iNumb /= 2
WEnd
$iCount = 1
EndIf

$fSqrt = Sqrt($iNumb)
While $iNumb <> 1 And $iDiv <= $fSqrt
If Not Mod($iNumb, $iDiv) Then
$aiFact[$iCount] = 1
$iNumb /= $iDiv
While Not Mod($iNumb, $iDiv)
$aiFact[$iCount] += 1
$iNumb /= $iDiv
WEnd
$fSqrt = Sqrt($iNumb)
$iCount += 1
EndIf
$iDiv += 2
WEnd

If $iNumb <> 1 Then
$aiFact[$iCount] = 1
$iCount += 1
EndIf

ReDim $aiFact[$iCount]
Return $aiFact
EndFunc

; Diese Funktion macht mir Probleme und Kopfschmerzen...
Func _GetComb(ByRef $aiFact) ; Anzahl der möglichen Teiler
Local $iSize = UBound($aiFact)
Local $iFac = $aiFact[0]
Local $iAdd = $aiFact[0]
Local $iC, $iSum, $iAdd

For $iC = 2 To $iSize
$iSum += _C($iSize, $iC)
$iFac *= $aiFact[$iC -1]
$iAdd += $aiFact[$iC -1]
Next

Return $iSum * $iFac + $iAdd +1
EndFunc

Func _C($n, $k) ; Kombination
Return _P($n) / (_P($n - $k) * _P($k))
EndFunc

Func _P($n) ; Permutation
Local $iRet = 1

While $n > 1
$iRet *= $n
$n -= 1
WEnd

Return $iRet
EndFunc

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Ich hoffe jemand kann mir helfen. Das muss doch mit Stochastik irgendwie zu berechnen sein. Irgendwas mit Permutation, Kombination und/oder Variation muss doch passen damit ich das richtige Ergebnis heraus bekomme. Weiß jemand Rat?

Ach stimmt, da habe ich mal wieder nicht nachgedacht.
Entschuldige, man lernt wohl nie aus.

Gern geschehen
Falls du noch Fragen haben solltest kannst du mich entweder direkt anschreiben oder hier im Thread nachfragen.

LG. Make

Du kannst den gleichen AutoIt-Code nutzen den du oben gepostet hast.

Zu den Datentypen, ich versuche es einmal anders zu erklären:
Wenn du von AutoIt aus per DllCall() einen String versendest, hängt AutoIt automatisch noch das Null-Zeichen hinten dran. Aus 'stringtest' wird demnach 'stringtest' & Chr(0). In FreeBASIC ist aber der Aufbau anders, die Strings die dort genutzt werden speichern noch die Länge mit ab. Vereinfacht gesagt wird dort 'stringtest' zu (Länge: 10 Zeichen | String: 'stringtest'). Intern werden die Strings also unterschiedlich gespeichert, wenn du FreeBASIC nun sagst es soll als Datentyp String verwenden, dann versucht es natürlich die übergebene Zeichenkette in seiner eigenen Struktur für Strings zu lesen. Das wäre so als ob du einen Deutschen einen arabischen Text geben würdest und sagst er solle diesen einfach mal vorlesen.

Der Datentyp ZString hingegen entspricht der Struktur wie der, die DllCall() nutzt. Gibt es sonst noch Fragen?

Der Datentyp String arbeitet grundsätzlich anders als der in AutoIt. Wenn du per DllCall() einen String übergibst, ist dieser Null-terminierend, das bedeutet dass das Letzte Zeichen immer das Null-Zeichen (Chr(0)) ist. FreeBASIC speichert aber zu jedem String dessen Länge ab. Dadurch kann FreeBASIC Strings dynamisch verwalten und sogar das Null-Zeichen mitten in einen String abspeichern und ausgeben. Du benötigst den Datentyp ZString welcher die gleiche Arbeitsweise wie von den gewohnten Strings entspricht. Dann sollte das auch so funktionieren wie du dir das vorstellst. Jedoch ist zu beachten dass du einen ZString nicht einfach returnen kannst, lediglich den Pointer dazu kannst du zurückgeben:

Extern "Windows-MS"
Function stringtest(iX As ZString) As ZString Ptr Export

	Return @iX

End Function
End Extern

LG. Make

Du kannst in HTML nicht einfach einen Klassennamen mit Leerzeichen vergeben. Solche Geschichten wie class=“btn btn-info“ (Zeile 7 in der EditDayView.html) sind in HTML nicht valide. Der Grund ist, dass das Leerzeichen in CSS als Selektor fungiert. Z.B. p div { <!-- CSS Code --> } maskiert alle div-Elemente welche Kinder von p-Elementen sind. Da musst du aufpassen dass du nur erlaubte Zeichen für Klassennamen oder ID's benutzt. Erlaubte Zeichen sind ausschließlich alle Groß und Kleinbuchstaben von A bis Z sowie die Zeichen 0 bis 9, der Unterstrich ( _ ) und das Minuszeichen ( - ). Außerdem solltest du mal deine HTML Seite (so wie sie derzeitig ist) durch den W3C Validator schicken. Du wirst erstaunt sein was du da für Meldungen bekommst. Ach ja, sobald ich die index.html aufrufe (unter Chrome) bekomme ich gleich einige JavaScript Fehlermeldungen. Auch da musst du mal am besten nach schauen, hast also noch viel zu tun.

So, jetzt noch eine andere Frage, in deinem Template hast du noch eine Feiertagszulage. Wie genau gedenkst du das mit ein zu beziehen? Soweit ich richtig informiert bin sind die Ferien in jedem Bundesland etwas unterschiedlich. Die meisten Feiertage sind ja noch einheitlich, aber Bayern und Saarland z.B. hat als einzige Bundesländer als gesetzlicher Feiertag Mariä Himmelfahrt (15. August). Da musst du differenzieren, außer dein Rechner soll sich nur auf ein Bundesland beziehen. Ist also schon ziemlich aufwendig was du da vor hast, aber machbar.

Wie man das am besten realisiert muss ich mir erst selber noch überlegen, besonders bei den Feiertagen die sich jährlich um irgendwelche Tage verschieben. Aber im Netz gibt es ja genug Formeln dazu wie z.B. die Osterformel. Ich überlege mir mal wie man das am besten umsetzen kann und was noch alles zu beachten ist. Die Zwischenergebnisse teile ich dir dann mit damit du Anregungen bekommst.

Ich schreibe den Rechner mal als OpenOffice Excel Dokument wenn das Recht ist ja? Lässt sich bestimmt alles mit einfacher Mathematik Berechnen.

LG. Make

Talk wenn es ein Thema ist wo man drüber reden kann. Z.B. Politik, Wetter oder was weiß ich
Natürlich auch Themen zu Computer Games, also alles wo ein allgemeines Interesse besteht und eine sinnvolle Konversation in öffentlicher Form stattfinden kann.
Was nicht mehr hinein passt (also worüber man weder reden noch diskutieren kann) gehört nach Offtopic. Z.B. Deine Anfrage hier.

Aber eigentlich ist das egal, die beiden Foren erfüllen sowieso den selben Zweck, daher ist das nicht so tragisch wenn man beide Foren einfach zusammenlegen würde.

Hey, normalerweise bearbeiten wir Probleme öffentlich. Zum einen können Moderatoren, Administratoren sowie aufmerksame User so sehen ob der Thread nicht gegen unsere Forenregeln verstößt. Zum anderen können suchende (die eventuell das gleiche Problem haben wie du) eine Lösung finden. Wenn wir dir also per Skype und Teamviewer helfen, nützt es anderen überhaupt nicht wenn sie auf diesem Thread stoßen, da sie weder das Problem noch die Lösungsansätze sehen. Zudem können viele Köpfe auch unterschiedliche Ideen hervorbringen um die optimale / beste Lösung zu finden. Bis jetzt wissen wir nicht mal worum es eigentlich genau geht.

Beschreibe doch einfach mal dein Problem auf Deutsch, Englisch oder Denglisch (Mischung aus Deutsch und Englisch, so sehen meine Texte meistens aus ^^). Dann füge deine Versuche bzw. dein Skript mit hinzu. Setze dieses am besten in [ autoit ] BB-Codes. In etwa so:

[autoit]Dein Sourcecode[/autoit]

So wirst du bestimmt auch viel schneller jemanden finden der dir auch tatsächlich helfen kann und will. Nicht dass Raupi ein umfangreiches wissen hat, aber jeder hat so seine „Spezialgebiete“.

LG. Make

Servus, welche sind denn die wichtigsten Dateien?
Ich gehe mal davon aus dass es sich um diese App hier handelt: Webprojekte\templates\EditDayView.html
Wo finde ich den JavaScript-Teil dazu? Oder hast du bis jetzt noch nichts geschrieben?

Hi, die UDF findest du unter http://sebastian-walter.net/projects/196/.

Ne, so schwer ist das auch nicht, es ist nur aufwendiger.
AutoIt regelt das glücklicherweise echt so entspannend, durch die GUI Funktionen ist AutoIt dh. Ein mächtiges Werkzeug um Benutzeroberflächen schnell & einfach zu Designen sowie zu verwalten. Aber wenn man den Bogen erst einmal raus hat, ist das auch mithilfe der WinAPI auch selber in jeder Programmiersprache gelöst. Es sind eben nur mehr Zeilen Code und deutlich mehr Verwaltungsaufwand. Vieles worum man sich selbst kümmern muss. Ich habe mal hier ein Beispielcode geschrieben welcher dies (so glaube ich) ganz gut zeigt. Es geht um eine einfache simple GUI welche in fast jeder Hochsprache auf diese Weise umgesetzt werden muss. (Da ist man manchmal echt froh über die GUI Funktionen in AutoIt )

Normalerweise werden sämtliche Messages jedes Control sowie Window intern von AutoIt verwaltet. Hast du dich nicht mal gefragt wieso wir so schön mit GUICreate() und GUISetState() (2 Zeilen Code) eine GUI erzeugen und anzeigen können? In C++ sind da schon geschätzte 50 Zeilen notwendig. Normalerweise musst du eine Klasse via _WinAPI_RegisterClass() registrieren und dann das Fenster mithilfe von _WinAPI_CreateWindowsEx() erzeugen. Aber damit es nicht noch genug wäre fehlt natürlich noch WndProc Funktion die alle Windows Messages abfängt und behandelt, vom Schließen der GUI bis hin zum minimieren etc.

Lustigerweise ist das aber auch bei Controls so, für jedes Control musst du eine Klasse registrieren und dann das Control erstellen. Das ist sehr aufwendig, dh. regeln das AutoIt intern was es erst ermöglicht diesen ganzen Mist zu ignorieren bzw. erst gar nicht kennen zu müssen. Wenn man jedoch nun selber anfängt Messages abzufangen pfuscht man da quasi AutoIt dazwischen, nun hat man 2 Optionen: Man führt NUR seine eigene Message aus oder führt im Anschluss (welches das Standardverhalten entspricht) noch ZUSÄTZLICH die interne Funktion aus. Dazu muss lediglich die Konstante $GUI_RUNDEFMSG zurückgegeben werden. Man kann also alles selber implantieren oder nur Teile umschreiben bzw. erweitern was einem für das Standardverhalten fehlt.

LG. Make

Das Problem liegt an der Abbruchbedingung. Siehe kommentierte Zeile:

Okey, bei dir entspricht Zeile 25 meiner auskommentierten Zeile. Habe das Skript nur mal auf das nötigste komprimiert. Wie du siehst wird das Array abgeklappert bis wir auf -1 bzw. False treffen. Wenn wir das Skript bis 30 durchlaufen lassen, passiert folgendes:

Alles ungeraden Zahlen ab 3 bis 30 aufschreiben:
3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29

Nun überprüfen welche der Zahlen eine Vielfache von der aktuellen Primzahl ist, bei 3 fangen wir an:

3 <> 5
3 <> 7
3 = 9 >> 9 wird ausradiert
usw...

Folgende Liste bleibt über:
3, 5, 7, -, 11, 13, -, 17, 19, -, 23, 25, -, 29

Gleiches Spiel, dieses mal mit der 5:
5 <> 7
5 <> - >> Abbruchbedingung erfüllt.

Nun geht’s mit der 7 weiter:
7 <> - >> Abruchbedingung erfüllt

Du siehst wo das Problem ist? Ich weiß was du damit bezwecken willst, habe auch schon die Lösung. Die Abbruchbedingung gehört nicht in die zweite For-Schleife sondern muss abgefragt werden BEVOR diese überhaupt gestartet wird:

Wie du siehst wird jetzt auch die 25 degradiert.