Versuchs mal damit:

Bedingung IstESO
Wenn istWand Dann
dreheLinks
Wenn ist Wand Dann Wahr
Sonst Falsch
*Wenn
*Wenn
*Bedingung

Ich kenne Robot Karol selbst nicht, daher kann ich nicht für korrekte Formulierung garantieren. Der Grundgedanke müsste aber richtig sein. Funktioniert allerdings nur, wenn Robot Karol aus Norden kommt, d.h. nur bei ungerader Spaltenzahl.
Dein Ansatz ist eigentlich nicht schlecht, allerdings trifft Deine Bedingung jedes Mal zu, wenn Karol auf eine südliche Wand trifft.

Füge da einfach nach dem RechtsDrehen ein:

Wenn IstWand Dann Wahr
Sonst Falsch
*Wenn*

dann könnte es klappen.

Ich bezweifle dass jemand on ist der mir helfen kann, aber:

Ich muss in Assembler mit Hilfe von SSE das Skalarproukt zweier Vektoren berechnen. Leider bin ich in Assembler eine null haha..
FALLS das soweit richtig ist, habe ich die zwei Vektoren multipliziert und die Werte in einem Vektor gespeichert. Jetzt müsste ich diese Werte addieren, doch leider weiß ich nicht, wie man Werte innerhalb eines Vektors addiert.. kann mir da jemand helfen?


1 .data
2 floatout: .string "Wert %f\n"
3 x: .float 12.0, 12.0, 3.0, 71.0 # vector 1
4 y: .float 19.0, 10.0, 111.0, 12.0 # vector 2
5 n: .long 4 #dimension
6
7 result: .float 0.0 #result
8
9 .text
10
11 .globl main
12 main:
13 movl x, %eax
14 movl b, %ebx
15
16 movups (%eax), %xmm0
17 movups (%ebx), %xmm1
18 mulps %xmm1, %xmm0
19
20
21
22
23
24 fstpl (%esp) # output
25 pushl $floatout
26 call printf
27
28 # Exit
29 movl $1, %eax
30 int $0x80

Leider gibt es nicht den Assembler, deshalb wären Angaben wie der verwendete Assembler (Programm zum Übersetzen in Opcodes) und Architektur gut.
Folgendes habe ich mir rekonstruiert:
Linux (da "int 0x80")
Gnu-Asm (da AT&T/Motorola Assembler verwendet wird + Linux + dieser dort verbreitet ist; ergo eher geraten)
x86/AMD64 Architektur, min. Pentium 3 (da damit (I)SSE 1 eingeführt wurde)

Auch wären Angaben, welche Rahmenbedingungen du hast - z.B. ob du zwangsweise SIMD(SSE)-Code verwenden musst - hilfreich.

Ich habe mir deshalb mal ein Lubnuntu aufgesetzt und mit folgendem Befehl deinen Code (Datei PB.S genannt) kompiliert:
g++ -g -m32 PB.S -o pb

Allerdings baut der Code nicht, da "b" unbekannt ist (Zeile 14). Ich nehme einfach mal an, dass y gemeint war.
Wenn man das Programm dann baut und ausführt stürzt es wie erwartet in Zeile 16 ab. Deine Zeile besagt, dass der Inhalt von EAX als Adresse aufgefasst werden soll und 128 Bit des Speichers ab dieser Adresse in das Register XMM0 geschrieben werden soll. Und was steht in EAX? Es ist 0x41400000, was der hexadezimalen Repräsentation von IEEE 754, einfacher Genauigkeit des Wertes 12,0 entspricht.
Oder anders ausgedrückt, du kopierst den ersten Wert deines Vektors nach EAX und interpretierst diesen Wert dann allerdings als Zeiger. Und da du auf diese Speicheradresse nicht zugreifen darfst, knallt es.
Stattdessen willst du den Zeiger auf deinen ersten Wert von X nach EAX speichern, für so etwas gibt es den Befehl LEA (Load Effective Address).

Nun einige Anmerkungen zu deinem Code/Grundproblem. Du verwendest SSE-Code, dies hat auch immer Nebeneffekte. Wenn du reine Assembler-Programme schreibst kannst du das relativ leicht selber absichern, sofern dein Betriebssystem SSE unterstützt. Benutzt du allerdings Inline-Assembler wird das schon kompliziertes. Allgemein denke ich, dass SIMD-Erweiterungen wie SSE an dieser Stelle nicht notwendig sind - zumindest bei dem, was ich hier sehe. Ich persönlich habe schon einmal SIMD bei Vektor-Rechnungen verwendet und konnte sowohl Visual Studio C++, als auch Gnu C++-Compiler in Punkte Geschwindigkeit (wobei die ordentlich optimieren durften!) geschlagen, um ca. 2%. Das hat mich über 20 Stunden gekostet, heutige Compiler sind einfach verdammt gut im Optimieren und in meinem Fall hatten die Vektoren Millionen von Einträgen - nur so konnte ich den zusätzlichen Overhead eliminieren. Optimierung per Assembler lohnt sich bei den heutigen, ausgereiften Compilern nur noch sehr selten!
Statt den SIMD-Code bietet sich wohl eher die Rechnung mit der FPU an.
Dann wird "int 0x80" verwendet. Ich weiß, in der Linux-Welt kommt das immer noch ab und zu vor, als Fallback-Lösung. Doch heutzutage verwenden eigentlich nur noch Treiber und Schadsoftware Interrupt, Alternativen gibt es schon sehr lange. Wobei ich allerdings auch anmerken will, dass ich Assembler eigentlich nur unter Windows, bei Betriebssystem-Programmierung oder inline verwendet habe.
Bei der Assembler-Programmierung ist es meiner Erfahrung nach immer gut eine entsprechende Dokumentation der Befehle parat zu haben und zu befragen. Bei x86/x64 sind das natürlich die Handbücher von Intel und AMD (unter Manuals, Vol. 4). Die von Intel finde ich besser, allerdings habe ich auch mit denen "gelernt" und es ist vermu7tlich nur eine Gewöhnungssache. Beide verwenden übrigens Intel-Syntax, nicht AT&T!

Nun zum Schluss zu deiner eigentlichen Frage:
Floatingpoint Operationen werden i.d.R. mit der FPU erledigt. Der von dir bereits verwendete Befehlt "fstpl" (Store Floating Point Value) ist bereits ein Befehl von/für diese Einheit. Die FPU ist als eine Art Stack aufgebaut. Es gibt 8 Register und die meisten Befehle gehen auf das oberste Element "ST(0)". Für die Addition musst du nun die Werte auf diesen Stack "pushen" und mit FADDP kannst du dann die obersten Elemente (ST(0) und ST(1)) miteinander addieren.
Falls du ganz von SIMD wegkommen möchtest: mit FMULP kannst du ST(0) und ST(1) miteinander multiplizieren.
Die Benutzung der FPU ist aufgrund des STACK-Konzeptes etwas gewöhnungsbedürftig, sind doch die anderen Befehle register-basierend.

PS: Hier im Board gibt es den BBCode "code", mit dem man Quellcode gut darstellen kann:

Vielen vielen Dank!

Zuerst einmal, ja das b sollte ein y sein, es war schon spät...
Ich muss das Skalarprodukt zweier Vektoren berechnen und MUSS dafür SSE verwenden. Lerne Assembler gerade in der Uni und da ist das so vorgegeben.
Deine Annahmen waren richtig, wir benutzen AT&T, deshalb kann ich die Intel-Anleitungen leider nicht benutzen, habe aber selbst einige.
Mit FPU kenn ich mich aus, muss aber wie gesagt SSE benutzen.

Das mit dem Register einlesen habe ich gemacht, weil auf den Vorlesungsfolien folgendes stand (Auszug):


Zwei Vektorenadressen befinden sich in êx und ëx


( Weiß nicht wie eine neue Zeile anfängt,sorry )

Also müsste es doch so gehen?

PS: Mittlerweile habe ich HADDPS gefunden, mit dem ich an mein Ergebnis komme. In " result " steht dann allerdings das Ergebnis 4mal, da es ein Vektor ist. (Wenn ich das richtig verstanden habe.) Nun will ich nur EINS dieser Werte, egal welches, rausnehmen und pushen. Gibt es dafür einen Befehl?

Das Intel-Handbuch ist dennoch benutzbar. Die Unterschiede halten sich in Grenzen, besonders wichtig ist nur, dass die Reihenfolge der Parameter genau umgedreht ist. Für (aktuelle) x86/x64- und ISSE-Befehle gibt es keine besseren Referenzen als die Entwickler dieser, Intel und AMD. Aber es ist auch nicht schlimm, wenn die nicht benutzt werden. Wenn du eine Quelle mit AT&T-Syntax hast, ist auch gut. Das erspart einem das ständige Umdenken. Selbst mit einigen Erfahrungen kann doch mal eine Verwechslung geschehen.


(Der Code wird so direkt wiedergegeben, Zeilenumbrüche werden somit mit Zeilenumbrüchen dargestellt. Ich weiß allerdings gerade leider nicht, ob er unbedingt "Windows-Zeilenumbrüche" will.)

Du hast selber geschrieben, dass auf der Folie "Vektorenadressen" steht. Deshalb muss du in EAX/EBX auch die Adressen und nicht das erste Element schreiben. Und das macht man, wie gesagt, mit LEA (auf Anhieb finde ich leider nur Quellen mit Intel-Syntax).

Gibt es eine Vorgabe, welche SSE-Version es sein soll? Dein HADDPS ist beispielsweise SSE3. In SSE4.1 gibt es das Skalarprodukt sogar als einen direkten Befehl DPPS. SSE3 ist in späteren Pentium 4 Prozessoren 2004 vorhanden, SSE4.1 mit späteren Core2 Prozessoren Ende 2008. Die Wahl entscheidet also, wo der Code später laufen kann/soll.

Dein HADDPS macht nicht das, was du denkst, zumindest, wenn ich dich richtig verstanden habe. Im Handbuch von Intel (tut mir Leid, dass ich damit schon wieder anfange) ist eine gute Abbildung, was dort berechnet wird.
Wenn in xmm0 die Zahlen a,b,c,d stehen und in xmm1 die Zahlen w,x,y,z, dann ergibt sich mit in xmm0 die Zahlen (w+x),(y+z),(a+b),(c+d).
Du kannst den Befehl natürlich missbrauchen und ihn zweimal benutzen, im zweiten Register steht dann am Besten immer 0.

Nach der zweiten Anwendung befindet sich im untersten Element dein gewünschtes Ergebnis, der Rest ist leer. Du könntest den kompletten Ergebnisvektor (1x Skalarprodukt und drei mal 0) in x oder y schreiben und dann nur das richtige Element verwenden.
Mit MOVSS kannst du wohl auch einen einzelnen Wert, allerdings nur den Untersten, herausholen.

Vielen Dank, habe es leider jetzt erst gesehen. Ich habe es mit LEA gelöst wie du richtig gesagt hast und haddps war der Schlüssel zur Lösung. Wir durften SSE benutzen aber nicht höher als SSE 3, deshalb ist das mit DDPS weggefallen.

Nun habe ich Assembler zum Glück hinter mir und muss nun C++ lernen. In 90 Minuten wurde das durchgegangen..
Da C++ aber verbreiteter ist im Forum, hoffe ich dass mir jemand helfen kann bei folgenden Fragen:





Das Idiom ist unter dem Namen erase-remove bekannt. Was passiert bei dieser Kombination von Aufrufen?
Was ist der Inhalt von str nach diesen Aufrufen? (1 Punkt)

So ist die Aufgabe. Soweit ich es erkenne, werden die Klammern ausgewählt und der Rest vorangeschoben. Anschließend wird alles was im end gespeichert ist gelöscht, also nach dem Letzten NICHT ausgewähltem Objekt. Demnach bleibt dann der String OHNE Klammern zurück, richtig?

Ich finde, man sollte Quellcode auch einfach mal ausprobieren.


Ich habe den Code mal etwas angepasst, damit er ausführbar wird. Falls Fragen dazu sind, einfach heraus damit.
Mit deiner Annahme, dass die Klammern entfernt werden, hast du also Recht. Doch was passiert genau? Dazu kann man sich die Hilfe von std::string::erase und std::remove_if ansehen. Bevor jetzt etwas Text kommt, es kann sein, dass du alles richtig verstanden hast und ich dich nur falsch verstanden habe. Aber so wie ich dich verstehe, hast du einen kleinen Fehler im Gedankengang.

Beginnen wir einfach mit der äußeren Funktion, erease. Die Funktion gibt es in drei Varianten, die hier vorliegende ist die 3. Form. "Erases the sequence of characters in the range [first,last)." Die Funktion entfernt also alle ab "first", bis exklusive "end". Die Angaben werden als Iteratoren (beinhaltet grob das "aktuelle" Element und eine Möglichkeit zum nächsten Element zu kommen) vorgenommen.
Im konkreten Fall sind der von remove_if erstellte Iterator und str.end, ein Iterator der auf das Zeichen hinter dem letzten Zeichen von str zeigt (ist also kein gültiges Zeichen!), angegeben. Mit str.end weiß man immer, wann die kompletten Zeichenkette durchlaufen ist.

remove_if nimmt zwei Iteratoren (Anfang und Ende) und eine Bedingung an. Die Funktion entfernt alle Zeichen, die bei der angegebenen Bedingung "true" liefern, in unserem Fall ist das immer bei runden Klammern der Fall. Dies geschieht, indem die Zeichen, die behalten werden sollen, nach vorne geschoben werden. Die Größe des Containers - hier Zeichenkette - wird aber nicht verändert. Wenn also n Zeichen am Anfang da waren und m entfernt wurden, so sind es danach immer noch n Zeichen vorhanden. Allerdings sind die ersten (n-m) Zeichen, die, die behalten werden sollen. Wenn ich das richtig verstehe, so sind die letzten m-Zeichen undefiniert.
Der von der Funktion zurückgegebene Iterator zeigt auf das erste Zeichen, welches weg kann. Im konkreten Fall könnte es so aussehen (ich hoffe, dass verwirrt jetzt nicht):

"STL und Strings" ist gewünscht und "s)" ist zu viel da und der Iterator zeigt auf das s von "s)".


Was ist also die Kombination?
Zuerst werden die gewollten Zeichen nach vorne geholt und ein Iterator wird zurück gegeben, der auf den Anfang des Restes zeigt, welches entfernt werden soll. Danach wird dieser Rest entfernt.
Ich hatte dich so verstanden, dass alles entfernt wird, was in "str.end()" steht, aber das ist nicht korrekt. "str.end()" zeigt immer auf das Element hinter dem letzten Element. Stattdessen wird alles entfernt ab dem ersten überflüssigen Rest, der noch in str ist. Denn remove_if hat es nicht real entfernt. Dies kann man auch leicht testen, indem erease entfernt wird, also nur noch

ausgeführt wird. Das Ergebnis ist dann in meinem Fall mit Gnu C++:

str.end() zeigt dann immer noch auf ein Zeichen hinter ")" und str.begin() zeigt auf das erste "S", den Anfang. Iteratoren umfassen nie Bereiche, sondern immer nur einzelne Elemente.

Ich hoffe, das war verständlich.

Super, ich habe es in einer Stunde geschafft aber gerade nochmal top erklärt, vielen Dank! Das mit dem str.end dachte ich zuerst auch :D
Übrigens ich glaube statt dem zweiten " s " meinst du " ( " also Tippfehler, ansonsten alles richtig und verständlich!

edit: Nein, meinte genau das, deine Überlegung scheint aber logisch zu sein. Heißt das aber dass die andere Klammer noch weiter hinten ist und nicht angezeigt wird weil der String seine Länge beibehält?

Bei mir steht dann in der Tat "STL und Stringss)" und nicht "STL und Strings()" in der Zeichenkette, nach remove_if. Die Hilfe zu der Funktion sagt nur, dass die Zeichen, die nicht entfernt werden sollen, nach vorne wandern. Was mit dem Rest geschieht, wird nicht gesagt, weshalb ich auch von "undefiniert" ausgehe. Und da die Zeichen sowieso entfernt werden sollen ist es überflüssig, diese extra zu merken und dann hinten anzustellen. Das Doppelte s ist dann einfach eine Folge davon, dass das "s" eins nach vorne gezogen wird, das Original aber nie überschrieben, da es in dem Bereich liegt, welcher entfernt werden soll.
Den Vorgang im Speicher könnte man sich so vorstellen:

Das ganze habe ich mal etwas vereinfacht.

Oder meinst du etwas anderes?

Nein, meinte genau das, deine Überlegung scheint aber logisch zu sein. Heißt das aber dass die andere Klammer noch weiter hinten ist und nicht angezeigt wird weil der String seine Länge beibehält?


Nun muss ich bei einer andere Aufgabe einen int mithilfe von Bitoperationen shiften. Ich versuche das erste Bit ans Ende zu shiften, aber irgendetwas ist an diesem Befehl falsch..ich weiß nicht was in sizeof( .. ) rein muss, irgendeine Idee? Vielen Dank schonmal!


std::vector<int> v{ 0, 0, 0, 1 };

std::transform(v.begin(), v.end(), v.begin(), (v.begin() >>= v.sizeof() * 8));

Die Runde-Klammer-Auf ist bei GNU-C++ komplett verloren.
Ich weiß nicht, wie weit dein Hintergrundwissen ist. Alle Informationen werden im (Arbeits-)Speicher abgelegt, so auch die Zeichenkette. Der Speicher besteht aus einzelnen, ein-Byte-großen Zellen, jede Zelle kann über eine Zahl direkt angesprochen werden. Bei 32 Bit gibt es 2^32 (2 hoch 32) solcher Zellen, also von 0 bis 4.294.967.295. Bei 64 Bit gibt es 2^64, also von 0 bis ((2^64)-1).
Jedes Element der Zeichenkette, also jeder Buchstabe, steht in einer eigenen Zellen. Wird nun das erste S nach ( verschoben - eigentlich wird es im konkreten Fall kopiert - wird der Inhalt der Speicherzelle mit ( mit S überschrieben. Was vorher enthalten war, also die Klammer, ist verloren.
Die Runde-Klammer-Zu bleibt nach remove_if erhalten. Was nach dem erease ist, kann ich dir nicht sagen. Ich vermute, dass die Klammer noch erhalten ist, das doppelte s aber ersetzt wurde durch eine \0 (nicht das Zeichen 0, sondern das Byte hat den Wert 0 mit der Bedeutung "Null character", was oft für das Ende von Zeichenketten verwendet wird). Ich könnte es herausfinden, das ist aber etwas aufwändiger und die Information nicht sonderlich sinnvoll.

Es gibt Spezifikationen für die Sprachen und Standardbibliotheken. Dort ist festgelegt, wie groß die einzelnen Elemente sind, welche Aufgaben die einzelnen Funktionen haben und so weiter. Die Dokumente sind dann groß, das von C++ (Vorversion der aktuellen Fassung, Datum 2012) umfasst z.B. mehr als 1300 Seiten.

Alles, was nicht definiert wird oder ausgewiesen ist als "implementation-defined" kann der Entwickler des konkreten Compilers entscheiden.
Und ich denke, beides, was mit dem zu entfernenden Teil von remove_if, als auch mit dem Entfernten Teil von erease ist, fällt in diese Kategorie. Nur weil es in meiner aktuell genutzten GNU-C++-Version so ist, heißt das nicht, dass alle anderen das auch so machen. Zudem könnte GNU das auch ändern, wenn für die eine andere Variante plötzlich besser ist.
Es könnte auch sein, dass bei DevC++ nach remove_if nicht "STL und Stringss)" sondern "STL und Strings()" oder auch "STL und Strings\0\0" im Speicher steht.

Ich nehme an, das ("k.A., ist auch nicht wichtig") klingt für dich jetzt vllt. blöd, zumindest wäre mir das früher so gegangen, aber eigentlich braucht man solches wissen nur, wenn man quasi am Standard vorbei arbeiten möchte. Ziel ist es ja eigentlich sich von der konkreten Implementierung zu lösen und auf einem höheren, abstrakteren Level (z.B. Zeichenketten, statt Speicherzellen) Level zu arbeiten. Und in solchen Fällen ist entscheidend, was die eigentliche Aufgabe der Funktion macht und das ist bei allem gleich. Was dann konkret im Müll ist, ist nicht wichtig.


Deinen zweiten Teil verstehe ich leider nicht ganz. Wenn ich Zahlen mittels arithmetischem Shift verschieben möchte, dann mache ich das z.B. so:

Wenn du das mit jedem Element eines Vektors machen möchtest, inkl. Nutzung von transform, dann verstehe ich deinen Ansatz nicht. Nach der Beschreibung auf dieser Seite ist das letzte beispielsweise Funktion, welches die Veränderung angibt. Auf der Seite gibt es unten übrigens auch ein Beispiel mit zwei verschiedenen Transformationen.

Das normale sizeof gibt die Größe eines Elementes an, das wird allerdings noch vor der Übersetzung in ein Programm ersetzt. Soweit ich weiß besitzt std::vektor keine sizeof-Funktion.
Beispiel:

ergibt bei mir

Vielen vielen Dank für dieses ausführliche Antwort, die hat mir sehr weitergeholfen!!

Zun zweiten:

Die Aufgabe besagt dass man einen Vektor hat der Werte haben kann die entweder 1 oder -1 sind. Nun soll mittels transform jeder Wert -1 mit einer 1 und jede 1 mit einer 0 überschieben werden. Dazu dürfen wir ausschließlich bitoperationen benutzen. Das soll kein ganzes Programm seinsondern ich muss nur kurz 1 oder 2 Zeilen angeben, wie das zu lösen wäre.

Meine Idee war, dass das Most Significant Byte von -1 1 ist und von 1 0. Diese erste Zahl nehm ich also und shifte sie einfach nach ganz rechts, von links wird mit Nullen aufgefüllt, schon habe ich meine gewünschte Zahl. Deshalb der Ausdruck. Irgendeine Idee dazu?

EDIT: Lösung

Quellcode

1. int rightshift(const unsigned& i){ return (i >> 1) & 1;}//... std::transform(v.begin(), v.end(), v.begin(), rightshift);

Hallo! Übe mich jetzt an Java aber bin unsicher ob das was ich tue Sinn macht oder nicht..dachte mir vllt ist hier der ein oder andere Programmiercrack.

1. Ich will eine Methode schreiben, die mir die Elemente einer Liste dupliziert. Sprich aus abc wird aabbcc.
Dabei schreibe ich einmal eine iterative und einmal eine rekusive Version.


2. Die zweite Methode soll jedes Tripel der Liste zyklisch permutieren lassen. Wenn am Ende kein volles Tripel da ist, soll es nicht verändert werden.
Aus a b c d e f g h i j k wird also c a b f d e i g h j k.


Folgenden Code habe ich:




Die andere Klasse:



Ich hoffe jemand kann mir sagen ob das so richtig ist..

EDIT: Wow, das sieht hier richtig unübersichtlich aus, hab versucht es mit ein paar Leerstellen und Enter ein bisschen besser darzustellen, aber irgendwie bleibt das in einer Zeile...

Moin,

ich hab jetzt leider nicht die große Zeit, mir das Geschwurbel da durchzulesen (Kommentare (!) und Einrückungen helfen, auch wenn letztere ja wohl wegen dem Kopieren fehlen), aber ich will dir einfach mal noch ne Idee im logischen Bereich geben, wie ich rangehen würde, nachdem ich deine Aufgabenstellung gelesen habe. Muss dazu aber sagen, dass mein letztes Mal Java programmieren auch bald 10 Jahre her ist, also kann es durchaus neuere Tricks und/oder bessere Methoden geben :D

1. openbook.rheinwerk-verlag.de/j…a6292a2df6e31df7304ee0c9b
Erstes Beispiel der ".add"-Befehl. Länge der Liste rausfinden, dann mit Schleife durchgehen und mit add das gleiche Element an die Stelle danach direkt einfügen. Dann brauchst du nur 1 Schleife.

2. Ähnliches Vorgehen. Frage die Länge der gesamten Liste ab und mit modulo3 wie viele Tripple du hast. Das dient dir dann als Schleifenwert.
Danach gehst du ins ((Schleifenzahl+1)*3-1)te Element, ziehst dir den Wert raus, löschst dieses Element und fügst das Element an die ((Schleifenzahl+1)*3-3)te Stelle wieder ein.
(Für den ersten Durchgang dann also Schleifenzahl=0, nehme 2. Element [code=c], lösche es und füge es an die 0.te Stelle vor [a b] ein -> [cab]).
Dann brauchst du auch hier keine großen Abfragen oder extra Listen/Schleifen.

Solange dein Code funktioniert, wird der aber auch richtig sein. Und ich denke auf dem Level sind Zeitersparnisse dann auch noch nicht alles.
Hoffe das konnte irgendwie leicht weiterhelfen, mehr ist heute leider net drin...

Gruss

Ja, irgendwie kommt da sowas komisches raus.. Danke!

Zu 1: ich habe da nur eine Schleife.

Zu 2: Das ist eine gute Idee! Wenn meins nicht klappt werdde ich das so machen ist wohl auch eleganter als immer p.next.next.next usw. :D

Ich habe mir deinen Code mal angesehen. Aber vorweg ein paar allgemeine Dinge als Hinweise/Empfehlungen.

• Der Vorteil an Programmcode ist, dass man ihn auch gleich testen kann. Es ist auch gut dies zu tun. Versuch und Irrtum sind gute Lehrmeister.
  
• Bei einem Programmierproblem ist es immer gut ein lauffähiges Minimalbeispiel zu liefern. Das minimiert den Aufwand für Personen, die dir helfen wollen. Wenn sie allerdings erst einmal Stunden damit zubringen müssen deinen Code zum Laufen zu bekommen, verlieren sie schnell die Lust.
  
• Verwende keine Bezeichner der Standard-Java-Bibliothek. List ist beispielsweise ein Interface in java.util. Das könnte zu Verwirrungen führen, wenn man (an anderer Stelle im Quellcode) annimmt, dass es dieses List ist und nicht deine Klasse. Mir ist klar, dass es eine gern genommene Aufgabe aus der Uni ist, eine List-Klasse zu schreiben und prinzipiell geht es auch. Aber das heißt dennoch nicht, dass es schön ist und könnte dir, früher oder später, auf die Füße fallen.
  
• Gib deinen Klassen eigene toString-Funktionen, dies hilft beim Debuggen immer wieder.
  

So, nun zu deinem Code. Ich habe deinen Code etwas abgeändert. Zuerst habe ich ein "COwn" für deine beiden Klassennamen gepackt - das C steht übrigens für Class, ein Teil meinen Code-Styles. Ferner habe ich COwnList drei neue Funktionen geschenkt: "addItems", "clear" und "toString".
Im Anschluss habe ich eine weitere Klasse, CMain, geschaffen, um den Code ausführen zu können:



Also auf und laufen lassen! Doch oh weh - das Programm wird nicht fertig und konsumiert immer mehr Speicher. Zu diesem Zeitpunkt steht folgendes auf der Konsole:

Also ist es wahrscheinlich, dass etwas in der duplicateEachElementIter-Funktion nicht stimmt. Da wir eine Debug-Ausgabe haben, können wir dies einfach in die Funktion einbauen. Also flugs ein "System.out.println(this);" ans Ende (innerhalb!) der Schleife packen und wieder laufen lassen. Ich gebe nur mal den Anfang der Ausgabe auf der Konsole aus:

Es fällt auf, dass immer wieder Ada hinzugefügt wird. Wenn man sich den Code ansieht, fällt auch auf, wieso. Wir beginnen bei first und fügen danach direkt dahinter ein neues Element mit dem Wert von first ein. Anschließend nehmen wir das Element hinter first und wiederholen den Vorgang damit. Dieses Element ist allerdings das neu eingefügte. Wir wollten allerdings mit dem weiter machen, was ursprünglich hinter first war und nun hinter first.next liegt. Also kurz eine Zeile abgewandelt und nun scheint der Teil zu klappen. Dann können wir nun unsere Debug-Ausgabe wieder entfernen

Nachdem das erste Problem behoben ist, führen wir unserer Programm erneut aus. Doch was ist das, es stürzt ab:

Eine NullPointerException in rotate in Zeile 93. Meine Zeilen 92-94 sehen wie folgt aus:

Was passiert hier? Wir haben eine Oder-Verknüpfung, die ist dann wahr, wenn eines von beiden wahr ist. Zudem bricht die Überprüfung ab, sobald wahr erreicht ist - besser wird es eh nicht. Also nehmen wir an, wir sind bei unserem vorletzten Element angekommen, t.next!=null, aber t.next.next==null. Dann ist die Bedingung erfüllt, wir gehen rein und bei t.next.next.key knallt es.
Also kurz den Fehler behoben und nun läuft das Programm durch:


Doch was ist das? Die rotate-Funktionen liefern zwar das gleiche Ergebnis, aber die Liste wird irgendwie - nunja - kleiner. Und Ada, Bernhard und der nicht mehr vorhandene Charles sind auch nicht umgedreht.
Sehen wir uns einfach rotateTriplesIter am Beispiel von A B C D an. Ändern wir unsere Main und nehmen nur die vier Werte. Zudem lassen wir uns von der Funktion jeden Schleifendurchlauf ausgeben.


Wir sehen, C verschwindet beim ersten Schritt und in Zeile 76 steht "if (p.next.next != null) {".
Bevor wir uns dem Absturz widmen, fangen wir vorne an. Unser Ausgang ist A->B->C->D
Wir beginnen den Schleifendurchlauf mit A und schauen, ob next.next existiert, das ist aktuell C, also alles OK. Nun nehmen wir ein neues Element haben damit temporär 3 Listen (first, p und temp):
first: A->B->C->D
p: A->B->C->D
temp: C->D
Nun ändern wir von B was als nächstes und zwar auf temp.next, also D:
first: A->B->D
p: A->B->D
temp: C->D
Und nun gehen wir zwei Elemente weiter, also :
first: A->B->D
p: D
Das temp existiert nicht mehr, da es innerhalb des if-Blockes war, wir jetzt aber einen neuen Durchlauf der Schleife haben, also außerhalb sind.
Nun testen wir ob p.next.next null ist. Dummerweise ist bereits p.next null und es knallt.

Ich vermute, deine Grundidee ist es, die einzelnen Listenelemente zu vertauschen und nicht deren Inhalt. Da T auch sehr komplex sein kann, ist das eine gute Idee. Doch leider änderst du nur zwei Zeiger, du willst aber zwei Elemente mit je zwei Zeigern - einen eingehenden und einen ausgehenden - ändern. Und deine Prüfung, ob du weiter machen kannst oder am Ende bist, funktioniert leider auch nicht in jedem Fall.
Ich mache an dieser Stelle mal nicht weiter. Du hattest ja schon angedeutet, dass du den Ansatz von Totenkopfgitarrist weiter verfolgen willst.

Zum Schluss noch ein paar Anmerkungen. Einige sind nur, damit keine Fragen über meinen Code aufkommen.

• In Java und anderen Sprachen werden gerne Iteratoren verwendet. Dann ist es nicht notwendig manuell über die Elemente zu laufen, sondern kann sich einfach die Elemente nacheinander geben lassen. In diesem Fall ist das wohl zu viel des Guten, aber ich wollte es für die Zukunft erwähnen.
  
• Es hat keine besondere Bedeutung, dass ich while-Schleifen verwende. Das ist einfach ein Relikt aus alten Tagen defekter Compiler.
  
• Bei Eclipse und evtl. anderen IDEs mit integrierter Konsole ist das "System.in.read();" samt Umbau überflüssig. Auch wenn man direkt auf der Konsole arbeitet ist das überflüssig. Das ist ein Relikt aus meiner Visual Studio-Zeit. Hmm, ziemlich viele Relikte .