====== Aufgaben Eindimensionale Arrays ======
=====Aufgabe 1: Würfelsimulation=====

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)
<code cpp>
srand (time(NULL)); // Intialisierung der srand Funktion  
wurf[i]=rand()%6 + 1; // liefert eine Zahl zwischen 1 und 6
</code>

=====Aufgabe 2: Prüfsumme=====

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.

=====Aufgabe 3: Quadratzahlen=====

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!


=====Aufgabe 4: Zufallszahlen=====

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)
<code cpp>
srand (time(NULL)); // Intialisierung der srand Funktion  //
</code>
Hinweis 2: Wie man  eine Zufallszahl zwischen den Grenzen //ug// und //og// zu erhalten kann, zeigt die folgende Zeile
<code cpp>
zahl[i]=rand()%(og-ug+1)+ug;
</code>

=====Aufgabe 5: Zufallszahlen - Erweiterung=====

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.

=====Aufgabe 6: - Primzahlenberechnung mit dem Sieb des Erathostenes=====


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.

=====Aufgabe 7: Sequentielle Suche=====

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.

=====Aufgabe 8: Auswahlsort=====

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|
<code cpp>

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();
}
</code>
++++


===== Aufgabe 9: Array-Übung mit Zufallszahlen =====


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.

/*
++++ Lösung|
<code cpp>
void erzeugezahlen(int zahlen[12])
{
	for (int i=0;i<=11 ;i++ ) {
	   zahlen[i]=rand()%100+1; //Zufallszahl wird in die i-te Stelle des Arrays
							   //geschrieben
	}
}

void ausgabezahlen(int zahlen[12])
{
	for (int i=0;i<=11 ;i++ ) {
		cout << zahlen[i] << " "; //Die i-te Zahl des Arrays wird ausgegeben.
	}
}

int summe(int zahlen[12])
{
   int sum=0;
   for (int i=0;i<=11 ;i++ ) {
	   sum=sum+zahlen[i];
   }
   return sum;
}

float mittelwert(int zahlen[12])
{
	float mw;
	mw = summe(zahlen)/12.0;  //12.0 damit die Division ein float-Ergebnis liefert.
	return mw;
}

int anzahlgerade(int zahlen[12])
{
  int anzahl=0;
  for (int i=0;i<=11 ;i++ ) {
	  if(zahlen[i]%2==0) anzahl++;    //Erhöhung der Anzahl, wenn zahlen[i] gerade
  }
  return anzahl;
}

bool zahlvorhanden(int benutzerzahl, int zahlen[12])
{
	bool vorhanden=false;

	for (int i=0;i<=11 ;i++ ) {
	  if (zahlen[i]==benutzerzahl) {   //Überprüft, ob die i-te Zahl gleich der
		  vorhanden=true;              //Benutzerzahl ist, wenn ja, wird "vorhanden"
	  }                                //gleich true gesetzt.
	}
	return vorhanden;
}

int main()
{
   int zufallszahlen[12];
   int benutzerzahl;
   srand(time(0));  //Entsprechend der Systemzeit wird gemischt
   cout << "Dieses Programm erzeugt zwoelf Zufallszahlen zwischen 1 und 100.\n";
   erzeugezahlen(zufallszahlen);
   cout << "Ausgabe der Zufallszahlen: \n";
   ausgabezahlen(zufallszahlen);
   cout << "\nDie Summe aller Zahlen beträgt: " << summe(zufallszahlen);
   cout << "\nDer Mittelwert aller Zahlen beträgt: " << mittelwert(zufallszahlen);
   cout << "\nDie Anzahl der geraden Zahlen beträgt: " << anzahlgerade(zufallszahlen);
   cout << "\nDie Anzahl der ungeraden Zahlen beträgt: " << 12-anzahlgerade(zufallszahlen);

   cout << "\n\nBitte geben Sie eine Zahl zwischen 1 und 100 ein: ";
   cin >> benutzerzahl;

   if (zahlvorhanden(benutzerzahl,zufallszahlen)==true) {
	   cout << "\nIhre Zahl ist in der Liste vorhanden!";
   } else
   {
	   cout << "\nIhre Zahl kommt in der List nicht vor!";
   }

  getch();
  return 0;
}
</code>

++++
*/
===== Aufgabe 10: Bankomat =====


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:

<code>
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
...
</code>
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.


===== Aufgabe 11 - Verständnis-Aufgabe =====

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

<code cpp>
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)
}
</code>

----

===== Weitere Übungsaufgaben =====

Schreibe ein Programm, dass

<box 100% |<fc #0000ff>Ex 1</fc>>
...das eine Folge von n ganzen Zahlen einliest und jene Zahlen aus der Folge löscht, die mehrmals vorkommen. Anschließend soll die Folge ausgegeben werden.
</box>

++++ Lösung|
<code cpp delmultiple.cpp>
#include <iostream>
using namespace std;

main(){
int n;
cout<<"Anzahl Zahlen: "; cin>>n; cout<<endl;

int zahl[n];
cout<<"\nZahlen: \n";
for(int i=0;i<n;i++)cin>>zahl[i];

sort(zahl,zahl+n);

cout<<"\nSortiert ohne Wiederholung: \n";
cout<<zahl[0] <<" ";
for(int i=1;i<n;i++)
   if(zahl[i]!=zahl[i-1]) cout<<zahl[i]<<" ";

cout<<endl<<endl;
system("PAUSE");
</code>
++++


<box 100% |<fc #0000ff>Ex 2</fc>>
...das eine Folge von n ganzen Zahlen einliest und jene Zahlen aus der Folge löscht, die größer als eine vorgegebene Zahl sind. Anschließend soll die Folge ausgegeben werden.
</box>

++++ Lösung|
<code cpp delgreater.cpp>
#include <iostream>
using namespace std;

main(){
int *zf, max,anz;
cout<<"Anzahl der Zahlen: ";cin>>anz;
zf=new int[anz];
cout<<"\nMaxiaml hoechste Zahl: ";cin>>max;
cout<<"\nZahlen:\n";
for(int i=0;i<anz;i++)cin>>zf[i];
for(int j=0;j<anz;j++){if(zf[j]>max){zf[j]=max+1;}}
cout<<"\nSortierte, begrenzte Folge: \n";
sort(zf,zf+anz);
for(int l=0;l<anz;l++){if(zf[l]!=max+1){cout<<zf[l] <<" ";}}
delete[] zf;

cout<<endl<<endl;
system("PAUSE");
</code>
}
++++

<box 100% |<fc #0000ff>Ex 3</fc>>
...das eine maximal 80 Zeichen lange Zeichenfolge umdreht.
</box>

++++ Lösung|
<code cpp revers.cpp>
#include <iostream>
#include <conio.h>
using namespace std;

const char ENTER=13;

int main(){
 int i=0;
 char zeichen, zkette[80];
 cout<<"Zeichenfolge eingeben:\n";
 do {
   zeichen = getche();
   zkette[i]=zeichen;
   i++;
 } while (zeichen!=ENTER && i<80);
 cout<<endl<<endl;
 reverse(zkette,zkette+i);
 for(int j=0;j<i;j++)cout<<zkette[j];

 cout<<endl;
 system("PAUSE");
}
</code>
++++


<box 100% |<fc #0000ff>Ex 3a</fc>>
...das an einer maximal 40 Zeichen langen Zeichenfolge überprüft, ob es sich um ein Palindrom handelt.

Hinweis: Von einem Palindrom spricht man dann, wenn ein Wort von vorne und hinten gelesen gleich aussieht, z.B. LAGERREGAL
</box>

++++ Lösung|
<code cpp palindrom.cpp>
#include <iostream>
#include <conio.h>
using namespace std;
const char CR=13;

main()
{char zeichen; char zkette[100];
 cout<<"Geben Sie Ihre Zeichenkette ein (max. 100): \n";
 // Eingabe der Zeichenkette
 int i=0;
 do {
   zeichen = getche();
   zkette[i]=zeichen;
   i++;
 } while (zeichen!=CR);
 int laenge=i-1;
 // Ausgabe verkehrt
 cout<<"\nRueckwaerts gelesen:\n ";
 for(i=laenge-1;i>=0;i--) cout<<zkette[i];
 // Vergleich auf Palindrom-Eigenschaft
 i=0; while(zkette[i]==zkette[laenge-i-1]) i++;
 if (i==laenge) cout<<"\nEs handelt sich um ein Palindrom.";
 else cout<<"\nEs ist kein Palindrom.";

 cout<<"\n\n"; system("PAUSE");
}
</code>
++++

<box 100% |<fc #0000ff>Ex 4</fc>>
...das zwei steigend sortierte Buchstabenfolgen zu einer sortierten Folge zusammenfasst. In der Ergebnisfolge dürfen keine gleichen Buchstaben vorkommen. Bei der Eingabe soll überprüft werden, ob die Buchstabenfolgen steigend sortiert sind.
</box>

<box 100% |<fc #0000ff>Ex 5</fc>>
...das zwei monoton steigende Zahlenfolgen zu einer monoton steigenden Zahlenfolge zusammenfasst und ausgibt.
</box>

<box 100% |<fc #0000ff>Ex 6</fc>>
...das zwei gleichlange Wörter einliest und den HAMMING-Abstand berechnet: Als HAMMING-Ab-stand zweier Wörter mit gleichlangen Binärcodes wird die Anzahl jener Stellen bezeichnet, in denen sich die beiden Wörter unterscheiden.

Beispiel: \\ 001010110 101000110\\ HAMMING-Abstand:2
</box>

<box 100% |<fc #0000ff>Ex 7</fc>>
...das Vektoren verknüpft. Folgende Operationen sollen durchführbar sein:
   * Addition zweier Vektoren,
   * Subtraktion zweier Vektoren,
   * Multiplikation von Vektor und Skalar,
   * skalares Produkt zweier Vektoren.

Die Anzahl der Elemente der Vektoren soll mittels Konstante definiert werden. z.B. ''#define MAX 5''	
</box>

<box 100% |<fc #0000ff>Ex 8</fc>>
...das wie ein Auszählreim arbeitet: n Kinder sind im Kreis aufgestellt. Nach Aufsagen eines Auszählreimes mit m Silben wird das jeweils m-te Kind im Kreis ausgeschieden. Auszugeben ist die Reihenfolge, in der die Kinder ausscheiden.

Anleitung:
Jedem Kind ist ein Element eines Arrays zugeordnet. Zu Beginn werden sämtliche Elemente des Arrays gleich 1 gesetzt. Danach werden die Elemente zyklisch durchlaufen und das jeweils m-te Element gleich 0 gesetzt. Die Indizes der 0 gesetzten Elemente entsprechen den Nummern der ausgeschiedenen Kinder.
</box>

++++ Lösung|
<code cpp auszaehlreim.cpp>
// Auszählreim
#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;

int main()
{int n,m;
 cout << "\nBitte Anzahl der Kinder und Anzahl der Silben eingeben:\n";
 cin >> n >> m;
 int kind[n];
 // Initialierung des Feldes
 for (int i=0;i<n;i++) kind[i]=1;
 // Ausgabe
 // for (int i=0;i<n;i++) cout << "(" << i <<"|" << kind[i] <<")";
 cout << endl;

 clock_t sz,ez;
 sz = clock();

 // Auszählreim
 int pos=-1;
 for (int i=0;i<n;i++) {
    int z=1;
    while (z<=m){
       pos=(pos+1)%n;
       if (kind[pos]) z++;
    }
    kind[pos]=0;z=0;
    cout <<  pos  << ' ';
 }
 ez = clock();
 cout << "\nGesamtzeit: " << (ez-sz)/(double)CLOCKS_PER_SEC << "\n\n";


 system("PAUSE");
 return 0;
}
</code>
++++

<box 100% |<fc #0000ff>Ex 9</fc>>
...das alle Primzahlen, die kleiner oder gleich der natürlichen Zahl n sind, ausgibt.

Anleitung (Siebverfahren des ERATOSTHENES):
Verwende ein Array mit dem Index 0..n-2, dessen Elemente gleich 1 (wahr) gesetzt werden. Danach betrachtet man mit dem Index 0 beginnend der Reihe nach sämtliche Elemente mit dem Wert wahr und setzt jene Elemente gleich 0 (falsch), deren Indizes Vielfache des gerade betrachteten Indexwertes+2 sind. Die  Indizes jener  Elemente,  die den Wert wahr beinhalten, sind Primzahlen.
</box>

++++ Lösung|
<code cpp siebdeseratosthenes.cpp>
#include <iostream>
using namespace std;

main(){
 int n;
 cout <<"Geben Sie eine natuerliche Zahl ein: "; cin >>n; int z[n+1];
 z[1]=0; for(int i=2;i<=n;i++) z[i]=1;
 for(int i=3;i<=n;i++)
   for(int j=2;j<i;j++) if(i%j==0) z[i]=0;
 cout<<"\nAlle Primzahlen, die kleiner oder gleich der natuerlichen Zahl "<<n<<" sind:\n\n";
 for(int i=1;i<=n;i++)if(z[i]==1) cout<<i<<' ';
 cout << "\n\n"; system("PAUSE");
}
</code>
++++

<box 100% |<fc #0000ff>Ex 10</fc>>
...das ein Kartenspiel von 52 Karten an beliebig viele Spieler austeilt und das Blatt jedes Spielers sortiert ausgibt. Die Anzahl der Spieler soll eingegeben werden.
Beispiel:

{{:inf:cpp:adim-70-1.jpg?300|}}
</box>

<box 100% |<fc #0000ff>Ex 11</fc>>
... das einen Text gemäß der Cäsar-Verschlüsselung codiert.
Dabei wird jeder Buchstabe eines Textes durch seinen m-ten Nachfolger erstetzt.

z.B. Hallo Welt, m=3\\
wird zu Kdoor Zhow
</box>

++++ Lösung|
<code cpp caesarverschluesselung.cpp>
// Cäsar-Verschlüsselung
#include <iostream>
#include <conio.h>
using namespace std;

int main()
{int m,i=0;
 char text[100], vtext[100], zeichen;
 cout << "Cäsar-Vershluesselung\n\n";
 cout << "Bitte Verschiebung m angeben: "; cin >> m;
 // Eingabe des Textes
 cout << "\nBitte zu verschluesselnden Text eingeben ('.' fuer Ende) \n";
 do {
   zeichen = getche(); // cout << '*';
   text[i]=zeichen;
   i++;
 }
 while (zeichen!='.');
 // Ausgabe des Textes
 cout << endl;
 for (int j=0;j<(i-1);j++) cout << text[j];
 cout << endl;

 // Verschluesselung
 for (int j=0;j<(i-1);j++) {
   // Großbuchstaben verschlüsseln
   if (text[j]>= 65 && text[j] <=90) vtext[j]=(text[j]-65+m)%26+65;
   // Großbuchstaben verschlüsseln
   if (text[j]>= 97 && text[j] <=122) vtext[j]=(text[j]-97+m)%26+97;
 }

 // Ausgabe des codierten Textes
 cout << endl;
 for (int j=0;j<(i-1);j++) cout << vtext[j];
 cout << endl;


 system("PAUSE");
 return 0;
}

</code>
++++