Aufgaben Eindimensionale Arrays

a) Entwickle eine Würfelsimulation, die es erlaubt 10 mal zu würfeln. Die Wurfergebnisse sollen dabei über den Zufallsgenerator erzeugt werden und in einem Integer-Array abgespeichert werden.
b) Ergänze das Programm derart, dass der Mittelwert der 10 Würfe berechnet wird und die Anzahl jener Würfe ermittel wird, die über dem Mittelwert liegen.

Hinweis 1: Es muss zuerst der Zufallsgenerator von CPP initialisiert werden (sonst erhält man stets die selbe Zufallsfolge)

srand (time(NULL)); // Intialisierung der srand Funktion  
wurf[i]=rand()%6 + 1; // liefert eine Zahl zwischen 1 und 6

Zum Schutz von Fehlern werden Texte oft mit einem Prüfbyte versehen, das aus den Zeichen eines Textes berechnet wird. Eine einfache Technik zur Berechnung eines Prüfbytes besteht darin, alle Zeichen des Textes mit der Operation XOR (bitweise exklusives oder, ^) zu verknüpfen. Schreibe eine Funktion, der ein Text als char-Array übergeben wird und die daraus ein Prüfbyte nach der beschriebenen Technik berechnet.

Schreibe ein Programm, die in einem Array die ersten 20 Quadratzahlen (1^2, 2^2,…) ablegt. Diese Quadratzahlen sollen nun nach geraden und ungeraden aufgeteilt werden. In ein Array sollen alle geraden kopiert werden und in ein anderes alle ungeraden. Gib alle geraden und ungeraden Quadratzahlen und die jeweilige Anzahl aus!

Ein Array namens Bereich soll mit einer vorgegebenen Anzahl von Zufallszahlen zwischen den Grenzen ug und og belegt werden. Dabei können sich die Zahlen wiederholen.
Hinweis 1: Es muss zuerst der Zufallsgenerator von CPP initialisiert werden (sonst erhält man stets die selbe Zufallsfolge)

srand (time(NULL)); // Intialisierung der srand Funktion  //

Hinweis 2: Wie man eine Zufallszahl zwischen den Grenzen ug und og zu erhalten kann, zeigt die folgende Zeile

zahl[i]=rand()%(og-ug+1)+ug;

Gehe von der Aufgabenstellung von Aufgabe 4 aus. Es dürfen sich aber jetzt die erzeugten Zufallszahlen nicht wiederholen. Am Beginn wird die erste Zufallszahl erzeugt. Dann erfolgt die schrittweise Bestimmung der restlichen Zahlen. Dabei muss jede neue Zufallszahl mit allen vorher erzeugten Zahlen veglichen werden. Nur wenn sie mit keiner davon übereinstimmt, wird sie in den Bereich übernommen.

Zur Berechnung aller Primzahlen bis zu einer Obergrenze n gibt es ein raffiniertes Verfahren, das vom griechischem Mahtematiker Erathostenes stammt. Es wird das Sieb des Erathostenes genannt und basiert auf der Idee, dass die Vielfachen einer Primzahl mit Sicherheit keine Primzahlen sind. Wenn wir z.B. wissen, dass 2 eine Primzahl ist, können wir alle Vielfache von 2 aus der Menge der Primzahlenkandidaten streichen. Die kleinste Zahl der dann verbleibenden Menge ist die nächste Primzahl. Wir eliminieren wiederum alle ihre Vielfache.

Implementieren lässt sich dieser Algorithmus sehr schön mit Hilfe eines Arrays der Länge n mit boolean Elementen.

Schreibe eine Anwendung, die 25 Zufallszahlen zwischen -10 und 10 in ein Array schreibt. Der Anwender soll eine zu suchende Zahl eingeben und die Anwendung soll im Array nach der Zahl suchen. Das Programm soll anschließend ausgegeben, ob die gesuchte Zahl im Array enthalten ist oder nicht.

Programmiere die Suche als sequentielle Suche, d.h. fange beim ersten Arrayelement an und vergleiche es mit dem Suchwert. Falls es nicht das gesuchte Element ist, gehe zum nächsten Arrayelement usw..

Überlege dir, wie du Zufallszahlen zwischen -10 und 10 geschickt erzeugen kannst.

Realisiere einen Sortieralgorithmus (Auswahlsort) um 10 zufällig erzeugte Integer-Werte zwischen 0 und 99 eines Arrays zu sortieren:

Um die ersten n Elemente eines Arrays a (z.B. des Datentyps int) aufsteigend zu sortieren, kann man folgendermaßen vorgehen:

• Zuerst sucht man im Indexbereich 0..n–1 nach dem Index des kleinsten Elements:
• Danach vertauscht man a[0] mit a[min], so dass das kleinste Element in Position 0 steht.
• Diese Vorgehensweise wiederholt man für die Indexbereiche 1 .. n–1, 2 .. n–1 bis schließlich n–2 .. n–1. Dadurch wird sukzessive das zweitkleinste Element an die Position 1, das drittkleinste an die Position 2 übertragen usw.

Lösung

void fuelleArray(int a[10]){
	srand(time(0));
	for(int i=0;i<10;i++){
		a[i]=rand()%100;
	}
}
 
void ausgabe(int a[10]){
	for (int i=0; i<10; i++) {
    	cout<<a[i]<<" - ";
	}
}
 
void main()
{
	const int max=10;
	int zahlen[max];
	fuelleArray(zahlen);
	ausgabe(zahlen);
	getch();
}

Das Programm erstellt 12 Zufallszahlen zwischen 1 und 100

• Die Summe aller Zahlen wird ausgegeben.
• Der Mittelwert wird ausgegeben.
• Die Anzahl der geraden Zahlen wird ausgegeben.
• Benutzer gibt eine Zahl ein, es wird überprüft, ob die Zahl vorkommt.
• Es wird überprüft, ob irgendwelche Zahlen doppelt vorkommen.

Realisiere einen Bankomaten mit einem Array, in welchem der jeweilige Wert der Scheine gespeichert ist und einem zweiten Array, in welchem die jeweilige Anzahl gespeichert ist:

wert[0] = 500,
wert[1] = 200,
wert[2] = 100,
...
anzahl[0] = Anzahl der 500er-Scheine
anzahl[1] = Anzahl der 200er-Scheine
anzahl[2] = Anzahl der 100er-Scheine
...

Das Besondere an diesem Bankomat ist, dass man weder Karte noch Code benötigt, um abzuheben

Ein neuer Bankomat ist leer, d.h. alle Werte im Array anzahl haben den Wert 0.

Daher muss der Bankomat befüllt werden. Das Unterprogramm befuellen(…) hat 2 Parameter:

• schein: gibt an, welche scheine nachgelegt werden (z.B. 50 - es werden 50er-Scheine nachgelegt).
• anzahl: gibt an, wieviele Scheine nachgelegt werden.

Mit dem Unterprgoramm auszahlen(…) kann man den Bankomat veranlassen, einen bestimmten Betrag auszuzahlen. Der Automat muss nun berechnen, ob und mit welchen Scheinen er den Betrag auszahlen kann. Dabei gilt die Regel, dass er immer mit den größtmöglichen Scheinen auszahlt. Die Anzahl der jeweiligen Scheine wird auf der Konsole ausgegeben.

Beispiel: Der Betrag 790 soll ausgezahlt werden - Ausgabe auf der Konsole:

• 500-Scheine: 1
• 200-Scheine: 1
• 50-Scheine: 1
• 20-Scheine: 2

Natürlich muss dabei überprüft werden, ob die benötigten Scheine überhaupt verfügbar sind. Falls nicht, wird eine Fehlermeldung ausgegeben: Betrag nicht verfügbar.

Bei einer Auszahlung müssen auch die Werte im entsprechenden Array reduziert werden.

Es soll intern jeweils eine Schleife verwendet werden und so programmiert sein, dass man ohne großen Aufwand daraus einen Bankomat machen könnte, der beispielsweise auch 5er, 2er und 1er auszahlt.

Der Benutzer wird immer wieder gefragt, ob er einzahlen, auszahlen oder das Programm beenden möchte.

Gib an, welche der mit a) bis g) bezeichneten Anweisungen syntaktisch korrekt sind. Falls ja, beschreiben das Ergebnis dieser Anweisungen.

void ArrayTest1()
{
int a[10];
for (int i=1; i<=10;i++) a[i] = 0; // a)
int b[2], c[2], d[3];
b[0]=0; b[1]=1;
c=b; // b)
int x=b[b[b[0]]]; // c)
c[0]=0; c[1]=1;
d[0]=0; d[1]=1; d[2]=2;
if (b==c) x++; // d)
if (c==d) x++; // e)
int s1=sizeof(a); // f)
int s2=sizeof(a)/sizeof(a[0]); // g)
}

Schreibe ein Programm, dass

Lösung

Lösung

Lösung

Lösung

Lösung

Lösung

Lösung