Fachschaft Informatik - Benutzerbeiträge [de]

Gedächtnisprotokoll SE108-1

2009-03-17T13:38:35Z

RaG:

Es gab 58 Aufgaben. Einige Aufgaben in der Klausur entsprachen denjenigen aus der bekannten 20 Minuten-Probeklausur.

== Aufgabe 34 ==

Welche Rückgabe liefert die Funktion, wenn man ihr den aktuellen Parameter 3 übergibt?

int m34( int p ) {
int result = p;
if( p > 0 ) {
result = 3 * p + m34(p - 1);
}
return result;
}

Antwortmöglichkeiten:
* 12
* 15
* 18
* 21

== Aufgabe 35 ==

Welche Rückgabe liefert die Funktion, wenn man ihr den aktuellen Parameter 3 übergibt?
int m35( int p ) {
int result;
if( p == 0 ) {
result = 0;
} else {
result = 3 * p + m35(p - 1);
}
return result;
}

Antwortmöglichkeiten:
* 12
* 15
* 18
* 21

== Durcheinander ==

=== Frage ===
Welche Aussagen stimmen?

class Schalter {

private boolean _aktuellerZustand;
static public int _ANZAHL;

public void umschalten() {
_aktuellerZustand = !_aktuellerZustand;
_ANZAHL++;
}

static private int gibAnzahl() {
return _ANZAHL;
}

}

* _ANZAHL ist eine Klassenvariable
* gibAnzahl ist eine Exemplarmethode
* _aktuellerZustand kann nicht aus gibAnzahl abgefragt werden
* in _ANZAHL zählt für jedes Objekt getrennt das umschalten.

=== Frage ===
Berechne den folgenden Ausdruck:
(int)( 13.0 / 3 * 3 )

* 4
* 12
* 13
* bla

=== Frage ===
Berechne den folgenden Ausdruck:
5.0 / 2 * 3

* 6
* 7,5
* 11
* bla

=== Frage ===
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?:
int result = 2;
if( sum == 0 )
if( count == 0)
result = 1;
else
result = 0;

* 0
* 1
* 2
* Der Code wirft eine Exception

=== Frage ===
Was trift zu:
int[] intArray;
int i = intArray[0];

* bla
* i hat nach der Ausführung der Zeilen den Wert 0
* Der Code wirft eine Exception
* intArray hat 0 Elemente

[[Kategorie:Gedaechtnisprotokoll|SE1]]

Gedächtnisprotokoll RS09-1

2009-02-27T10:54:29Z

RaG:

Rechnerstruktur Klausur, WS 08/09, 1. Termin, Freitag, 13.02.2009
<pre>
ANMERKUNG: Es gab insgesamt 180 Punkte zu erreichen, davon entfallen alleine 60 auf Bonuspunkte.
Das heisst, für eine 1,0 würden 120 Punkte reichen, zum Bestehen 60.
</pre>
== Aufgabe 1 ==
(7 Punkte)

Wandeln sie folgende Zahl 7951 in Binär, Oktal und Sedezimaldarstellung um.

== Aufgabe 2 (Bonusaufgabe)==
(10 Punkte)

Wandeln Sie 0,35 in einen Binärbruch um. Geben Sie dazu die Vorperiode und Periode an und runden Sie diesen neutral auf die 8 Stelle.

== Aufgabe 3 ==
(10 Punkte)

Gegeben sind folgende absolute Häufigkeiten 4, 7, 11, 18, 19, 23 eines Zeichensatzes. Geben Sie die Längen der Codewörter eines zugehörigen Huffmancodes an.

== Aufgabe 4 ==
(20 Punkte)

Berechnen Sie zu folgender Bittkette K = 11010010010 einen Prüfcode mittels des Divisionspolynoms C = 10011. Geben Sie die korrigierte Nachricht in der Form K konkav C an.

== Aufgabe 5 (Zusatzaufgabe) ==
(20 Punkte)

Berechnen Sie, ob die folgenden Nachrichten korrekt übertragen wurden, das Divisionspolynom ist 1101. Ansonsten geben Sie die korrigierten Nachrichten an.

a) 0111001
b) 1010000
c) 0100110
d) 1111010

== Aufgabe 6 ==
(20 Punkte)
<pre>
VORSICHT! Die Aufgabe ist nicht genau dieselbe wie beim Gedächtnisprotokoll zu RS08-1!
Die Ankreuzmöglichkeiten waren ein wenig verändert!
Das heisst, nicht einfach auswendig lernen und in der Klausur richtig durchlesen!
Vielleicht kann sich ja jemand noch an die richtigen Möglichkeiten erinnern ;)
</pre>

Gegeben sind folgende DNF

X = /ABC + A/B/C + A/BC + AB/C + ABC

Y = /A/BC + /AB/C + A/BC + AB/C + ABC

Dadraus wurden mithilfe von KV-Diagrammen die folgenden minimierten DNF erstellt:

a)

X = ....

Y = .....

Kreuzen Sie alle zutreffenden Aussagen an:

<pre>
[ ] Die minimierten Terme sind richtig
[ ] Die minimierten Terme sind falsch
[ ] Nur X ist richtig
[ ] Nur Y ist richtig
[ ] Die minimierten Terme sind richtig, aber vertauscht
[ ] Die minimierten Terme sind richtig, aber in der falschen Reinfolge
</pre>

b)

Aus den minimierten DNF wurde folgende Schaltung gebaut:

http://nilstgmd.bplaced.net/data/RS_aufg6b.png

Kreuzen Sie alle richtigen Aussagen an:
<pre>
[ ] Die Schaltung ist richtig.
[ ] Die Schaltung ist falsch, weil die Eingänge falsch belegt sind.
[ ] Die Schaltung ist falsch, weil die Ausgänge falsch belegt sind.
[ ] Die Schaltung ist richtig, aber alle Ausgänge wurden vertauscht.
[ ] Die Schaltung ist richtig, aber alle Eingänge wurden vertauscht.
[ ] Die Schaltung ist richtig, aber die Eingäng A und B wurden vertauscht.
[ ] Die Schaltung ist richtig, aber nicht für diese DNF
...
[ ] Keine der Aussagen trifft zu.
</pre>

c)

Geben Sie an, welche Bedeutung die in der Schaltung verwendeten Symbole als elementare Schaltglieder haben.

d)

Geben Sie an, wie oft die elementaren Schaltglieder in der Schaltung verwendet wurden.

== Aufgabe 7 ==
(32 Punkte)

Ampelschaltung

Zustand | Zustandscodierung | Auto-Ampel | Fußgänger-Ampel
X 001 Gelb Rot
Y 011 Rot Rot
Z 111 Rot Grün
A 110 Rot Rot
B 100 Rot-Gelb Rot
W 000 Grün Rot

a) Übertragen Sie die Ampelphasen ausgehend aus der Zustandstabelle in einen Zustandsgraphen

b) Übertragen Sie ihren Zustandsgraphen in eine Zustandstabelle der Form:

K | Z2 Z1 Z0 | Z2+ Z1+ Z0+

c) Leiten Sie mittels Minimierung durch KV-Diagramme die minimierten Terme des Übergangschaltnetzwerkes aus Ihrer Zustandstabelle ab.

d) Erstellen Sie eine Wertetabelle für die Ausgangsfunktion in folgender Form:

Z2 Z1 Z0 | Stop Gehen | Rot Gelb Grün

e) Bestimmen Sie mittels Minimierung durch KV-Diagramme die minimierten Terme der Ausgangsfunktion.

f) In welchem Zustand befindet sich Ihre Ampelsteuerung zum Zeitpunkt des Einschaltens? Wie verhält sich Ihre Schaltung in den nicht realisierten Zuständen?

g) Welche Möglichkeiten haben Sie, die Schaltung sicherer zu machen bzw. die Fälle auszuschließen?

== Aufgabe 8 ==
Geben Sie für folgende Ausgangsmatrix die Verbindungsmatrix an.

http://img216.imageshack.us/img216/3715/verbindungendn9.th.jpg
[[Kategorie:Gedaechtnisprotokoll|RS]]

== Aufgabe 9 ==
( 15 Punkte )

Was macht dieses Programm:

funktion:
save %sp, -120, %sp
mov %i0, %o0 ! %o0 = x

smul %o0, %o0, %o3
smul %o0, %o3, %o2

sll %o2, 2, %o0
sll %o2, 3, %o1
add %o0, %o1, %o2

sll %o3, 1, %o0
sll %o3, 4, %o1
add %o0, %o1, %o3

add %o3, %o2, %o3
add %o3, 60, %o0

sra %o0, 31, %g1
wr %g0, %g1, %y
nop
nop
nop
sdiv %o0, 18, %i0

jmp %i7+8
restore

== Aufgabe 10 (Bonusaufgabe) ==

Gegeben seien zwei Single-Zahlen (32 Bit) a und b in Sedezimalnotation.
Berechnen Sie die Summe von a und b und geben Sie sie auch in Sedezimalnotation an.

'' 4 Additionsaufgaben, davon 2 relativ simple, in denen für die Ergebnisangabe der Exponent geändert werden musste, eine Aufgabe mit einer negativen Zahl sowie eine mit 'unendlich' als Summand ''

== Aufgabe 11 (Bonusaufgabe) ==

Die XOR Operation hat einige besonders schöne Eigenschaften. Unter anderem gilt: (a XOR b) XOR a = b.
Nutzen Sie nur die XOR Funktion, um zwei Register ohne einen Zwischenspeicher zu vertauschen.

''Anmerkung: Pseudo oder Assemblercode war gefragt.''

== Aufgabe 12 ==

Haupspeichergröße = 2^20

Cachemengen = 32 mit je 4 Cacheblöcken (direct mapped)

Cacheblockgröße = 32 Byte

In welchen Cachemengen werden die Werte folgender Adressen abgelegt:

a) 01 0110 1010 0100 1010

b) 10 1010 1010 0101 1101

c) 11 0101 0100 1110 1001

d) 00 1001 1110 1011 1010

Geben Sie an wie viele Bit der Adresse auf was verfallen:
<pre>
Tag: Bit
Index: Bit
Bytenummer: Bit
</pre>

== Aufgabe 13 ==

Bestimmen Sie für die folgende Referenzkette R die Anzahl der Seitenalarme bei Beladys
Algorithmus und dem LRU-Verfahren bei einer Größe des Kachelspeichers von 3.
R = a b c d a b b a c e d c a f g a d b c f

Gedächtnisprotokoll SE109-1

2009-02-26T12:13:50Z

RaG:

[[Kategorie:Gedaechtnisprotokoll|SE1]]
== Frage ==

Was trifft für folgenden Programmtext zu?
int[] intArray = new int[5];
for (int i : intArray)
{
i = 42;
}
int j = intArray[0];

Antwortmöglichkeiten (ungenau):
* intArray[1] ist 42
* j ist 42
* intArray[1] ist 0
* Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte

== Frage ==
Welche Aussagen bezüglich Variablen sind korrekt?

* Bei einem Methodenaufruf werden die Werte der formalen Parameter an die aktuellen Parameter gebunden
* Die Lebensdauer einer lokalen Variable entspricht maximal der Lebensdauer der Methode, in der sie deklariert wurde
* Eine Variable in Java ist die Abstraktion eines physischen Speicherplatzes
* Die Deklaration von Exemplarvariablen und lokalen Variablen ist ''immer'' gleich
* [...]

== Frage ==

Welche Aussagen stimmen?

* Das Einfügen am Anfang einer Liste ist bei einer LinkedList schneller als bei einer ArrayList
* Das Einfügen am Ende einer Liste ist für ArrayList und LinkedList ''immer'' gleich schnell
* Das Lesen eines Elements in der Mitte einer Liste geht schneller bei einer ArrayList
* Die Suche nach einem Element in einer unsortieren Liste hat den Aufwand O(n)
* In einem balancierten, binären Baum hat die Suche nach einem Element die Komplexität O(n log n)
* Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden
* Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort

== Frage ==

Welche Aussagen stimmen?

* [...]
* Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen
* Die Implementation eines Graphen mittles Adjazenzlisten ist im Allgemeinen speichereffizienter als eine Implementation durch eine Adjazenzmatrix
* Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen
* Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch

== Frage ==

Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen?

{
int g = 4;
int h = g + 3;
h = g - h;
}

Antwortmöglichkeiten:
* -3
* 4
* 3
* 0

== Frage ==

Welchen Wert hat h nach Ausführung dieses Programmtextes?
int g = 4;
int h = g + 3;
g = h - 2;
h = g + 2;

Antwortmöglichkeiten (ungenau):
* [...]
* 7

== Frage ==
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?:
int result = 2;
if( sum == 0 )
if( count == 0)
result = 1;
else
result = 0;

* 0
* 1
* 2
* Der Code wirft eine Exception

Gedächtnisprotokoll SE109-1

2009-02-26T12:12:02Z

RaG:

[[Kategorie:Gedaechtnisprotokoll|SE1]]
== Frage ==

Was trifft für folgenden Programmtext zu?
int[] intArray = new int[5];
for (int i : intArray)
{
i = 42;
}
int j = intArray[0];

Antwortmöglichkeiten (ungenau):
* intArray[1] ist 42
* j ist 42
* intArray[1] ist 0
* Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte

== Frage ==
Welche Aussagen bezüglich Variablen sind korrekt?

* Bei einem Methodenaufruf werden die Werte der formalen Parameter an die aktuellen Parameter gebunden
* Die Lebensdauer einer lokalen Variable entspricht maximal der Lebensdauer der Methode, in der sie deklariert wurde
* Eine Variable in Java ist die Abstraktion eines physischen Speicherplatzes
* Die Deklaration von Exemplarvariablen und lokalen Variablen ist ''immer'' gleich
* [...]

== Frage ==

Welche Aussagen stimmen?

* Das Einfügen am Anfang einer Liste ist bei einer LinkedList schneller als bei einer ArrayList
* Das Einfügen am Ende einer Liste ist für ArrayList und LinkedList ''immer'' gleich schnell
* Das Lesen eines Elements in der Mitte einer Liste geht schneller bei einer ArrayList
* Die Suche nach einem Element in einer unsortieren Liste hat den Aufwand O(n)
* In einem balancierten, binären Baum hat die Suche nach einem Element die Komplexität O(n log n)
* Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden
* Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort

== Frage ==

Welche Aussagen stimmen?

* [...]
* Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen
* Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen
* Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch

== Frage ==

Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen?

{
int g = 4;
int h = g + 3;
h = g - h;
}

Antwortmöglichkeiten:
* -3
* 4
* 3
* 0

== Frage ==

Welchen Wert hat h nach Ausführung dieses Programmtextes?
int g = 4;
int h = g + 3;
g = h - 2;
h = g + 2;

Antwortmöglichkeiten (ungenau):
* [...]
* 7

== Frage ==
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?:
int result = 2;
if( sum == 0 )
if( count == 0)
result = 1;
else
result = 0;

* 0
* 1
* 2
* Der Code wirft eine Exception

Gedächtnisprotokoll SE109-1

2009-02-26T12:11:18Z

RaG:

[[Kategorie:Gedaechtnisprotokoll|SE1]]
== Frage ==

Was trifft für folgenden Programmtext zu?
int[] intArray = new int[5];
for (int i : intArray)
{
i = 42;
}
int j = intArray[0];

Antwortmöglichkeiten (ungenau):
* intArray[1] ist 42
* j ist 42
* intArray[1] ist 0
* Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte

== Frage ==
Welche Aussagen bezüglich Variablen sind korrekt?

* Bei einem Methodenaufruf werden die Werte der formalen Parameter an die aktuellen Parameter gebunden
* Die Lebensdauer einer lokalen Variable entspricht maximal der Lebensdauer der Methode, in der sie deklariert wurde
* Eine Variable in Java ist die Abstraktion eines physischen Speicherplatzes
* Die Deklaration von Exemplarvariablen und lokalen Variablen ist ''immer'' gleich
* [...]

== Frage ==

Welche Aussagen stimmen?

* Das Einfügen am Anfang einer Liste ist bei einer LinkedList schneller als bei einer ArrayList
* Das Einfügen am Ende einer Liste ist für ArrayList und LinkedList ''immer'' gleich schnell
* Das Lesen eines Elements in der Mitte einer Liste geht schneller bei einer ArrayList
* Die Suche nach einem Element in einer unsortieren Liste hat den Aufwand O(n)
* In einem balancierten, binären Baum hat die Suche nach einem Element die Komplexität O(n log n)
* Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden
* Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort

== Frage ==

Welche Aussagen stimmen?

* [...]
* Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen
* Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen
* Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch

== Frage ==

Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen?

{
int g = 4;
int h = g + 3;
h = g - h;
}

Antwortmöglichkeiten:
* -3
* 4
* 3
* 0

== Frage ==

Welchen Wert hat h nach Ausführung dieses Programmtextes?
int g = 4;
int h = g + 3;
g = h - 2;
h = g + 2;

Antwortmöglichkeiten (ungenau):
* [...]
* 7

=== Frage ===
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?:
int result = 2;
if( sum == 0 )
if( count == 0)
result = 1;
else
result = 0;

* 0
* 1
* 2
* Der Code wirft eine Exception

Gedächtnisprotokoll SE109-1

2009-02-22T13:50:46Z

RaG:

[[Kategorie:Gedaechtnisprotokoll|SE1]]
== Frage ==

Was trifft für folgenden Programmtext zu?
int[] intArray = new int[5];
for (int i : intArray)
{
i = 42;
}
int j = intArray[0];

Antwortmöglichkeiten (ungenau):
* intArray[1] ist 42
* j ist 42
* intArray[1] ist 0
* Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte

== Frage ==
Welche Aussagen bezüglich Variablen sind korrekt?

* Bei einem Methodenaufruf werden die Werte der formalen Parameter an die aktuellen Parameter gebunden
* Die Lebensdauer einer lokalen Variable entspricht maximal der Lebensdauer der Methode, in der sie deklariert wurde
* Eine Variable in Java ist die Abstraktion eines physischen Speicherplatzes
* Die Deklaration von Exemplarvariablen und lokalen Variablen ist ''immer'' gleich
* [...]

== Frage ==

Welche Aussagen stimmen?

* Das Einfügen am Anfang einer Liste ist bei einer LinkedList schneller als bei einer ArrayList
* Das Einfügen am Ende einer Liste ist für ArrayList und LinkedList ''immer'' gleich schnell
* Das Lesen eines Elements in der Mitte einer Liste geht schneller bei einer ArrayList
* Die Suche nach einem Element in einer unsortieren Liste hat den Aufwand O(n)
* In einem balancierten, binären Baum hat die Suche nach einem Element die Komplexität O(n log n)
* Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden
* Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort

== Frage ==

Welche Aussagen stimmen?

* [...]
* Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen
* Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen
* Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch

== Frage ==

Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen?

{
int g = 4;
int h = g + 3;
h = g - h;
}

Antwortmöglichkeiten:
* -3
* 4
* x
* y

== Frage ==

Welchen Wert hat h nach Ausführung dieses Programmtextes?
int g = 4;
int h = g + 3;
g = h - 2;
h = g + 2;

Antwortmöglichkeiten (ungenau):
* [...]
* 7

=== Frage ===
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?:
int result = 2;
if( sum == 0 )
if( count == 0)
result = 1;
else
result = 0;

* 0
* 1
* 2
* Der Code wirft eine Exception

Gedächtnisprotokoll SE1 08-1

2009-02-21T14:15:25Z

RaG: hat ?Gedächtnisprotokoll SE1 08-1? nach ?Gedächtnisprotokoll SE108-1? verschoben: Zur Anpassung an die anderen Gprot-Namen

#REDIRECT [[Gedächtnisprotokoll SE108-1]]

Gedächtnisprotokoll SE108-1

2009-02-21T14:15:25Z

RaG: hat ?Gedächtnisprotokoll SE1 08-1? nach ?Gedächtnisprotokoll SE108-1? verschoben: Zur Anpassung an die anderen Gprot-Namen

Es gab 58 Aufgaben. Einige Aufgaben in der Klausur entsprachen denjenigen aus der bekannten 20 Minuten-Probeklausur.

== Aufgabe 34 ==

Welche Rückgabe liefert die Funktion, wenn man ihr den aktuellen Parameter 3 übergibt?

int m34( int p ) {
int result = p;
if( p > 0 ) {
result = 3 * p + m34(p - 1);
}
return result;
}

Antwortmöglichkeiten:
* 12
* 15
* 18
* 21

== Aufgabe 35 ==

Welche Rückgabe liefert die Funktion, wenn man ihr den aktuellen Parameter 3 übergibt?
int m35( int p ) {
int result;
if( p == 0 ) {
result = 0;
} else {
result = 3 * p + m35(p - 1);
}
return result;
}

Antwortmöglichkeiten:
* 12
* 15
* 18
* 21

== Durcheinander ==

=== Frage ===
Welche Aussagen stimmen?

class Schalter {

private int _aktuellerZustand;
static public int _ANZAHL;

public void umschalten() {
_aktuellerZustand = !_aktuellerZustand;
_ANZAHL++;
}

static private int gibAnzahl() {
return _ANZAHL;
}

}

* _ANZAHL ist eine Klassenvariable
* gibAnzahl ist eine Exemplarmethode
* _aktuellerZustand kann nicht aus gibAnzahl abgefragt werden
* in _ANZAHL zählt für jedes Objekt getrennt das umschalten.

=== Frage ===
Berechne den folgenden Ausdruck:
(int)( 13.0 / 3 * 3 )

* 4
* 12
* 13
* bla

=== Frage ===
Berechne den folgenden Ausdruck:
5.0 / 2 * 3

* 6
* 7,5
* 11
* bla

=== Frage ===
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?:
int result = 2;
if( sum == 0 )
if( count == 0)
result = 1;
else
result = 0;

* 0
* 1
* 2
* Der Code wirft eine Exception

=== Frage ===
Was trift zu:
int[] intArray;
int i = intArray[0];

* bla
* i hat nach der Ausführung der Zeilen den Wert 0
* Der Code wirft eine Exception
* intArray hat 0 Elemente

[[Kategorie:Gedaechtnisprotokoll|SE1]]

Gedächtnisprotokoll SE1 09-1

2009-02-21T14:14:44Z

RaG: hat ?Gedächtnisprotokoll SE1 09-1? nach ?Gedächtnisprotokoll SE109-1? verschoben: Um den Namen den restlichen Gprots anzupassen

#REDIRECT [[Gedächtnisprotokoll SE109-1]]

Gedächtnisprotokoll SE109-1

2009-02-21T14:14:44Z

RaG: hat ?Gedächtnisprotokoll SE1 09-1? nach ?Gedächtnisprotokoll SE109-1? verschoben: Um den Namen den restlichen Gprots anzupassen

== Frage ==

Was trifft für folgenden Programmtext zu?
void m()
{
int[] intArray = new int[5];
for (int i : intArray)
{
i = 42;
}
int j = intArray[0];
}

Antwortmöglichkeiten (ungenau):
* intArray[1] ist 42
* j ist 42
* intArray[1] ist 0
* Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte

== Frage ==
Welche Aussagen bezüglich Variablen sind korrekt?

* Bei einem Methodenaufruf werden die Werte der formalen Parameter an die aktuellen Parameter gebunden
* Die Lebensdauer einer lokalen Variable entspricht maximal der Lebensdauer der Methode, in der sie deklariert wurde
* Eine Variable in Java ist die Abstraktion eines physischen Speicherplatzes
* Die Deklaration von Exemplarvariablen und lokalen Variablen ist ''immer'' gleich
* [...]

== Frage ==

Welche Aussagen stimmen?

* Das Einfügen am Anfang einer Liste ist bei einer LinkedList schneller als bei einer ArrayList
* Das Einfügen am Ende einer Liste ist für ArrayList und LinkedList ''immer'' gleich schnell
* Das Lesen eines Elements in der Mitte einer Liste geht schneller bei einer ArrayList
* Die Suche nach einem Element in einer unsortieren Liste hat den Aufwand O(n)
* In einem balancierten, binären Baum hat die Suche nach einem Element die Komplexität O(n log n)
* Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden
* Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort

== Frage ==

Welche Aussagen stimmen?

* [...]
* Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen
* Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen
* Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch

== Frage ==

Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen?

{
int g = 4;
int h = g + 3;
h = g - h;
}

Antwortmöglichkeiten:
* -3
* 4
* x
* y

== Frage ==

Welchen Wert hat h nach Ausführung dieses Programmtextes?
int g = 4;
int h = g + 3;
g = h - 2;
h = g + 2;

Antwortmöglichkeiten (ungenau):
* [...]
* 7

[[Kategorie:Gedaechtnisprotokoll|SE1]]

Gedächtnisprotokoll SE109-1

2009-02-21T14:12:01Z

RaG:

Gedächtnisprotokoll SE109-1

2009-02-21T14:07:55Z

RaG:

== Frage ==

Was trifft für folgenden Programmtext zu?
void m()
{
int[] intArray = new int[5];
for (int i : intArray)
{
i = 42;
}
int j = intArray[0];
}

Antwortmöglichkeiten (ungenau):
* intArray[1] ist 42
* j ist 42
* intArray[1] ist 0
* Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte

== Frage ==

Welche Aussagen stimmen?

* Das Einfügen am Anfang einer Liste ist bei einer LinkedList schneller als bei einer ArrayList
* Das Einfügen am Ende einer Liste ist für ArrayList und LinkedList ''immer'' gleich schnell
* Das Lesen eines Elements in der Mitte einer Liste geht schneller bei einer ArrayList
* Die Suche nach einem Element in einer unsortieren Liste hat den Aufwand O(n)
* In einem balancierten, binären Baum hat die Suche nach einem Element die Komplexität O(n log n)
* Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden
* Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort

== Frage ==

Welche Aussagen stimmen?

* [...]
* Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen
* Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen
* Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch

== Frage ==

Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen?

{
int g = 4;
int h = g + 3;
h = g - h;
}

Antwortmöglichkeiten:
* -3
* 4
* x
* y

== Frage ==

Welchen Wert hat h nach Ausführung dieses Programmtextes?
int g = 4;
int h = g + 3;
g = h - 2;
h = g + 2;

Antwortmöglichkeiten (ungenau):
* [...]
* 7

[[Kategorie:Gedaechtnisprotokoll|SE1]]