| 23.01.2016, 17:33 |
Auf diesen Beitrag antworten » |
| Lars |
einfach verkettete Listen in C -Programmhilfe
So, ich hab mich hier jetzt auch mal registriert! 
Aber nun zum eig. Thema. Die Aufgabe wie immer im Anhang. Bitte erstmal keine Komplettlösung, ich häng gerade nur an einer Stelle.
Bin gerade beim 2. Stichpunkt.
Mein Code sieht zurzeit so aus:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
|
#include <stdio.h>
#include <stdlib.h>
#include "readline.h"
#include <time.h>
typedef struct person{
char nameperson[20];
char Abteilung;
int TelNr;
}Person;
int neuePerson()
{
Person* p=(Person*)malloc(sizeof(Person));
readLine(p->nameperson, 20);
srand (time(NULL));
p->TelNr=rand()%100;
p->Abteilung = rand() % 3 + 65;
printf("%s, %c, %i\n",p->nameperson,p->Abteilung,p->TelNr); //zur Überprüfung, ob das ganze bis jetzt funktioniert
};
int main()
{
printf("Bitte im Folgenden 10 Mitarbeiternamen (jeweils mit Enter) eingeben...\n");
for(int i=0; i<10; i++)neuePerson();
}
|
|
Das Programm funktioniert bis dahin (ist ja auch nicht viel), aber da ich 10 Namen speichern muss, weiß ich gerade nicht wie ich realisieren kann, dass beim Neuausführen der Schleife nicht die alten Werte überschrieben werden. Ich brauch ja theoretisch immer nen anderen Pointer den ich zurückgeben muss, auf das jeweilige struct mit den gespeicherten Daten oder?
Hilfe wäre ganz lieb 
. |
| |
| |
|
| 23.01.2016, 17:39 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Dann willkommen an Bo(a)rd.
Bei einer verketteten Liste braucht die Person noch einen Zeiger auf die nächste Person.
Und dann folgst du so lange den Zeigern, bis du am Ende bist, um dort eine Person anzuhängen.
Und wenn du nichts zurückgeben willst, deklarier die Funktion als void. |
| 23.01.2016, 17:46 |
Auf diesen Beitrag antworten » |
| Lars |
Ok, ich versuch mich mal und schau mal, ob was bei rumkommt. Ansonsten meld ich mich hier wieder.
Funktion ist jetzt als void deklariert 
|
| 23.01.2016, 19:07 |
Auf diesen Beitrag antworten » |
| Lars |
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
|
#include <stdio.h>
#include <stdlib.h>
#include "readline.h"
#include <time.h>
typedef struct person{
char nameperson[20];
char Abteilung;
int TelNr;
struct person *next;
struct person *anfang;
}Person;
struct person *next = NULL;
struct person *anfang = NULL;
int neuePerson()
{
struct person* zeiger;
if(anfang==NULL){
anfang=(Person*)malloc(sizeof(struct person));
readLine(anfang->nameperson, 20);
srand (time(NULL));
anfang->TelNr=rand()%100;
anfang->Abteilung = rand() % 3 + 65;
anfang->next=NULL;
}
else{
zeiger=anfang;
while(zeiger->next != NULL) zeiger=zeiger->next;
if(zeiger->next == NULL){
zeiger->next=(Person*)malloc(sizeof(struct person));
zeiger=zeiger->next;
readLine(zeiger->nameperson, 20);
srand (time(NULL));
zeiger->TelNr=rand()%100;
zeiger->Abteilung = rand() % 3 + 65;
zeiger->next=NULL;
}
}
}
void neuesListenElement()
{
}
void listeAusgeben()
{
}
int main()
{
printf("Bitte im Folgenden 10 Mitarbeiternamen (jeweils mit Enter) eingeben...\n");
for(int i=0; i<10; i++)neuePerson();
}
|
|
Ist das so richtig, ich glaube nicht x). |
| Anzeige |
| |
|
| 23.01.2016, 19:19 |
Auf diesen Beitrag antworten » |
| Lars |
Die uns gegebene readLine Funktion sieht so aus:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
|
/* Diese Datei muss einfach nur im selben Verzeichnis liegen wie die Datei, die
readLine benutzt. Dort muss dann die Funktion mit
#include "readline.h"
eingebunden werden. Am Compileraufruf aendert sich nichts. */
/* Nutzung der Funktion:
strbuffer muss ein Pointer auf einen genuegend grossen char-Array sein
buffersize muss die Groesse dieses char-Arrays angeben.
Bei Aufruf von readLine wird dann vom Terminal eine Zeichenkette (inklusive Leerzeichen)
eingelesen, bis der Nutzer Enter drueckt oder bis die maximale Arraylaenge erreicht ist.
Das "Enter" wird nicht in den String mitgespeichert. */
#ifndef READLINE_H
#define READLINE_H
#include <stdio.h>
void readLine( char* strbuffer, unsigned int buffersize )
{
char format[30] = "";
sprintf( format, "%%%u[^\n]%%*c", buffersize-1 );
scanf( format, strbuffer );
}
#endif //#ifndef READLINE_H
|
|
|
| 23.01.2016, 19:55 |
Auf diesen Beitrag antworten » |
| Lars |
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
|
#include <stdio.h>
#include <stdlib.h>
#include "readline.h"
#include <time.h>
typedef struct person{
char nameperson[20];
char Abteilung;
int TelNr;
struct person *next;
struct person *anfang;
}Person;
struct person *next = NULL;
struct person *anfang = NULL;
int neuePerson(void)
{
struct person* zeiger;
if(anfang==NULL){
anfang=(Person*)malloc(sizeof(struct person));
readLine(anfang->nameperson, 20);
srand (time(NULL));
anfang->TelNr=rand()%100;
anfang->Abteilung = rand() % 3 + 65;
anfang->next=NULL;
}
else{
zeiger=anfang;
while(zeiger->next != NULL) zeiger=zeiger->next;
if(zeiger->next == NULL){
zeiger->next=(Person*)malloc(sizeof(struct person));
zeiger=zeiger->next;
readLine(zeiger->nameperson, 20);
srand (time(NULL));
zeiger->TelNr=rand()%100;
zeiger->Abteilung = rand() % 3 + 65;
zeiger->next=NULL;
}
}
}
void neuesListenElement()
{
}
void listeAusgeben(void)
{
struct person* zeiger = anfang;
printf("Personalpool Firma:\n");
while(zeiger != NULL){
printf("name: %s abteilung: %i telNr: %i\n",zeiger->nameperson, zeiger->Abteilung, zeiger->TelNr);
zeiger=zeiger->next;
}
printf("Personalpool ferig -- Anzahl Mitarbeiter: 10\n");
}
int main()
{
printf("Bitte im Folgenden 10 Mitarbeiternamen (jeweils mit Enter) eingeben...\n");
for(int i=0; i<10; i++)neuePerson();
listeAusgeben();
}
|
|
Sooo, das sieht doch schonmal gut aus. Fehlt noch das Sortieren, kann sein, dass du mir da nen bisschen helfen musst. Aber ich versuche mich erst
. |
| 23.01.2016, 20:27 |
Auf diesen Beitrag antworten » |
| Lars |
Ok, ich require dann doch nochmal help hier. Ich bekomm das nicht hin, dass ich die Elemente der Liste jetzt in eine andere Liste nochmal ordne. Mir fehlt irgendwie der Ansatz...
Mann, ich war sooo naaah dran 
.
Edit: Nächstes mal nutz ich die Edit-Funktion, sorry 
. |
| 23.01.2016, 20:28 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Dann spoiler ich mal nicht zu viel: ich würde es mit Bubblesort machen.
Edit: dank Karlito habe ich ein Script, das mich über neue Beiträge informiert. Edits werden da aber nicht erkannt. Insofern ist ein neuer Beitrag schon ok. |
| 23.01.2016, 20:39 |
Auf diesen Beitrag antworten » |
| Lars |
Ok! Dann dann kann ich ja munter weiterposten
. Ich kannte Bubblesort bis jetzt noch gar nicht, hab mich gerade mal informiert. Ist eine geniale Funktion, bringt mir leider in dem Falle nichts. Hab mal eine Datei mit der Beispielausgabe, die uns gegeben wurde, hochgeladen. Da soll ja eine zweite Liste nochmal ausgegeben werden, wo dann jeweils einmal der Pool ist und dann eben die sortierte Liste, während der Pool eben immer kleiner wird und die Liste dann die nach den Abteilungen geordneten Personen aufweist. |
| 23.01.2016, 20:48 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Im Allgemeinen gibt es besseres, geht nur meines Wissens nicht mit verketteten Listen.
Erstelle dir eine zweite Liste und füge dann per InsertionSort dorthin ein. |
| 23.01.2016, 21:03 |
Auf diesen Beitrag antworten » |
| Lars |
Ok, ich probiere mich! |
| 24.01.2016, 11:54 |
Auf diesen Beitrag antworten » |
| Lars |
Ok, übrigens sollen wir keine Algorithmen nutzen, jemand hat im Forum nachgefragt:
Mein jetziger Code:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
|
#include <stdio.h>
#include <stdlib.h>
#include "readline.h"
#include <time.h>
typedef struct person{
char nameperson[20];
char Abteilung;
int TelNr;
struct person *next;
struct person *anfang;
}Person;
struct person *next = NULL;
struct person *anfang = NULL;
typedef struct sortiert{
char nameperson[20];
char Abteilung;
int TelNr;
struct sortiert *next;
struct sortiert *anfang;
}Sortiert;
struct sortiert *snext = NULL;
struct sortiert *sanfang = NULL;
int neuePerson(void)
{
struct person* zeiger;
if(anfang==NULL){
anfang=(Person*)malloc(sizeof(struct person));
readLine(anfang->nameperson, 20);
srand (time(NULL));
anfang->TelNr=rand()%100;
anfang->Abteilung = rand() % 3 + 65;
anfang->next=NULL;
}
else{
zeiger=anfang;
while(zeiger->next != NULL) zeiger=zeiger->next;
if(zeiger->next == NULL){
zeiger->next=(Person*)malloc(sizeof(struct person));
zeiger=zeiger->next;
readLine(zeiger->nameperson, 20);
srand (time(NULL));
zeiger->TelNr=rand()%100;
zeiger->Abteilung = rand() % 3 + 65;
zeiger->next=NULL;
}
}
}
void neuesListenElement()
{
struct person* zeiger;
struct person* zeiger1;
struct sortiert* zeiger2;
printf("=== sortieren... ===\nnoch im allgemeinen Pool: \n");
if(sanfang==NULL){
sanfang=(Sortiert*)malloc(sizeof(struct sortiert));
if(anfang!=NULL){
if((anfang->Abteilung)=='A'){
sanfang->Abteilung=anfang->Abteilung; sanfang->TelNr=anfang->TelNr; free(anfang); anfang=zeiger;}
else{
zeiger=anfang;
while(zeiger->next!=NULL){
zeiger1=zeiger->next;
if(zeiger1->Abteilung=='A'){
sanfang->Abteilung=zeiger1->Abteilung;
sanfang->TelNr=zeiger1->TelNr;
zeiger->next=zeiger1->next;
free(zeiger1);
break;
}
zeiger=zeiger1;
}
}
}
}
else{
zeiger2=sanfang;
while(zeiger2->next!=NULL){zeiger2=zeiger2->next;
if(zeiger2->next==NULL){
zeiger2->next=(Sortiert*)malloc(sizeof(struct sortiert));
zeiger2=zeiger2->next;
zeiger2->next=NULL;
}
}
}
printf("\n \n [...] \n \n ");
}
void listeAusgeben(void)
{
struct person* zeiger = anfang;
printf("Personalpool Firma:\n");
while(zeiger != NULL){
printf("name: %s abteilung: %c telNr: %i\n",zeiger->nameperson, zeiger->Abteilung, zeiger->TelNr);
zeiger=zeiger->next;
}
printf("Personalpool ferig -- Anzahl Mitarbeiter: 10\n");
}
void listeAusgeben2(void)
{
struct sortiert* zeiger3 = sanfang;
printf("sortiert:\n");
while(zeiger3!=NULL){
printf("name: %s abteilung: %c telNr: %i\n",zeiger3->nameperson, zeiger3->Abteilung, zeiger3->TelNr),
zeiger3=zeiger3->next;
}
}
int main()
{
printf("Bitte im Folgenden 10 Mitarbeiternamen (jeweils mit Enter) eingeben...\n");
for(int i=0; i<10; i++)neuePerson();
listeAusgeben();
for(int s=0; s<10; s++){
neuesListenElement();listeAusgeben();listeAusgeben2();}
}
|
|
Sooo, Prinzipiell durchsucht wird jetzt die Liste nach einem 'A', dann werden die Werte in das erste Element der 2. Liste übernommen und der Speicher der ersten Liste freigegeben. Nun muss ich das noch vervollständigen, dass es, falls der zweite Listenanfang nicht mehr auf NULL zeigt auch nochmal nach den A's sucht und dann, wenn kein A mehr existiert jeweils nach den B's und C's. Bloß ist das so umständlich, dass ich schon wieder am Rad drehe. Ich steig langsam nicht mehr durch, wer hat sich denn bitte diese Aufgabe ausgedacht 
. Ok, außerdem kann ich sanfang->nameperson=anfang->nameperson nicht machen, dann spuckt er mir aus "invalid array assignment, wahrscheinlich weil ich nicht einfach so das array gleichsetzen kann. Wie kann man das einfach umschreiben? Mir fällt grad nichts mehr ein, seit gestern häng ich an dieser Aufgabe, Konzentration schwächelt imo.
|
| 24.01.2016, 12:57 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Du brauchst keine eigene struct für die sortierten Einträge, das sind weiterhin Personen.
Du musst beim Sortieren noch nicht mal neue Personen erstellen, du kannst sie aus der alten Liste entfernen und in die neue einbauen.
Du musst beim Einfügen 6 Fälle unterscheiden:
1. die sortierte Liste ist leer.
2. Du bist bei der Suche, wo du einfügen willst vor dem ersten Listeneintrag
2.1 Der neue Eintrag muss ganz an den Anfang
2.2 Der neue Eintrag gehört dahinter
3. Du bist irgendwo in der Mitte der Liste
3.1 Der neue Eintrag gehört da rein, wo du gerade bist
3.2 Du musst weiter nach hinten laufen
4. Du bist bereits hinter dem letzten Eintrag
Du musst 2 Knoten kennen: den vor und nach der aktuellen Position (nur so kannst du einfügen, ohne die Listenstruktur kaputtzumachen).
Ein if((anfang->Abteilung)=='A') brauchst du nicht, prüfe einfach if (zeiger1->Abteilung > zeiger2->Abteilung), wenn du wissen willst, wer von beiden größer ist.
Und das sturktuierte Vorgehen nach einem festen Schema ist die Definition eines Algorithmus. Ohne dessen Verwendung lässt sich die Aufgabe nicht lösen. |
| 24.01.2016, 17:47 |
Auf diesen Beitrag antworten » |
| Lars |
RE: einfach verkettete Listen in C -Programmhilfe
So, bin gerade wiedergekommen, noch 6h an Zeit das zu Ende zu schreiben, Zeit für den Endspurt.
Ich versteh irgendwie deine ersten 3 Zeile nicht.
Ich brauche also das gesamte struct sortieren nicht? Und ich soll keine neuen personen erstellen sondern einfach die, die ich entferne in die neue Liste übertragen?
Das klingt irgendwie gerade zu abstrakt für mich 
.
Wir hatten Listen erst letzte Woche und das ist bis jetzt das verwirrendste Thema, ich musste mir auch ne Skizze für das Prog. malen, weil ich sonst nicht durchgestiegen bin 
. |
| 24.01.2016, 17:50 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
| code: |
1:
2:
3:
4:
5:
6:
7:
|
typedef struct sortiert{
char nameperson[20];
char Abteilung;
int TelNr;
struct sortiert *next;
struct sortiert *anfang;
}Sortiert; |
|
Das ist kein Unterschied zu Person. also brauchst du diese struct auch nicht. Alles was du damit machen kannst, geht auch mit Person.
Du hast zwei Listen. Nacheinander nimmst du die Personen aus der einen Liste raus und tust sie direkt in die andere rein. Dafür brauchst du kein malloc.
Ach ja: das mal sich bei den Zeigern Skizzen macht um nicht durcheinander zu kommen, ist ganz normal. Mache ich auch manchmal noch. |
| 24.01.2016, 17:53 |
Auf diesen Beitrag antworten » |
| Lars |
Ah ok, das klingt plausibel. Mal schauen, ob ich jetzt weiter komme.
Unser Tutor meinte auch, dass Skizzen dafür sehr hilfreich sind, man wird ja echt teilweise verrückt, wenn man das alles im Kopf durchgeht
. |
| 24.01.2016, 20:34 |
Auf diesen Beitrag antworten » |
| Lars |
*seufz*
Ich bin ein hoffungsloser Fall
.
Das mit dem Einsetzen der einen Listenelemente in die andere Liste klingt ziemlich simpel und ist es wahrscheinlich auch, aber ich krieg's einfach nicht auf die Reihe.
Mir ist das recht unangenehm, aber wenn du gerade nichts zutun hast, kann du mir zeigen, wie genau ich das machen müsste?
Ich denke dann kann ich's wenigstens nachvollziehen...
Ich probier trotzdem nochmal rum, wobei ich nicht glaube, dass das heute nochmal was wird. |
| 24.01.2016, 20:45 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Heute habe ich keine Lust mehr, das ist keine Sache von 5 Minuten. Ich kann mich morgen mal dransetzen. |
| 24.01.2016, 21:00 |
Auf diesen Beitrag antworten » |
| Lars |
Ok, danke, dann kann ich das hoffentlich wenigstens nachvollziehen.
Ich schau mal wie weit ich noch komme heute. |
| 25.01.2016, 07:23 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Sortieren klappt, die Ausgabe darfst du selbst verschönen. Sonst verpasse ich noch den Bus.
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
|
#include <stdio.h>
#include <stdlib.h>
#include "readline.h"
#include <time.h>
typedef struct person{
char nameperson[20];
char Abteilung;
int TelNr;
struct person *next;
}Person;
struct person *anfang = NULL;
struct person *sanfang = NULL;
void neuePerson()
{
struct person* zeiger;
if(anfang==NULL){
anfang=(Person*)malloc(sizeof(struct person));
readLine(anfang->nameperson, 20);
anfang->TelNr=rand()%100;
anfang->Abteilung = rand() % 3 + 65;
anfang->next=NULL;
}
else{
zeiger=anfang;
while(zeiger->next != NULL) zeiger=zeiger->next;
if(zeiger->next == NULL){
zeiger->next=(Person*)malloc(sizeof(struct person));
zeiger=zeiger->next;
readLine(zeiger->nameperson, 20);
zeiger->TelNr=rand()%100;
zeiger->Abteilung = rand() % 3 + 65;
zeiger->next=NULL;
}
}
}
void listeAusgeben(Person* p)
{
struct person* zeiger = p;
int mitarbeiter = 0;
printf("Personalpool Firma:\n");
while(zeiger != NULL){
printf("name: %s abteilung: %c telNr: %i\n",zeiger->nameperson, zeiger->Abteilung, zeiger->TelNr);
zeiger=zeiger->next;
mitarbeiter++;
}
printf("Personalpool ferig -- Anzahl Mitarbeiter: %d\n", mitarbeiter);
}
int sortieren() {
if (anfang == NULL) return 0; //nichts mehr zu machen
//beim Probeablauf wird immer die letzte Person entfernt
Person* letzte = anfang;
Person* vorletzte = NULL;
while (letzte->next != NULL) {
vorletzte = letzte;
letzte = letzte->next;
}
if (vorletzte != NULL) vorletzte->next = NULL; //entferne letzten Eintrag aus unsortierter Liste
if (letzte == anfang) anfang = NULL;
//Hier kommt das Einfügen in die sortierte Liste
if (sanfang == NULL) sanfang = letzte; //Fall 1: leere Liste
else {
if (letzte->Abteilung < sanfang->Abteilung) { //Fall 2.1
letzte->next = sanfang;
sanfang = letzte;
}
else { //Fall 2.2
Person* pos = sanfang;
int eingefuegt = 0;
while (pos->next != NULL) {
if (letzte->Abteilung < pos->next->Abteilung) { //Fall 3.1
letzte->next = pos->next;
pos->next = letzte;
eingefuegt = 1;
break;
}
pos = pos->next;
}
if (!eingefuegt) { //Fall 4
pos->next = letzte;
}
}
}
return 1; //weiter sortieren
}
int main()
{
srand (time(NULL)); //srand gehört dahin, nicht nach oben - dann kann man die Eingabe auch von Datei einlesen und rand() liefert nicht immer das selbe
printf("Bitte im Folgenden 10 Mitarbeiternamen (jeweils mit Enter) eingeben...\n");
for(int i=0; i<10; i++)neuePerson();
listeAusgeben(anfang);
while (sortieren()) {
printf("==Pool==\n");
listeAusgeben(anfang);
printf("==sortiert==\n");
listeAusgeben(sanfang);
printf("\n");
}
} |
|
|
| 25.01.2016, 17:51 |
Auf diesen Beitrag antworten » |
| Lars |
Oh mann, ich hoffe du hast deinen Bus noch bekommen, dass du dir hier soviel Mühe machst ist ja echt unglaublich.
Ganz großes Danke meinerseits, ich hab's nach langwährendem Studieren nun verstanden. Wenn ich also irgendwann nochmal Listen sortieren muss werde ich's hinbekommen
.
Ich werde mich bemühen die nächste Aufgabe mal alleine zu lösen, mir wird's unangenehm, wenn ich dich immer fragen muss ^^. |
| 25.01.2016, 17:53 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Ich kam sogar noch rechtzeitig für einen Sitzplatz. Und der Prof kam dann auch noch zuspät, also alles im grünen Bereich 
|
| 25.01.2016, 18:02 |
Auf diesen Beitrag antworten » |
| Lars |
Ok, dann bin ich ja beruhigt. |
