Druckbare Version
Hätte nicht gedacht, dass ich so etwas mal brauchen werde. Was bei allen Programmiersprachen üblich ist, da es sich hier um einen Prozessor-Befehl handelt, ist bim RPG-Maker einfach nicht eingebaut.
Meine Frage: Wie lässt sich eine bitweise XOR-Operation mit zwei Variablen simulieren? Am besten wäre, wenn jemand eine mathematische Formel posten würde, die es dafür gibt. Ich komme leider nicht darauf. Die NOT-Operation habe ich geschafft, umzusetzen, aber dieses XOR macht mir Probleme.
http://www.rmxp.net/forums/index.php?showtopic=17768
Das sollte ganz hilfreich sein wenn ich mich nicht täusche (ein paar deiner Begrifflichkeiten in deinem Text sind mir nicht so wirklich geläufig =P)
Edit: ah ich hab noch nicht mal drauf geachtet, ob er den XP benutzt. Knüppelt mich.
Dazu müsstest du die Variablen in Binärwerte umrechnen. Dazu könnte man jetzt eine Variable "Binär" erstellen und diese dann etwa den Wert 100101 geben. Das Problem ist, bei 6 Stellen ist für den Maker Schluss und damit kommt man nicht so weit. Also bräuchtest du schon mindestens 2 Variablen um den Binärwert darzustellen. Dann musst du den Wert jeder Ziffer abfragen und diesen mit dem Vergleichsbit vergleichen. XOR müsste doch so aussehen:
Nach diesem Schema also dann entscheiden ob das Ergebnis wahr oder falsch, 1 oder 0 ist.Code:1 2 Ergebnis
============
0 0 0
1 0 1
1 1 0
0 1 1
@KillatHome:
Ich benutze den RM2000, nicht XP.
@Ynnus:
Naja, meine Variablen nehmen 5-stellige Werte an und die umzurechnen wären eine heidenarbeit. Ausserdem verwende ich ja gerade Variablen, um grosse "Switch"-Mengen zu simulieren. Aber dazu bräuchte ich auch die entsprechenden Operationen. Es wird doch wohl mathematische Formeln hierfür geben?
Naja, es gibt mathematische Formeln um Zahlen in Binärwerte umzurechnen. Nur dann wirst du mit Forks abfragen müssen, wie die einzelnen Stellen der Variablen aussehen usw. Leider ist der maker mathematisch alles andere als großartig und modern.
Aber wozu willst du so viele Switches simulieren, wenn ich fragen darf? Wie viele brauchst du denn? Mittels eines kleinen Hacks im Maker kann man die Obergrenze von Switches und Variablen locker auf die 30.000 hochschrauben. Ich schätze so 65536 dürften drinn sein, vielleicht auch mehr. Muss man ausprobieren. Aber mit den 30.000 ist definitiv schon getestet worden und funktioniert.
Nun, ganz einfach. Ich habe ein Schalterrätsel mit 3 mal 14 Schaltern. Jeder Schalter soll in seiner eigenen Reihe 14 Schalter zufällig an- bzw. ausschalten. Pro Schalter gäbe das also 2^14 = 16384 Möglichkeiten und dies 42 mal = 688128 Switches. Also habe ich mir gedacht, dass es mit Variablen sinnvoller wäre, da ja Zahlen nichts anderes als eine Bitfolge, d.h. eine Folge von Switches sind. Um allerdings den lösungsweg vorzuberechnen (die Schalter funktionieren nach dem Zufallsprinzip), bin ich auf bestimmte Operationen wie eben XOR oder NOT angewiesen.
BTW, um Dezimalzahlen in Binärzahlen umzurechnen, braucht man überhaupt keine Forks, sondern lediglich die / und Mod Funktionen, Zeiger-Variablen und Loops.
Ich bezog die Abfrage mittels Forks auf das Ausfindigmachen des Ergebnisses der XOR-Verknüpfung. Und da wirst du um Forks nicht mehr herum kommen, da Bitweise Operationen nicht vorhanden sind im Maker.Zitat:
Zitat von TheBiber
Ich habe es hingekriegt, ich habe einfach ein Common Event geschrieben, dass die XOR-Funktion simuliert. Hätte eigentlich selber darauf kommen müssen, die Potenz-Funktion habe ich schliesslich auch auf die gleiche Art erzeugt. (und so etwas als Matura-Jahrgangsbester in Mathematik) :rolleyes:
Ich schreibe mal beide Funktionen hier auf, falls sie jemand einmal gebrauchen sollte:
Code:Common Event: Potenz-Funktion
If [Exponent] = 0
[Potenz] set 1
else case
[Potenz] set Basis
[Potenz Zählvariable] set [Exponent]
loop
[Potenz Zählvariable] - 1
if [Potenz Zählvariable] = 0
break
end case
[Potenz] * [Basis]
end loop
end case
Die Potenz-Funktion ist Grundlage für die XOR-Funktion. Um die Funktionen im Spiel benutzen zu können, müssen folgende Befehle ausgeführt werden:Code:Common Event: XOR-Funktion
[XOR Zählvariable] set 0
[XOR Ergebnis] set 0
[XOR Teilvariable 1] set [XOR Operand 1]
[XOR Teilvariable 2] set [XOR Operand 2]
loop
[XOR Prüfvariable 1] set [XOR Teilvariable 1]
[XOR Prüfvariable 2] set [XOR Teilvariable 2]
[XOR Prüfvariable 1] mod 2
[XOR Prüfvariable 2] mod 2
If [XOR Prüfvariable 1] = [XOR Prüfvariable 2]
[XOR Ergebnisvariable] set 0
else case
[XOR Ergebnisvariable] set 1
end case
[Basis] set 2
[Exponent] set [XOR Zählvariable]
Call Event: Potenz-Funktion
[XOR Ergebnisvariable] * [Potenz]
[XOR Ergebnis] + [XOR Ergebnisvariable]
[XOR Zählvariable] + 1
If [XOR Zählvariable] > 20
break
end case
[XOR Teilvariable 1] / 2
[XOR Teilvariable 2] / 2
end loop
Potenz-Funktion p = b^e ausführen:
b befindet sich anschliessend in der Variable [Potenz].Code:[Basis] set b
[Exponent] set e
Call Event: Potenz-Funktion
XOR-Funktion z = x XOR y ausführen:
z befindet sich anschliessend in der Variable [XOR Ergebnis].Code:[XOR Operand 1] set x
[XOR Operand 2] set y
Call Event: XOR-Funktion
Ich habe die Codes überprüft, sie scheinen beide zu funktionieren. Falls jemand einen Fehler entdeckt hat, soll er mich bitte darauf aufmerksam machen. Verbesserungsvorschläge sind ebenfalls willkommen.
Beschreib mal genauer, was das Rätsel soll. XOR zu verwenden öhm wozu? Geht garantiert leichter.
Ich sehe 2 IFs = Forks... *Hähä, sieh an, geht also doch nicht ohne*
@Dhan:
Nein, so wie ich es geplant habe, geht das Rätsel gar nicht anders. Aber momentan stecke ich an einem neuen Problem im selben Rätsel, habe irgendwelche Fehler bei der Berechnung des Lösungsweges gemacht und finde sie kaum mehr. :rolleyes:
@Ynnus:
Das theoretische Umrechnen schon. :p :D
Antworte mir doch nicht direkt ohne eine Aussage zu machen ^^
Ich hab immer noch keinen Plan, was dein Rätsel genau ist. 3 Reihen a 14 Schalter die sich irgendwie beeinflussen (was heißt "zufällig"?)... aha?
Sagt nichts darüber aus, was man in dem Rätsel eigentlich tun muss und wie genau sich die Schalter nun beeinflussen.
Ich kann dir den komplexesten Code zu irgendwelchen Schaltungen aufschreiben aber wenn ich nicht weiß, was du eigentlich brauchst, wird das nichts bringen prophezei ich mal.
Nagut, aber mal zum Thema, XOR wird bei Zeichnungen über einfache elektronische Systeme mit = 1 dargestellt. (oder mit ein paar &s, abhängig von der Eingangsanzahl)
Ums mal ganz simpel zu sagen, du splittest die Variable, die die Switches speichert, kurz mal wieder in temporäre Switches auf (also in Binärstellen) und addierst +1 zu einer neuen (ebenfalls temporären) Variable für jeden aktivierten dieser Switche. Ist die Variable = 1, so ist XOR eingetreten.
Wo liegt das Problem?
Ne aber beantworte mir bitte die Frage, was GENAU du eigentlich da baust
Tja, komplexen Code schreiben kann ich auch, solange es bei Grundlagen-Programmierung bleibt. :DZitat:
Zitat von Dhan
Aber gut, ich erklär es mal:
Im Raum gibt es zunächst 14 Schalter und eine Türe. Um die Türe zu öffnen, müssen alle Schalter umgelegt sein. Sobald man einen Schalter umschaltet, werden von den restlichen 13 Schaltern zufällig vorher definierte ebenfalls umgeschaltet. Hinter der Türe kommt dann quasi dasselbe Rätsel noch einmal und hinter der nächsten gleich noch einmal. Also wenn das System für die ersten 14 Schalter funktionieren würde, wäre es kein Problem, dies umzuschreiben. Und ja, ich weiss, dass das Rätsel abartigstens, krankhaft schwierig ist, aber mein Spiel ist sowieso mehr Experiment als Spiel. ;)
Nun, mein Code von vorhin erfüllt eigentlich den Zweck, die XOR-Funktion auszuführen. Von dem her, ist das Thema dieses Threads gelöst. Momentan habe ich ein anderes Problem. ;)Zitat:
Nagut, aber mal zum Thema, XOR wird bei Zeichnungen über einfache elektronische Systeme mit = 1 dargestellt. (oder mit ein paar &s, abhängig von der Eingangsanzahl)
Ums mal ganz simpel zu sagen, du splittest die Variable, die die Switches speichert, kurz mal wieder in temporäre Switches auf (also in Binärstellen) und addierst +1 zu einer neuen (ebenfalls temporären) Variable für jeden aktivierten dieser Switche. Ist die Variable = 1, so ist XOR eingetreten.
Wo liegt das Problem?
Ok, habe ich, zufrieden? :DZitat:
Ne aber beantworte mir bitte die Frage, was GENAU du eigentlich da baust
1.XOR Funktionen gehen nur bei 2 Eingängen, die abgefragt werden
2.Benutz das nächste mal direkt Wörter wir Exklusiv-Oder oder Antivalenz, damit auch jemand der nicht der Digitaltechnik mächtig ist, dir helfen kann
3.Wieso brauchst du 3*14^2 Tabs, um den Zustand von 42 Schaltern zu speichern?
4.Erklär mir bitte den Sinn deines Rätsels, da es sich eher nach einem Glücksspiel für mich anhört
XOR kommt doch nicht nur in der Digitaltechnik vor. Ich kenne es als festen Begriff der Programmierung. Ansonsten, wer weiß was Exklusiv-Oder ist, sprich, wie man die bit verknüpfen muss um das gewünschte Ergebnis zu erzielen, der weiß auch was XOR ist. Und wer beides eben nicht weiß, der hält sich eben raus und lässt die Leute antworten, die Ahnung davon haben. So ist das eben im Forum.Zitat:
2.Benutz das nächste mal direkt Wörter wir Exklusiv-Oder oder Antivalenz, damit auch jemand der nicht der Digitaltechnik mächtig ist, dir helfen kann
1. 42*2^14 bitte!Zitat:
Zitat von DR_Zeph
2. Ich speichere nicht den Zustand von 42 Schaltern, sondern die Wirkung der einzelnen Schalter: ein Schalter kann 14 Schalter per Zufall umschalten, demnach kann er 2^14 verschiedene Dinge tun.
Der Sinn erfährt derjenige, der spielt.Zitat:
4.Erklär mir bitte den Sinn deines Rätsels, da es sich eher nach einem Glücksspiel für mich anhört
Scheinbar gehste immernoch nicht drauf ein, das eine XOR Funktion nur bei 2 Eingängen gehen.
aber nya, zu den anderen Punkten:
hä? Also du legst einen Schalter um? Soweit so klar. Dann bewegen sich mit ihm 14 weitere Schalter um, per Zufall. Richtig?
demnach kann er für mich nur eine Sache tun, Zufällig umschalten, und das ist keine Sache, die man in irgendeiner Form speichern müsste. Wenn es beim nächsten Unlegen wieder alle per Zufall bewegt werden.Zitat:
demnach kann er 2^14 verschiedene Dinge tun.
Achja, im Raum sind 14 Schalter, ich leg einen um und es wechseln alle anderem im Raum auch ihren Zustand. Nicht der eigentliche Schalter. Wie kommst du dann auf 2^14 möglichkeiten?
So, Ich würde das ganze mittels Variablen Regeln. Eine Variable kann imo 10^6 wertige Zahlen speichern. Damit würdest du pro Raum imo 1 Variable pro Raum benötigen. Wenn du zusätzlich auch noch die Zufällige änderung Speichern willst, brauchst du zusätzlich nochmal 1 Variable pro Raum! Wieso? Wir Rechnen einfach unser Binäres Zahlensystem und damit die Pegel unsere Schalter in unserer Wunderschönes Dezimale Zahlensystem, da wir damit Problemlos den Umgerechneten Wert von 2^14 bzw. 2^13 speichern können.
Ynnus hat dazu alles gesagt. In Programmiersprachen kann man die XOR-Operation auch auf gewöhnliche Zahlen anwenden, ebenso mit dem Windows-Taschenrechner.Zitat:
Zitat von DR_Zeph
Nope. Beim nächsten Umlegen schaltet er wieder exakt die gleichen Schalter um. Welche allerdings wird beim Betreten des Raumes festgelegt. D.h. sobald man den Raum verlässt, verhalten sich alle Schalter wieder anders. Und deshalb muss für jeden Schalter eine Switch-Reihe bzw. eine Variable festgelegt sein, die bestimmt, welche Schalter in dieser Sitzung umgeschaltet werden.Zitat:
aber nya, zu den anderen Punkten:
hä? Also du legst einen Schalter um? Soweit so klar. Dann bewegen sich mit ihm 14 weitere Schalter um, per Zufall. Richtig?
demnach kann er für mich nur eine Sache tun, Zufällig umschalten, und das ist keine Sache, die man in irgendeiner Form speichern müsste. Wenn es beim nächsten Unlegen wieder alle per Zufall bewegt werden.
Rein theoretisch wären es 2^13 Möglichkeiten. Es ergibt sich allerdings ein praktisches Problem, nämlich die Vorherberechnung des Lösungsweges. Dazu speichere ich für jeden Schalter eine Bitfolge für 14 Schalter ab mit der Anweisung, dass das Bit für den jeweiligen Schalter auf jeden Fall 1 sein muss, damit der entsprechende Schalter auf jeden Fall umgeschaltet wird.Zitat:
Achja, im Raum sind 14 Schalter, ich leg einen um und es wechseln alle anderem im Raum auch ihren Zustand. Nicht der eigentliche Schalter. Wie kommst du dann auf 2^14 möglichkeiten?
Ich brauche aber 14 Werte und nicht einen. Zudem findet alles im gleichen Raum statt, die 3 Schaltterreihen befinden sich lediglich hinter den Wänden die durch die Türen verbunden sind. :rolleyes:Zitat:
So, Ich würde das ganze mittels Variablen Regeln. Eine Variable kann imo 10^6 wertige Zahlen speichern. Damit würdest du pro Raum imo 1 Variable pro Raum benötigen. Wenn du zusätzlich auch noch die Zufällige änderung Speichern willst, brauchst du zusätzlich nochmal 1 Variable pro Raum! Wieso? Wir Rechnen einfach unser Binäres Zahlensystem und damit die Pegel unsere Schalter in unserer Wunderschönes Dezimale Zahlensystem, da wir damit Problemlos den Umgerechneten Wert von 2^14 bzw. 2^13 speichern können.
Ausserdem habe ich das Problem fast gelöst, mir fällt nur nicht ein, wie ich die Bitfolge aus der Variable, die die zur Lösung relevanten Schalter speichert rückwärts auslesen lassen soll, um die letzten beiden relevanten Schalter-Variablen-Nummern ausfindig zu machen. Diese beiden Nummern sind notwendig, um den Lösungsweg zu berechnen. Da die Bitfolge vorwärts ausgelesen wird, stimmt die Lösung im allgemeinen nicht.
jez weiß ich auch endlich was du mit dem ganzen dingel bezwecken willst,
aber weiter im Text:
Die änderung eines Schalters kannst du wiegesagt in einer Variable speichern. Indem du einmal Binär bestimmst, welche Wirkung ein Schalter hat, auf die anderen Schalter, dabei käme z.B. dieses Ergebnis heraus:
10110101011010
Um dieses Ergebnis nun Speichern zu können, müssten wir entweder 14 Switche nehmen, 3 Variablen beim 2k und 2 beim 2k3.
So, wieso Rechnen wir das ganze nun nicht einfach um, undzwar in unsere Dezimales Zahlensystem, da dort auch 11111111111111 locker in einer Variable gespeichert werden kann.
Meinst du jez das herausfiltern einer Stelle in eine Variable, oder die Berechnung? Wird daraus nicht so ganz klar.Zitat:
Ausserdem habe ich das Problem fast gelöst, mir fällt nur nicht ein, wie ich die Bitfolge aus der Variable, die die zur Lösung relevanten Schalter speichert rückwärts auslesen lassen soll, um die letzten beiden relevanten Schalter-Variablen-Nummern ausfindig zu machen.
Eine Variable kann maximal den dezimalen Wert 999999 annehmen. Wennschon bräuchte man 3 dafür, allerdings gäbe es dann ein ziemliches Problem bei der Berechnung. Ausserdem, ob ich die Werte jetzt dezimal oder binär speichere macht rein mathematisch nur den Unterschied, dass ich bei Teil- und Modulo-Operationen 10 statt 2 nehmen muss. Von dem her ist diese Methode erstens verschwenderischer und zweitens um einiges komplizierter, da man 3 Variablen braucht. Ich berechne die Variablen schliesslich mit Hilfe der Variablen-Nummern (Pseudo-Zeiger-Variante) und das wird bei 3 Variablen pro Schalter schnell undurchschaubar.Zitat:
Zitat von DR_Zeph
Also die Berechnung wird es wohl nicht sein, wenn ich schon in der Lage bin, Variablen binär aufzubauen und wieder zu entziffern (wird auch beim XOR-Code angewandt). Das Problem ist, dass ich die Variable in der umgekehrten Reihenfolge entziffern muss, wie sie aufgebaut ist, da ich die "Stellen" (das wären dann die entsprechenden Variablen-Nummern, die in Pseudo-Zeiger-Variablen gespeichert werden) der letzten beiden 1-Werte der Variablen, welche die relevanten Schalter speichert (ist eine notwendige Zusatzvariable, die aber nach dem gleichen Prinzip funktioniert) brauche.Zitat:
Meinst du jez das herausfiltern einer Stelle in eine Variable, oder die Berechnung? Wird daraus nicht so ganz klar.
Ein möglicher Lösungsansatz wäre natürlich eine Spiegelung des Bitmusters, die Frage ist jetzt wieder, wie das umzusetzen wäre. Ich könnte natürlich die Bits auslesen und nach dem Lifo-Prinzip abspeichern und wiederverwenden. Jetzt wäre eine Stack-Datenstruktur praktisch, aber eben...
Ich werde für zukünftige Spiele wohl so bald wie möglich auf den Game Maker umsteigen, die GML dort ist um einiges vielseitiger als das Event-Command-System. :rolleyes:
du weißt scheinbar nicht, worauf ich hinaus wollte?
du brauchst, um den Zustand von 14 Schaltern zu speichern, nur eine Variable, eben wenn du es Dezimal speicherst, da 14 Binäre HI's den maximalen Wert von 16384 annehmen, und das kann man imo in eine 2k sowie 2k3 Variable speichern. Wenn du nun den Schalter umlegst, einfach diesen Wert umrechnen und gut ist.
die Negation deines Lösungsweges sollte imo kein Prob mittels eines Cycels sein.
So, zu deinem Rückwärts entziffern frag ich mich wo dein Prob ist, Modul und Division sollten dir bekannt sein, und damit ist es in meinem Augen kein Problem, eine Variable vorwärts sowie Rückwärts in ihre Einzellstellen zu zerlegen. Wozu du nun Pointer mit ins Spiel bringst, ist mir nun ein Rätsel.
Naja, die Lösung selbst habe ich schon lange fertig. Allerdings habe ich für den Zustand der Schalter keine Variable, sondern 14 einzelne Switches verwendet, weil diese einfacher abzufragen sind, um die Grafiken für die Schalter bewegen zu lassen. Der Zustand des Rätsels ist aber das einzige, was ich mit Switches speichere. Für den Zustand brauche ich überhaupt keine Variable, aber ich brauche 14 Variablen, um zu bestimmen, welche Switches welcher der 14 Schalter switcht..Zitat:
Zitat von DR_Zeph
Tja, der Lösungsweg ist nunmal zufällig. Aber ich erkläre jetzt mal konkret, was ich codetechnisch gemacht habe, um die Variablen zu erzeugen: Ich habe zunächst eine zufällige Variable zwischen 0 und 16383 erstellt, die bitweise definiert, welche Schalter für die Lösung relevant sind, also gedrückt werden müssen, und welche nicht. Diese nenne ich die Relevanzvariable. Mit Hilfe dieser Variable habe ich dann die Nummern der letzten beiden relevanten Schalter ausfindig gemacht (hier ist das Problem mit dem Rückwärtsentziffern). Anschliessend habe ich für jede Variable eine Zahl aus zufälligen Bits zusammengesetzt und zwar mit Hilfe von mehreren Loops und Pointern. In dieser Routine musste ich auch einbauen, dass das Bit, welches den Schalter der entsprechenden Variablen selbst darstellt, auf jeden Fall 1 sein muss, damit der bezogene Schalter auf jeden Fall umgeschaltet wird. Bei der Variable des vorletzten relevanten Schalters habe ich zunächst den Lösungsweg bis dahin berechnet. Konkret habe ich die Variablen aller relevanten Schalter mit der XOR-Operation berechnet und in die Lösungsvariable gespeichert. Diese wird dann wieder aufgesplittet, um das Bit des letzten relevanten Schalters in der Variable des vorletzten relevanten Schalters gleich zu setzen wie das Bit der bisherigen Lösungsvariable (dies ist notwendig, damit der letzte Schalter zu diesem Zeitpunkt der Lösung auf jeden Fall nicht umgelegt ist). Anschliessend habe ich beim letzten relevanten Schalter zunächst nochmals eine XOR-Operation durchgeführt und zwar mit der Lösungsvariable und der Variable des vorletzten Schalters. Die Negation der Lösungsvariable bis dahin muss dann dem Bitmuster des letzten relevanten Schalters entsprechen, damit dieser alle zu diesem Zeitpunkt nicht umgelegten Schalter umlegt. Negiert wird ganz einfach, indem die Differenz der Zahl und 16383 berechnet wird.Zitat:
die Negation deines Lösungsweges sollte imo kein Prob mittels eines Cycels sein.
Du hast mich nicht verstanden. Die Pointer brauche ich, um zu speichern, welche der 14 Schalter die letzten beiden relevanten Schalter sind und diese brauche ich wie oben beschrieben für die Berechnung ihrer eigenen Variablen, damit diese zusammen mit den anderen relevanten Schaltern den Lösungsweg ergeben können.Zitat:
So, zu deinem Rückwärts entziffern frag ich mich wo dein Prob ist, Modul und Division sollten dir bekannt sein, und damit ist es in meinem Augen kein Problem, eine Variable vorwärts sowie Rückwärts in ihre Einzellstellen zu zerlegen. Wozu du nun Pointer mit ins Spiel bringst, ist mir nun ein Rätsel.
Und meine Frage ist unbeantwortet. Vorwärts aufsplitten ist kein Problem, da nehme ich einfach direkt /2 und mod2. Ich will aber rückwärts aufsplitten können.
EDIT:
Ich sehe beim nochmals durchlesen gerade, dass ich mich falsch ausgedrückt habe: Das Problem ist die Berechnung für das Rückwärts-entziffern (also vom hohen zum tiefen Bit).
Simpel ausgedrückt, du brauchst eine Routine die dafür sorgt, dass das Rätsel überhaupt lösbar ist, d.h. sich durch den Zufall nichts bildet, was niemals zum Ziel führen kann.
DAS is mal ne Aufgabe ^^
Knifflig uhm... öhm du könntest erstmal nur 13 Schalter definieren und dann eine Matrix durchrechnen lassen, obs eine Lösung gibt (0/1-Matrizen dürften net soo schwer sein, ich nehm mal an, damit hast du kein Problem so wie du geskillt bist) und wenn nicht eine Lösung festlegen lassen.
Soll ich mir den Kopf drüber zerbrechen oder kommst du alleine auf den Code der Matrix? (ich würd dir jetzt einen Code schreiben weil ich gerne komplexes Zeuch mache aber der viele Sekt hat da irgendwie was dagegen und meint ich soll pennen)
edit: Uh mir is noch was eingefallen, müssten die 14 Switchvariablen nicht einfach in der Matrix mit einem Faktor von 1 oder 0 (Lösungswegabhängig was 1 und was 0) einfach 16384 (11111111111111b) ergeben? kA obs richtig is, zu kirre im Kopp um klar Mathematik zu machen
Rückwärts aufsplitten stellt imo auch kein Prob dar, da es das selbe Prinzip ist, wie das Vorwärts aufsplitten.Zitat:
Und meine Frage ist unbeantwortet. Vorwärts aufsplitten ist kein Problem, da nehme ich einfach direkt /2 und mod2. Ich will aber rückwärts aufsplitten können.
Dafür fallen mir direkt zwei Methoden ein, wie das ganze imo kein Prob sein sollte, wovon ich einfach eine mal Code,
http://img330.imageshack.us/img330/9411/code0lt.jpg
Variable Dekade muss dabei auf die Stelle gesetzt werden, die herausgefiltert werden soll. Die Variable Hilfsvariable wird nacher auf den Wert gesetzt, den die Stelle hat.
Na, dann erklär mir doch bitte das Prinzip. Wenn ich eine Zahl habe, z.B. 11010 = 26, und ich diese nach und nach mit /2 und Mod2 aufsplitte, kommen nach und nach die Werte 0, 1, 0, 1, 1, in dieser Reihenfolge. Meine Frage ist, wie funktioniert das Verfahren, wenn ich die Werte in der umgekehrten Reihenfolge haben will, also 1, 1, 0, 1, 0?Zitat:
Zitat von DR_Zeph
Mit dem Code kann ich leider nicht viel Anfangen, da du meine Idee falsch aufgefasst hat. Ich brauche nicht den Wert einer bestimmten Stelle bei bekannter Stellennummer, sondern ich brauche die Nummer einer im voraus unbekannten Stelle, die erstmals bzw. zweitmals den Wert 1 hat. Zudem habe ich doch gesagt, dass ich binär und nicht dezimal arbeite. Ausserdem habe ich den Code schon längst geschrieben und dann auch noch effizienter, da ich ein Loop verwendet habe und nicht einfach hintereinander kopierte Befehle mit sich stetig ändernden Werten. Darf ich fragen, wie es mit deiner Programmiererfahrung steht?Zitat:
Dafür fallen mir direkt zwei Methoden ein, wie das ganze imo kein Prob sein sollte, wovon ich einfach eine mal Code,
Variable Dekade muss dabei auf die Stelle gesetzt werden, die herausgefiltert werden soll. Die Variable Hilfsvariable wird nacher auf den Wert gesetzt, den die Stelle hat.
Mein einziges Problem ist, wie man die Zahl berechnen soll, damit die einzelnen Stellen in der umgekehrten Reihenfolge ausgelesen werden, wie oben beschrieben. Und dazu brauche ich keinen Code, sondern lediglich einfache mathematische Anweisungen, auf die ich momentan nicht selbst komme bzw. die ich auch im Netz nicht so finde.
EDIT: @Dhan:
Erstmal wieder nüchtern werden. :D
Danach würde ich empfehlen, meine Posts nochmals durchzulesen, ich habe die Lösung schon lange programmiert, ich habe lediglich noch dieses eine Problem (und evtl. noch Fehler, aber das konnte ich ja noch nicht austesten), Deine Idee wäre natürlich auch ein guter Ansatz und ja, am Ende muss die Lösung den Wert 16383 annehmen (nicht 16384, weil die 0 auch inbegriffen ist). Der einzige Nachteil deiner Idee ist die relativ lange Rechenzeit und dass, falls es keine Lösung gibt, automatisch wieder meine Methode angewendet werden müsste, also lass ich es mit dem Überprüfen, das Rätsel ist auch so schwierig genug und falls es zufälligerweise einmal zwei Lösungen geben sollte, ist mir das auch recht. ;)
Nya, scheinbar bist du außerhalb des Rings net unterwegs, weil du mich dann vll kennen würdest und sich die Frage nach meiner Programmiererfahrung erübrigen würde.
In Beispielen arbeite ich meist ungern mit Cycklen und Pointern, da sie den Code imo unübersichtlich machen und somit das Verständnis erschweren würden, zudem schau ich bei meinen Code's ob es sich lohnen würde, einen Cyckel zu benutzen, oder ich die Sache 2 mal kopier und 2 Werte veränder.
Dann frag ich mich jez, wo dein Prob liegt, mit meinem Code kann man vor sowie Rückwärts die Stellen auslesen. Dazu einfach einmal Variable Dekade auf 14 setzen, und dann nach jedem durchlauf -1 auf die Variable Dekade anwenden. Schon fängt der Maker an, und liest von Links nach Rechts die Variable in ihre einzellnen Stellen aus.
Durch erweiterung einer Variable kannst du zudem erechnen wieviele Werte 1 sind, durch erweiterung noch einer Variable kannst du bestimmen, welche Stelle die zweite, dritte, oder vierte 1 besitzt.
Somit seh ich eigentlich keinen Fehler in meinem Code, aber ich lass mich gerne belehren.
Und wieso sollte ich dich dann kennen? Und meine Frage bleibt damit unbeantwortet.Zitat:
Zitat von DR_Zeph
Loops lohnen sich generell immer, da der Code allgemeiner ist und auch auf andere Probleme übertragen werden kann. Ausserdem bin ich es gewohnt, auf diese Art zu denken, das andere verwirrt mich eher und gibt nicht gerade das Bild eines guten Programmierstils ab, weshalb ich auch obige Frage gestellt habe.Zitat:
In Beispielen arbeite ich meist ungern mit Cycklen und Pointern, da sie den Code imo unübersichtlich machen und somit das Verständnis erschweren würden, zudem schau ich bei meinen Code's ob es sich lohnen würde, einen Cyckel zu benutzen, oder ich die Sache 2 mal kopier und 2 Werte veränder.
Von Fehlern war nie die Rede.Zitat:
Dann frag ich mich jez, wo dein Prob liegt, mit meinem Code kann man vor sowie Rückwärts die Stellen auslesen. Dazu einfach einmal Variable Dekade auf 14 setzen, und dann nach jedem durchlauf -1 auf die Variable Dekade anwenden. Schon fängt der Maker an, und liest von Links nach Rechts die Variable in ihre einzellnen Stellen aus.
Durch erweiterung einer Variable kannst du zudem erechnen wieviele Werte 1 sind, durch erweiterung noch einer Variable kannst du bestimmen, welche Stelle die zweite, dritte, oder vierte 1 besitzt.
Somit seh ich eigentlich keinen Fehler in meinem Code, aber ich lass mich gerne belehren.
Aber jetzt sehe ich, nach welchem Prinzip der Code funktioniert: Eine Zählvariable wird hochmultipliziert bzw. heruntergeteilt und dann schrittweise als Divisor verwendet, um aus der Variablen die einzelnen Stellen herauszulesen.
Ist aber noch mühsam, dieses Prinzip aus dem RM-Code herauszulesen. In Worte gefasst hätte ich es eher verstanden, vor allem, weil der Code meiner Meinung nach auch unzureichend kommentiert war und überhaupt, weil da jegliche Erklärung fehlte.
Aber ich bedanke mich mal für die Lösung, werde sie alsbald mal einbauen und hoffe, dass das Rätsel endlich einwandfrei funktioniert.