RSS-Feed

Mathe 3

von Kai um 15:54 am Donnerstag, 11. Februar 2010 in Klausuren, Studium | 0 Kommentare

Heute war der Klausurtermin für “Mathematik für Informatiker”. So aus dem Gedächtnis wurden folgende Aufgaben gestellt. Die Liste ist bestimmt nicht vollständig und kann noch Fehler enthalten, kann aber mit Hilfe der anderen Opfer, die mitgeschrieben haben, komplettiert werden.

Aufgabe 1

a.) Beweisen Sie mit Hilfe der vollständigen Induktion:


b.) Beweisen Sie folgende Aussage mit Hilfe von Kontraposition:

Wenn teilerfremd sind, so sind auch teilerfremd.

c.) Beweisen Sie, dass der Satz: Wenn 3a+2b und 3a-2b sind nicht teilerfremd, dann sind a und b auch nicht teilerfremd, nicht gilt.

Lösung (anzeigen)













Aufgabe 2

a.) Die Wettervorhersage gibt an, dass es mit 40% Wahrscheinlichkeit morgen regnet und mit 60% Wahrscheinlichkeit, dass es nicht regnet. Leider trifft die Vorhersage aber nur mit 80% Wahrscheinlichkeit zu, dass es morgen tatsächlich regnet und mit 90% Wahrscheinlichkeit, dass es nicht regnet

Berechnen Sie die Wahrscheinlichkeit dafür, dass morgen ein Regentag ist.

b.) Adam und Eva waren zum Inlineskaten verabredet, doch leider kam Eva nicht zum vereinbartem Zeitpunkt, weil Sie gehört hat, dass es regnen wird. Als Entschuldigung gibt sie an, dass Sie gehört hat, dass es regnen sollte. Adam ist sich sicher, dass Eva die Wettervorhersage nicht gesehen haben kann.

Wie hoch ist die Wahrscheinlichkeit, dass es geregnet hat?

Aufgabe 3

Ein Prof vergisst jedes zehnte Mal (unabhängig vom vorherigen Mal) seine Unterlagen für die Vorlesung und muss zurücklaufen und sie holen. Bei 15 Vorlesungen:
a.) Wie groß ist die Wahrscheinlichkeit, dass er sie nie vergisst?
b.) Wie groß ist die Wahrscheinlichkeit, dass er sie mindestens zweimal nicht vergisst?

Lösung (anzeigen)


Aufgabe 4

In einer Sportgruppe liegt der Erwartungswert bzgl. der Körpergröße bei 1.8m und die Standardabweichung beträgt 0,1m. Für den Kurs „Turnen“ braucht man eine Größe zwischen 1,5m und 1,7m.

Wieviel Prozent der Studenten nehmen teil?

Lösung (anzeigen)





Es nehmen also 15,74% aller Studenten teil.

Aufgabe 5

Es sind folgende zwei Schätzer T1,T2 gegeben:

a.) Überprüfen Sie die Schätzer auf ihre Erwartungstreue
b.) Überprüfen Sie die Schätzer auf ihre Konsistenz

Aufgabe 6

Die Studenten geben an, dass Sie für das Fach Mathe folgenden Lernaufwand haben:

Studenten 80 100 60 40
Zeitaufwand in Std. [0,5) [5,10) [10,20) [20,40)

a.) Bitte erklären Sie, ob die Zufallsvariable X="Zeitaufwand der Studenten" diskret oder stetig ist. Bitte begründen Sie ihre Antwort. Ohne Begründung gibt es keine Punkte.
b.) Bitte geben Sie die Dichtefunktion an, und gehen Sie davon aus, dass die Studenten nicht länger als 40 Stunden für das Fach aufwenden?
c.) Zeichnen Sie die Verteilungsfunktion
d.) Berechnen Sie den Erwartungswert E(X)
e.) Berechnen Sie die Wahrscheinlichkeit für P(X<18)

Aufgabe 7

a.) Anhand folgender Tabelle soll eine Regressionsgerade mit Hilfe des Satzes der kleinen Quadrate berechnet werden.

Jahr nach 2000 2 4 6 8
Durchschnittsverbrauch an Kraftstoff in Liter/100km 8,5 8,2 7,9 8,0

b.) Berechnen Sie, ausgehend von einer linearen Abhängigkeit,nach wie viel Jahren nach dem Jahr 2000 der Durchschnittsverbrauch bei 5 Litern/100km liegen wird

Lösung (anzeigen)

















Onlinetest Python

von Kai um 20:37 am Montag, 11. Januar 2010 in Klausuren, Programmiersprachen, Studium | 0 Kommentare

Heute war es wieder mal soweit: Onlinetest. Dieses mal in Python. Nachdem ich erfolgreich meine Maschine (iMac mit Debian, Windowmanager war glaub ich FVWM) zweimal abgeschossen hatte, bin ich in der vorgegebenen Zeit von 90 Minuten knapp fertig geworden. Eigentlich sind die gestellten Aufgaben in den bisherigen Onlinetests, die ich so mitgeschrieben habe, nicht extrem schwer, trotzdem finde ich es aber schwierig auf Kommando kreativen (und möglichst cleveren) Code zu schreiben.

Es sind eben diese typischen Prüfungssituationen bei denen man unter erschwerten Bedingungen klaren Kopf behalten muss ;-)
Das waren die Aufgaben:

Aufgabe 1:

Man soll von der Standardeingabe eine Zeile einlesen und unnötige Leerzeichen entfernen. Außerdem soll jedes Wort mit einem großen Anfangsbuchstaben in Großbuchstaben umgewandelt wieder ausgegeben werden.

# a1.py
while True:
    line = raw_input()
    line = line.split()
    for word in line:
        if(str.isupper(word[0])):
            print str.upper(word),
        else:
            print word,
    print # Zeilenumbruch für schönere Ausgabe

Aufgabe 2:

Die zweite Aufgabe bestand darin, eine Datei belegung.dat einzulesen, die folgendes Format hatte: <VL-Nr>; <matrikelNr>; <VL-Name>; <VL-Typ>.
Danach sollte die so eingelesene Datei in folgendem Format in eine Datei ausgabe.dat geschrieben werden:
<VL-Nr>,<AnzahlBelegungen>, <VL-Name> <VL-Typ>
Momentan sind in der Ausgabe noch doppelte Einträge drin, das müsste noch geändert werden.

# a2.py
dict = {}
belegung = []

input = open('belegung.dat','r')
for line in input:
    line = line.split(';')
    belegung.append(line)

input.close()

for line in belegung:
    if dict.has_key(line[0]):
        dict[line[0]] += 1
    else:
        dict[line[0]] = 1

ausgabe = file('ausgabe.dat','w')

for nummer, anzahl in dict.iteritems():
    for line in belegung:
        tmp = ""
        if nummer==line[0]:
            try:
                tmp = str(nummer) + ',' + str(anzahl) + ',' + line[2] + '\n'
                ausgabe.write(tmp)
            except:
                pass

ausgabe.close()

Aufgabe 3:

Die dritte Aufgabe bestand darin, einen “sprach-begabten” Taschenrechner zu programmieren, der beim Aufruf des Programms Argumente wie “17 plus 4 minus 3 gleich” übernimmt und korrekt auswertet. Es soll bewusst auf Punkt-vor-Strich Rechnung verzichtet werden (also fällt eval() flach). Außerdem kann man der Einfachheit davon ausgehen, dass nur korrekte Argumente übergeben werden.
Ich hab ungefähr so etwas hingeschrieben:

# a3.py
import sys

i = 0
result = 0
input = sys.argv[1:]
while i < len(input):
    if input[1]=="gleich":
        result = int(input[0])
        break
    elif input[i]=="plus":
        result = int(input[i-1]) + int(input[i+1])
        input[i+1] = result
    elif input[i]=="minus":
        result = int(input[i-1]) - int(input[i+1])
        input[i+1] = result
    elif input[i]=="mal":
        result = int(input[i-1]) * int(input[i+1])
        input[i+1] = result
    elif input[i]=="durch":
        result = int(input[i-1]) / int(input[i+1])
        input[i+1] = result
    i += 1

print "Ergebnis:",str(result)

Onlinetest in C

von Kai um 19:19 am Montag, 23. November 2009 in Programmiersprachen, Studium | 0 Kommentare

Heute fand nach sechswöchiger Einführung in C in dem Modul “Programmieren 3″ der Onlinetest in C statt. Nächste Woche gehts dann mit einer Einführung in Python weiter.

Da ich mir mittlerweile meiner akuten Prüfungsangst und der damit einhergehenden Blackouteritis bewusst bin, gehe ich davon aus, dass ich nur knapp bestanden hab, obwohl (zumindest die ersten beiden Aufgaben) nicht so schwer waren.

Nachfolgend nun die ersten beiden Aufgaben des Onlinetests. Die dritte Aufgabe reiche ich wie schonmal nach, sobald mein Kopf nicht mehr ganz so matschig ist.

Aufgabe 1

/****************************************************
 * Aufgabe: Es werden Noten (Note '1' bis Note '6') *
 * auf der Kommandozeile eingegeben. Als Ausgabe    *
 * erscheint dann die Summe der einzeln eingegeben- *
 * en Noten                                         *
 ****************************************************/

#include <stdio.h>

int main(void) {

  int n1=0,n2=0,n3=0,n4=0,n5=0,n6=0;
  int note;
  while(scanf("%d", &note) != EOF) {
    switch (note) {
    case 1:
      n1++;
      break;
    case 2:
      n2++;
      break;
    case 3:
      n3++;
      break;
    case 4:
      n4++;
      break;
    case 5:
      n5++;
      break;
    case 6:
      n6++;
      break;
    }
  }

  printf("Note 1: %d mal\n", n1);
  printf("Note 2: %d mal\n", n2);
  printf("Note 3: %d mal\n", n3);
  printf("Note 4: %d mal\n", n4);
  printf("Note 5: %d mal\n", n5);
  printf("Note 6: %d mal\n", n6);
}

Aufgabe 2

/****************************************************
 * Aufgabe: Versehentlich wurden einige Lottozahlen *
 * doppelt gezogen. Es soll eine beliebige Reihe    *
 * von Zahlen auf der Kommandozeile eingegeben und  *
 * die doppelt vorkommenden Zahlen geklammert       *
 * werden                                           *
 ****************************************************/

#include <stdio.h>
#include <assert.h>

typedef struct zahlen {
  int zahl;
  struct zahlen *next;
} Zahl;

Zahl *neueZahl(void) {
  Zahl *z;

  z = malloc(sizeof(Zahl));
  assert(z);
  z->zahl = 0;
  z->next = NULL;

  return z;
}

Zahl *start;
Zahl *tmp;

int main(void) {

  int eingabe;
  int erstesMal = 0;
  while(scanf("%d", &eingabe) != EOF) {
    if(erstesMal == 0) {
      Zahl *neu = neueZahl();
      neu->zahl = eingabe;
      neu->next = NULL;
      start = neu;
      tmp = neu;
      erstesMal = 1;
    } else {
      Zahl *neu = neueZahl();
      neu->zahl = eingabe;
      tmp->next = neu;
      tmp = neu;
    }

  }

  printf("%d ",start->zahl);
  tmp = start->next;
  while(tmp != NULL) {
    if(start->zahl == tmp->zahl) {
      printf("[%d] ",tmp->zahl);
    } else {
      printf("%d ",tmp->zahl);
    }
    start = tmp;
    tmp = start->next;
  }
}

Ultimative Emacs Cheat Sheet Übersicht

von Kai um 14:17 am Samstag, 31. Oktober 2009 in Produktivität, Studium | 1 Kommentar

emacsCheatSheetNotgedrungen aus dem Umstand, dass ich mir für das Studium momentan den Emacs Editor anschauen muss, habe ich mir die Mühe gemacht, eine kleine Überlebenshilfe zu basteln. (Auch wenn ich Vim selbstverständlich viel besser finde ;-) )
Die Infos auf dem DIN A5 großen Blatt habe ich mir quer durchs Internet zusammengesucht.

Der Verweis über das Vorschaubild führt zum Original und damit zur vollen Auflösung von 300 DPI. Viel Spaß damit.

Update auf Eclipse Galileo

von Kai um 20:26 am Donnerstag, 25. Juni 2009 in Studium | 0 Kommentare

Gestern kam die neue Version von Eclipse, meiner favorisierten (Java-) IDE. NetBeans hatte ich nur kurz ausprobiert, aber da wir an der FH ebenfalls Eclipse einsetzen, benutze ich die auch auf meinem Rechner zu Hause.

Eclipse

Neben einer “gefühlten” Verbesserung der Geschwindigkeit, kann ich eigentlich nicht viel Neues feststellen. Gut gelöst finde ich die neue Workspace Verwaltung. Hier kann man statt einer in Stein gemeißelten Festlegung eines Workspaces, nun bei jedem Start auswählen, in welcher man arbeiten möchte. Da ich meine Projekte bisher immer nach Semester getrennt habe, kommt mir das sehr entgegen.

Ich habe es seit Ganymede nicht geschafft, meine Version “einzudeutschen”. Mittlerweile ist mir die englische Oberfläche aber weitgehend lieber bzw. habe ich mich daran gewöhnt. Und da der Sourcecode (inklusive den Kommentaren und der Doku *hust*) in englischer Sprache gehalten ist, finde ich es auch eigentlich konsistenter die englische Variante zu benutzen.

Anfang dieses Semesters hatte ich mir von der FH ein SVN-Repository besorgt, um meine Projekte bequem von verschiedenen Rechnern aus verwalten zu können, ich habe aber schnell gemerkt, dass das bei dem Umfang der einzelnen Programmieraufgaben dem Schießen mit Kanonenrohren auf Spatzen gleichkommt. Ich habe nämlich keine Lust bei 20 Zeilen Code, jedesmal den Code neu auszuchecken, bzw. Updates zu ziehen und Patches hochzuladen. Ich nutze deswegen Dropbox, um die Ordner fürs Studium und den jeweiligen Workspace auf verschiedenen Rechnern synchron zu halten. Leider ist die FH an der ich studiere, von der Idee, Dropbox auf dem Rechnerpool zu installieren nicht sehr angetan gewesen, weswegen ich immer noch einer praktischen Lösung suche, den Kram, den ich zu Hause mache direkt auf dem Rechner in der FH zur Verfügung zu haben.

Letzte Klausur dieses Semester: Hands-On Programmieren 1

von Kai um 18:38 am Freitag, 13. März 2009 in Gadgets, Klausuren, Studium | 5 Kommentare

Update: Ungetestete Lösung Aufgabe 8 noch angehängt

Nachdem ich gestern die letzte Klausur in diesem Semester in Programmieren 1 geschrieben habe und deren Ausgang noch unklar ist, habe ich mich mal hingesetzt und versucht die ganzen Aufgaben zu rekapitulieren (danke auch an Fabian und Seba) und korrekt zu lösen:

1.) Man sollte die EBNF für beliebig lange Summen-Terme hinschreiben und danach das entsprechende Syntaxdiagramm dazu bilden (z.B. a+b, a+b+c+b+a+c, a ). Als EBNF ist wohl folgendes korrekt:

Summe = (a|b|c) {"+"(a|b|c)}

und das entsprechende Syntaxdiagramm sieht dann wohl so aus:

Syntaxdiagramm

2.) Als nächtes musste man ein paar Code-Fragmente auf Korrektheit überprüfen. Da ich die einzelnen Abschnitte nicht mehr rekonstruieren kann, lasse ich diese hier außen vor.

3.) Die Aufgabe war anhand eines übergebenen Monats (1 – 12) die korrekte Jahreszeit wiederzugeben. Einmal mittels Switch-Anweisung und einmal mit einem Array gelöst: Ich hab folgendes hingeschrieben:

public static String Jahreszeit (int monat)
{
// Lösung mit switch
switch(monat) {
    case 1: case 2: case 12:
        return "Winter";
    case 3: case 4: case 5:
        return "Frühling";
    case 6: case 7: case 8:
        return "Sommer";
    case 9: case 10: case 11:
        return "Herbst";
    default:
        return "Ungültige Monatsangabe";
}

// Lösung mit String-Array
String[] jahreszeiten = {"","Winter","Winter","Frühling","Frühling","Frühling","Sommer","Sommer","Sommer","Herbst","Herbst","Herbst","Winter"}

return jahreszeiten[monat];

4.) Bei der nächsten Aufgabe sollten für eine Zahl n alle ungeraden Teiler ausgegeben werden. Einmal mit einer while-Schleife, mit einer do-while-Schleife und mit einer for-Schleife. Meine Lösung:

public static void ungeradeTeiler(int n) {

// while-Schleife
int i=1;
while(i < n) {
    if(n%i==0 && i%2 != 0) {
    System.out.println(i);
    }
    i++;
}

// do-while-Schleife
int j=1;
do {
    if(n%j==0 && j%2 != 0) {
        System.out.println(j);
        }
        j++;
    } while(j < n);

// for-Schleife
for (int k=1; k < n;k++)
    if(n%k==0 && k%2 != 0) {
        System.out.println(k);
    }
}

5.) Die nächste Aufgabe bestand darin, eine Reihe von Zahlen nach Größe sortiert wieder auszugeben. Hier war es von Vorteil, wenn man sich eine der üblichen Sortierverfahren vorher eingeprägt hatte. Obwohl der QuickSort-Algorithmus mit einer der effizientesten Algorithmen ist, hab ich mich dennoch für den BubbleSort entschieden, weil ich mir den leichter merken kann:

public static void main(String[] args) {
       
// Einlesen der Zahlen von der Kommandozeile
int[] array = new int[args.length];
int i=0;
while(i<args.length) {
    array[i] = Integer.parseInt(args[i]);
    i++;
}

// sortieren mit BubbleSort-Verfahren
i= 1;
while(i< array.length) {
    int j = array.length -1;
    while (j >= i) {
        if (array[j] < array[j-1] ) {
            // vertauschen der beiden Stellen
            int tmp = array[j];
            array[j] = array[j-1];
            array[j-1] = temp;
        }
        j--;
    }
    i++;
}
   
// sortierte Liste ausgeben
i=0;
while (i < array.length ) {
    System.out.println(array[i]);
    i++;
    }
}

6.) Die sechste Aufgabe behandelte die binäre Suche. Das ist ein Algorithmus, der auf einem Array recht schnell ein gesuchtes Element finden kann. Der Algorithmus funktioniert folgendermaßen:
Als erstes wird das mittlere Element des Array auf geprüft. Wenn es gleich dem gesuchten Element ist, ist die Suche beendet, ist es kleiner als das gesuchte Element, muss man in der hinteren Hälfte des Arrays weitersuchen, ist es größer, wird in der vorderen Hälfte des Arrays weitergesucht.
Im nächsten Schritt wird dann wieder wie vorher weitergemacht: Also mittleres Element überprüfen, falls das gesuchte Element gleich dem mittleren Element ist, abbrechen, ansonsten jeweilige Hälfte überprüfen usw.
Ein Programmbeispiel konnte ich in der Klausur leider nicht liefern, werde mir aber dafür das Beispiel in der Wikipedia anschauen. Dort ist es neben einem Pseudocode ebenfalls in Java gelöst worden (neben Python und C).

7.) In der siebten Aufgabe sollte ein Skalarprodukt zweier Vektoren mit gleicher Länge ausgerechnet werden. Das Problem sollte einmal iterativ und einmal rekursiv gelöst werden:

// iterative Lösung
public static int skalar(int[] v, int[] w) {
    int result = 0;
    for(int i=0;i<v.length;i++)
    {
        result += v[i] * w[i];
    }
    return result;
}

// rekursive Lösung
public static int skalar(int[] v, int[] w) {
    int l = v.length;
    if (l == 0)
        return 0;
    else {
        int[] vv = new int[l - 1];
        int[] ww = new int[l - 1];
        for (int i = 0; i <= l - 2; i++) {
            vv[i] = v[i];
            ww[i] = w[i];
        }
        return v[l - 1] * w[l - 1] + skalar(vv, ww);
    }
}

8.) Die letzte Aufgabe war es, eine Verbindungslinie zwischen zwei Punkten zu berechnen. Vorgegeben war eine fiktive Funktion setPixel(int[][] a, int[][] b). Zuerst sollte man den Mittelpunkt M zwischen dem Anfangs- und Endpunkt berechnen. Lagen dann alle berechneten Punkte in einem jeweils benachbartem Feld, war man fertig und konnte die errechneten Punkte an die Funktion setPixel übergeben, ansonsten musste man wieder jeweils den Mittelpunkt zwischen dem Anfangs- bzw. Endpunkt berechnen usw. Zum besseren Verständnis eine Grafik:
Verbindungen
Die Lösung erspare ich mir heute und wird morgen nachgereicht. Update: Ungetestete Lösung noch beigefügt:

public static int[][] getMiddlePixel(int A[][], int B[][]) {
    int[][] M = new int[(A.length/2)+(B.length/2)][(A[0].length/2)+(B[0].length/2)];

    if (A.length == B.length && A[0].length == B[0].length) {
        // Die Punkte A und B liegen übereinander
        return M;
    } else  if (A.length == B.length && A[0].length != B[0].length) {
        // Der x-Wert der Punkte A und B sind korrekt
        return getMiddlePixel(A,M);
    } else {
        // Der y-Wert der Punkte A und B sind korrekt
        return getMiddlePixel(M,B);
    }
}

Suggestions for Students

von Kai um 12:16 am Sonntag, 1. März 2009 in How-To, Produktivität, Studium | 0 Kommentare

Ratgeber zum MitschreibenAuf der Suche nach Lernmethoden und aktiver Prokrastination aufgrund bevorstehender Klausur bin ich über einen guten Link gestolpert.

David Hirsch, Professor an der Western Washington University hat eine Liste mit Vorschlägen und Methoden zusammengestellt, um seinen Studenten das Studieren leichter zu machen. Die ersten Ratschläge sind recht offensichtlich. Zum einen rät er generell der Vorlesung auch wirklich beizuwohnen und sich stets ganz vorne einen Platz zu suchen, sowie sich mit einer Gruppe von Kommilitonen zusammen zu tun, die gut miteinander harmonieren, d.h. die einen ähnlichen Wissensstatus haben, sich gegenseitig abfragen und Lücken füllen können.

Etwas interessanter fand ich den Part, in dem er vorschlägt, die eigenen Notizen nach der Vorlesung nochmal zusammenzufassen, wichtiges von unwichtigem zu trennen, sowie beim schriftlichen Kopieren der Notizen sich selbst zu überprüfen, ob das geschriebene auch verstanden wurde.

Generell ist das natürlich ein guter Tipp, aber so etwas ist immer leichter gesagt als getan. Probleme entstehen nämlich genau dann, wenn man nicht alles notieren konnte, wenn keine Möglichkeit bestand Fragen zu stellen, sowie der unerwähnte Zeitaufwand der dabei entsteht, wenn man das Kopieren der mitgeschriebenen Notizen “2-3 mal die Woche” exerzieren sollte.

Deshalb hab ich mich mal etwas näher über dieses “Note Taking” informiert. Ebenfalls auf der Webseite der Western Washington University habe ich hierzu eine Art Tutorial gefunden.

Hier heisst es, dass

geschicktes Mitschreiben eine wichtige Komponente für das erfolgreiche Studieren an einer Universität sei (freie Übersetzung des Autors).

Auch hier heißt es wieder, dass der Schlüssel zum Erfolg das aktive Durchsehen der eigenen Notizen ist.
Folgende Dinge werden hier erläutert:

Aktive Teilnahme an der Vorlesung hilft sich das Gelehrte besser zu behalten

  • Vorlesungen regelmäßig besuchen
  • Ganz vorne sitzen
  • Stell dir vor dein Professor unterhält sich nur mit dir (das ist lustig :-) ) und es hängt von dir ab, wie gut du zuhörst. Stelle Fragen, wenn du etwas nicht verstehst.
  • Konzentrieren

Auf die wesentlichen Ideen achten beim Mitschreiben in der Vorlesung

  • Mitschreiben, wenn der Professor explizit sagt, dass folgendes wichtig ist
  • Tafelbild abschreiben
  • Wenn der Prof. einen Sachverhalt näher erläutert ebenfalls notieren
  • Explizit genannte Vor- und Nachteile eines bestimmten Themas machen sich auch immer gut in den Notizen
  • Auf die Modulation der Stimme achten, d.h. wenn der Dozent lauter/leiser wird, ist das oft ein Indikator, dass das nachfolgende bedeutend sein könnte, sowie bestimmte Signalwörter (z.B. “mit anderen Worten”, “Zum Beispiel”, “Zusammengefasst”)

Wenn der Dozent zu schnell spricht

  • Hier hilft es sich für die nächste Stunde vorzubereiten, d.h. Vorlesungsunterlagen/Skript für nächste Stunde bereits vorbereiten
  • Die mitgeschriebenen Notizen mit einem Kommilitonen (oder mehreren) vergleichen und ggf. ergänzen.
  • Beim Mitschreiben der Notizen Platz lassen für Dinge, die man nicht mit notieren konnte.
  • Entwickeln von speziellen Symbolen, wenn man den Faden verloren hat (z.B. “?” oder “F” für Frage). Danach fällt es oft leichter die entsprechenden Stellen nochmal zu erläutern bzw. nachzufragen
  • Professor fragen, wenn etwas unklar ist, oder man etwas nicht verstanden hat.
  • Vorlesung aufzeichnen (Erlaubnis vorher einholen)
  • Abkürzungen benutzen, evtl. auch eigene Abkürzungen entwicklen.

Wie bereits anfangs erwähnt, erscheinen viele Hinweise eigentlich offensichtlich, ich denke einzig und allein die Disziplin aufzubringen, wirklich jede Vorlesung so zu besuchen dürfte der einzige Knackpunkt an dieser Strategie sein;-)

Zwischenspiel

von Kai um 18:43 am Mittwoch, 18. Februar 2009 in Allgemeines, Studium | 0 Kommentare

So,

knapp die Hälfte der Klausuren ist rum. Morgen steht noch die mündliche Prüfung in Gestaltung an, dann übernächste Woche Signalverarbeitung, d.h. E-Technik und danach Englisch und Programmieren 1.

Die richtig schweren Klausuren (Analysis und Einführung Informatik) sind zum Glück schon vorbei. Für nächstes Semester nehme ich mir fest vor, am Ball zu bleiben und schon während der Vorlesungszeit was zu machen, anstatt am Ende in alter Schulmanier die letzten Tage vor einer Klausur press durchzulernen.

Ich habe heute mit dem Gedanken gespielt, mir ein Netbook zuzulegen, weil so ein Kinder-Notebook (bei der Größe der Tasten und der Leistung, die diese Teile haben finde ich den Namen ganz passend) in vielen Dingen praktischer ist, als ein normales Notebook. Zum einen ist es ne ganze Ecke leichter als mein aktueller Thinkpad T61 (dabei hatte ich mir den Thinkpad doch extra wegen dem geringen Gewicht gegenüber anderen Notebooks gekauft), zum anderen sind die Bootzeiten erheblich kürzer. Ich weiß bloss noch nicht, welches ich den kaufen soll, gibt ja mittlerweile ein ganz schön großes Angebot und ständig kommt ein neues raus.

Am Blog werd ich noch ne ganze Menge ändern, ich habe bisher lediglich am Theme etwas rumgefeilt und meine ganzen alten Beiträge aus meinem alten Blog hierher übertragen. Die Liste ist lang, die Zeit ist kurz.