switch language to english

Lösungen

<< Zurück

(Zur Hauptseite, zur Übungsseite)

Übung 1: Unix

kommt (vielleicht) noch...

Übung 2: Hallo Welt

Zur Aufgabe
 #include <iostream>    // zur Ausgabe von Streams
 
 using namespace std;
 
 int main (void)        // Hauptprogramm (ohne Argumente) void kann auch weggelassen werden
 {
   //Textausgabe:
   float x = 0.5;
   int a = 10;
 
   cout << "Hallo Welt!" << endl;
 
   cout << "ein Float: " << x << endl;
   cout << "ein Int: "   << a << endl;
 
   char richtung;
   cout << "In Welche Richtung wollen Sie gehen? N,S,O,W?" << endl;
   cin >> richtung;
 
   int schritte;
   cout << "Wie viele Schritte?" << endl;
   cin >> schritte;
 
   cout << "Gehen Sie " << schritte << " Schritte in Richtung: " << richtung << endl;
 
   // Programm beenden
   return 0;
 }

Übung 3a: Datentypen und verschiedene Operatoren

Zur Aufgabe
 #include <iostream>
 using namespace std;   // 'std::' kann man damit weglassen...
 
 int main ()
 {
   std::cout << "Size of int: " << sizeof(int) << std::endl;
   std::cout << "Size of char: " << sizeof(char) << std::endl;
   std::cout << "Size of bool: " << sizeof(bool) << std::endl;
   std::cout << "Size of float: " << sizeof(float) << std::endl;
   std::cout << "Size of double: " << sizeof(double) << std::endl;
   std::cout << "Size of long: " << sizeof(long) << std::endl;
   std::cout << "Size of unsigned: " << sizeof(unsigned) << std::endl;
 
   unsigned char a=255;  // ein char würde hier -1, die Typumwandlung ergäbe unten dann einen anderen Wert
   std::cout << "char a=255 result =  " << (unsigned)a << std::endl;
   a = 256;      
   std::cout << "char a=256 result =  " << (unsigned)a << std::endl;
 
   char bitvector = 0b1101;
   char comp = 0b1000;
 
   std::cout << "Bit vector = " << (int)bitvector << " comp = " << (int)comp << std::endl;   
 
   std::cout << "Bit nummer 4 ist :" << (bitvector & comp) != 0 << std::endl;   
   comp >>=1;
   std::cout << "Bit nummer 3 ist :" << (bitvector & comp) != 0 << std::endl;
   comp >>=1;
   std::cout << "Bit nummer 2 ist :" << (bitvector & comp) != 0 << std::endl;
   comp >>=1;
   std::cout << "Bit nummer 1 ist :" << (bitvector & comp) != 0 << std::endl;
 
   int value = 2104;
   int comp2 = 1<<11;
   std::cout << "Bit nummer 11 von " << value << " ist :" << (bool)(value & comp2) << std::endl;
   comp2 = 1<<12;
   std::cout << "Bit nummer 12 von " << value << " ist :" << (bool)(value & comp2) << std::endl;
 
 
   return 0;            
 }

Übung 3b: Boolsche Operatoren

Zur Aufgabe Die Lösungen sind einfach selbst auszuprobieren, zur Überprüfung dennoch:
  • 1) a=false, b=false, c=true, d=true, e=true
  • 2) setzte b3=false
  • 3) c=true, d=false, e=false
  • 4) a,b,e
  • 5) a,b


  • Übung 3c: Kleines Einmaleins

    Zur Aufgabe
     #include <iostream>
     #include <iomanip>
     using namespace std;   // 'std::' kann man damit weglassen...
     
     int main ()
     {
       const int NN = 10;   // Zeige 1 ... (NN-1) an!
     
       for (int izeile=1; izeile < NN; izeile++)  // lokale Definition von 'zeile'!
       {
         for (int ispalte=1; ispalte < NN; ispalte++)
         {
           // Ausgabelänge mit setw(3) auf 3 Zeichen festlegen.
           // Auch möglich mit: cout.width(3); 
           cout << setw(3) << ispalte * izeile;
         }
         cout << endl;      // Zeilenumbruch am Ende einer Zeile erzeugen
       }
       return 0;            // Ende ohne Fehler melden
     }


    Übung 4a: Kontrollstrukturen

    Zur Aufgabe
     #include <iostream>
     #include <string>
     
     using namespace std;   // 'std::' kann man damit weglassen...
     
     int main ()
     {
        while (true) 
        {
          cout << "Geben Sie eine Zahl von 0-99 ein:" << endl;
          int a;
          cin >> a;
     
          if(a<0){
            cout << "Abbruch durch benutzer!" << endl;
            return 0;
          }
     
          cout << "Die Zahl war " << a << endl;
     
          string zahl;
     
          int s1 = a%10;
          int s2 = (a/10)%10;
     
          if(s2==0){
            if(s1==0){
              zahl = "null";
            }else if(s1==1){
              zahl = "eins";
            }else if(s1==2){
              zahl = "zwei";
            }else if(s1==3){
              zahl = "drei";
            }else if(s1==4){
              zahl = "vier";
            }else if(s1==5){
              zahl = "fünf";
            }else if(s1==6){
              zahl = "sechs";
            }else if(s1==7){
              zahl = "sieben";
            }else if(s1==8){
              zahl = "acht";
            }else if(s1==9){
              zahl = "neun";
            }
          }
          else if(s2==1)
          {
            if(s1==1){
              zahl = "elf";
            }else if(s1==2){
              zahl = "zwölf";
            }else{
              if(s1==3){
                zahl = "drei";
              }else if(s1==4){
                zahl = "vier";
              }else if(s1==5){
                zahl = "fünf";
              }else if(s1==6){
                zahl = "sech";
              }else if(s1==7){
                zahl = "sieb";
              }else if(s1==8){
                zahl = "acht";
              }else if(s1==9){
                zahl = "neun";
              }
              zahl += "zehn";
            }
          }else{
            if(s1==1){
              zahl = "einund";
            }else if(s1==2){
              zahl = "zweiund";
            }else if(s1==3){
              zahl = "dreiund";
            }else if(s1==4){
              zahl = "vierund";
            }else if(s1==5){
              zahl = "fünfund";
            }else if(s1==6){
              zahl = "sechsund";
            }else if(s1==7){
              zahl = "siebenund";
            }else if(s1==8){
              zahl = "achundt";
            }else if(s1==9){
              zahl = "neunund";
            }
     
            if(s2==2){
              zahl += "zwanzig";
            }else if(s2==3){
              zahl += "dreißig";
            }else if(s2==4){
              zahl += "vierzig";
            }else if(s2==5){
              zahl += "fünfzig";
            }else if(s2==6){
              zahl += "sechzig";
            }else if(s2==7){
              zahl += "siebzig";
            }else if(s2==8){
              zahl += "achtzig";
            }else if(s2==9){
              zahl += "neunzig";
            }
          }
     
          cout << "Die Zahl war " << zahl << endl;
        }
        return 0;
    }

    Übung 4b: Zahlen in Einmaleins

    Zur Aufgabe
     #include <iostream>
     
     int main()
     {
       const int N  = 10;                 // Größe (1..N)
       const int NN = N * N;              // maximale Zahl ist N*N
       bool found[NN];                    // Markiere hier die gefundenen Zahlen
                                          // ACHTUNG: erlaubt ist found[0] .. found[NN-1]
       int charwidth = 2;                 // Zum Spass: ermittle die benötigte Buchstabenbreite
       int t = NN;                        //  für beliebige NN
       while (t>=10) {t/=10; charwidth++;}// bildet den 10er logarithmus von t
     
       for (int i=0; i < NN; i++) found[i] = false;  // alle Werte als 'nicht gefunden' markieren
     
       for (int iy=1; iy <= N; iy++) {    // Einmaleins ausgeben
         for (int ix=1; ix <= N; ix++) {  // s. Kommentar (1)
           std::cout.width(charwidth);
           std::cout << ix * iy;
           found[ix * iy - 1] = true;     // Produkt markieren. S. Kommentar (2)
         }                                // beachte die '-1', um nicht auf found[NN] zuzugreifen
         std::cout << std::endl;
       }
     
       int count = 0;
       for (int i=0; i < NN; i++) if (found[i]) count++;   // Anzahl 'true' zählen
     
       std::cout << "There are " << count << " different numbers" << std::endl;
       return 0;
     }

    Das dynamische Anlegen des 'found' array geht mit
     bool *found = new bool[NN];
     ...
     delete[] found;

    Verbesserungsmöglichkeiten: * Da das Einmaleins symmetisch um die Diagonale ist (wegen ix * iy iy * ix) muss man nicht alle N*N Elemente durchprobieren: Es reicht, wenn man mit ix jeweils nur bis zur Diagonale (inclusive) geht, also die Zeile (1) durch for (int ix=1 ; ix <= iy; ix++) { ersetzt. * Man kann die verschiedenen Zahlen auch gleich zählen, wenn man sie im found[] array markiert: Man erhöht also count, sobald ein found-Element gesetzt werden soll, das vorher noch nicht gesetzt war. Man ersetzt also (2) durch: int k = ix * iy - 1; if (!found[k]) {found[k]=true; count++;} und spart sich das Aufsummieren. Überlegen Sie, welche Methode effizienter ist....

    Übung 5: Anzahl von Primzahlen

    Zur Aufgabe
     #include <math.h>       /* sqrt */
     #include <iostream>
     #include <fstream>
     
     // g++ -o anzahlPrimzahlen anzahlPrimzahlen.cpp
     
     using namespace std;
     
     int anzahlPrimzahlen (int n)
     {
       int freq=n-1;                  //1 ist keine Primzahle
     
       for (int i=3; i<=n; ++i)       // 2 ist Primzahl daher starten wir bei 3
       { 
         for (int j=2;j<=sqrt(i);j++) // durch Aufwärts-Zählen fliegen gerade Zahlen 
         {                            //       schneller raus   
           if (i%j==0)                // i durch j ohne Rest Teilbar
           {
             freq--;                  // Nicht-Primzahl gefunden
             break;                   // weiter mit nächstem i
           }
         }
       }
       return freq;
     }
     
     
     int main ()
     {
       int value = 100000;            // kann man auch mit cin >> value vom Benutzer abfragen
       int f;
       cout << "Calculating..." << endl;
     
       f = anzahlPrimzahlen(value);
     
       cout << f << " Primzahlen gefunden, die kleiner sind als " << value << endl;
       return 0;
     }

    Da die Anzahl der Teiler einer Zahl symmetrisch um sqrt(i) verteilt sind starten wir mit sqrt(i) anstatt i-1. Das spart viel Rechenzeit, da nur ein Bruchteil der Zahlen verglichen werden müssen.

    Übung 6: Sortieren

    Zur Aufgabe
     #include <iostream>
     using namespace std;
     
     int main (void)
     {
       const int SIZE = 10;
       int number []  = {1,5,3,8,5,7,3,9,3,10};
     
       for (int startpos = 0; startpos < SIZE; startpos++) {
         int smallest = number[startpos];            // Annahme: kleinste Zahl ist bei startpos
         int ipos     = startpos;                    // Position der "kleinsten" Zahl merken
         for (int i=startpos+1; i < SIZE; i++) {       // nach kleineren Zahlen suchen
           if (number[i] < smallest) {
             ipos = i;                               // Kleienere Zahl gefunden:
             smallest = number[i];                   // Neue Position und den Wert merken
           }
         }
         number[ipos]     = number[startpos];        // Vordere Zahl nach hinten kopieren
         number[startpos] = smallest;                // Kleinste Zahl nach vorne holen
       }
     
       for (int i=0; i < SIZE; i++) cout << number[i] << ' ';
       cout << endl;
     
       return 0;
     }

    Dieser Algorithmus ist nicht effizient: die Laufzeit steigt quadratisch mit der Feldgröße N. Es gibt schnelle Algorithmen, die mit N*log(N) skalieren: Wenn der Aufwand für ein Feld der Länge N i.W. N^2 ist, dann kostet das Sortieren von zwei halben Feldern (mit je N/2) nur 2*(N/2)^2 = N^2/2, ist also schneller. (Die zwei sortierten Felder müssen dann noch gemischt werden, was aber schnell geht). Wenn man das weiter treibt (also die N/2 langen Felder in N/4 lange Felder teilt u.s.w.), so kommt man auf einen sehr effizienten (aber komplizierten) Algorithmus.
    Natürlich gibt es auch einen Sortier-Algorithmus in der Standardbibliothek. Dafür füllt man einfach alle Werte in beliebiger Reihenfolge in einen Standard-Container, z.B. einen std::vector und übergibt diesen Vector der Sortierfunktion, zu finden in <algorithm>

    Übung 7a: Zeiger

    Zur Aufgabe Kommt vielleicht später noch

    Übung 7b: Zeiger und Speicherverwaltung

    Zur Aufgabe
     #include <iostream>
     #include <fstream>
     using namespace std;
     
     struct Point{
       int x,y;
     };
     
     //Zeiger auf Punkte-Array als Points kann genauso verwendet werden wie "Point*"
     typedef Point* Points;
     
     Point* createLinearPoints(int N)
     {
       // Das Feld von N Points muss hier mit new Erzeugt werden
       // Wenn man das Feld als array Points pts[N]; anlegen würde,
       // würde es beim Verlassen gelöscht werden, und ausserhalb nichtmehr
       // zur Verfügung stehen.
       Point* pts = new Point[N];
     
       for(int i=0; i<N; i++){
         pts[i].x = i;
         pts[i].y = i;
       }
     
       return pts;
     }
     
     void printPoints(int N, Point * pts)
     {
       for(int i=0; i<N; i++){
         cout << pts[i].x << "\t" << pts[i].y << endl;
       }
     }
     
     void printPointsToFile(int N, Point * pts)
     {
       ofstream ofs("points.dat",ofstream::out);
       for(int i=0; i<N; i++){
         ofs << pts[i].x << "\t" << pts[i].y << endl;
       }
       ofs.close();
     }
     
     int main (void)
     {
       int numPoints;
       cout << "Wieviele Punkte sollen erzeugt werden?" << endl;
       cin>> numPoints;
     
       Point * pts = createLinearPoints(numPoints);
     
       printPoints(numPoints,pts);
       printPointsToFile(numPoints,pts);
     
       delete [] pts;  // ganz am Ende muss das Feld wieder freigegeben werden
     
       return 0;
     }

    Wer die Ausgabe in einen Plot mit gnuplot ausprobieren möchte, kann sich das plotscript plot.gp in den Ordner der Uebung 7 kopieren und mit dem Befehl gnuplot plot.gp aus der Konsole ausführen. Es wird dann eine .png Datei erstellt, die den Plot enthält.

    Übung 8: MyVector Klasse

    Zur Aufgabe

    Hauptprogramm main.cpp

      #include <iostream>
     
      // g++ -c myVector.cpp
      // g++ -c main.cpp
      // g++ -o myVector main.o myVector.o
      //
      // Alles zusammen
      // g++ -o myVector main.cpp myVector.cpp
     
      #include "myVector.h"
     
      using namespace std;
     
      int main()
      {
        MyVector v(5,2);
        MyVector u(2,1);
     
        cout << "Vector v is: ";
        v.print();
     
        cout << "Vector u is: ";
        u.print();
     
        MyVector w = u+v;
     
        cout << "Vector w after u+v is: ";
        w.print();
     
        w+=u;
        cout << "Vector w after w+=u is: ";
        w.print();
     
        w=v-u;
        cout << "Vector w after w=v-u is: ";
        w.print();
     
        cout << "SkalarProduct w*v is: " << w*v << endl;
     
        return 0;
      }

    Lösung myVector.h

      #ifndef MYVECTOR_H
      #define MYVECTOR_H
     
        class MyVector
        {
     
        public:
            MyVector();
            MyVector(float x_, float y_);
     
            MyVector operator+(MyVector other_vector);
            MyVector operator-(MyVector other_vector);
            MyVector operator+=(MyVector other_vector);
            int operator*(MyVector other_vector);
     
            void print();
     
        private:
            float x;
            flaot y;
        };
     
      #endif

    Lösung myVector.cpp

      #include <iostream>
     
      // g++ -c myVector.cpp
     
      #include "myVector.h"
     
      using namespace std;
     
      void MyVector::print()
      {
        cout << "x(" << x << ") ";
        cout << "y(" << y << ") ";
        cout << endl;
      }
     
      MyVector::MyVector()
        : x(0),y(0)
      {
        cout << "Vector generated" << endl;
      }
     
      MyVector::MyVector(float x_, float y_)
      {
        x= x_;
        y= y_;
     
        cout << "Vector generated" << endl;
      }
     
      MyVector MyVector::operator+(MyVector other_vector)
      {
        int newX = x + other_vector.x;
        int newY = y + other_vector.y;
     
        MyVector newVec(newX,newY);
     
        return newVec;
      }
     
      MyVector MyVector::operator-(MyVector other_vector)
      {
        int newX = x - other_vector.x;
        int newY = y - other_vector.y;
     
        MyVector newVec(newX,newY);
     
        return newVec;
      }
     
      MyVector MyVector::operator+=(const MyVector & other_vector)
      {
        x += other_vector.x;
        y += other_vector.y;
     
        return *this;
      }
     
      int MyVector::operator*(MyVector other_vector)
      {
        int scalarProduct = x * other_vector.x + y * other_vector.y;
        return scalarProduct;
      }

    Übung 9: Spielfeld

    Zur Aufgabe

    Hauptprogramm:

     #include <iostream>
     
     using namespace std;
     
     #include "Spielfeld.h"               // Deklaration des Spielfelds
     
     int main ()
     {
       int anzahl = 1;
       char s;
       bool exit = false;
     
       Spielfeld sp(5,5);
     
       cout << "Wohin willst du gehen? w,s,a,d - q für Ende. " << endl;
     
       while (!exit)
       {
         cin>>s;
     
         if(s == 'q'){
           exit = true;
         }else{
     
           cout << "Gehe nach ";
     
           if(s == 's'){
             cout << "Süden" << endl;
           } else if(s=='a'){
             cout << "Westen" << endl;
           } else if(s=='d'){
             cout << "Osten" << endl;
           } else if(s=='w'){
             cout << "Norden" << endl;
           }else{
             cout << "Ungültig" << endl;
             //exit = true;
             continue;
           }
           sp.bewegen(s,anzahl);
           sp.print();
         }
       }
     
       return 0;
     }

    Spielfeld.h:

     class Spielfeld{
       public:
     
         struct Position{int x,y;};
     
         Spielfeld(int sizeX_, int sizeY_);
         ~Spielfeld();
     
         void bewegen(char richtung, int anzahl);
         void print();
     
       private:
         char feld[20][20];
         Position pos;
     
     };

    Spielfeld.cpp:

     #include <iostream>
     
     #include "Spielfeld.h"
     
     using namespace std;
     
     Spielfeld::Spielfeld(int startX, int startY)
     {
       pos.x = startX;
       pos.y = startY;
     
       for(int x=0; x<20; x++){
         for(int y=0; y<20; y++){
           feld[x][y] = ' ';
         }
       }
     }
     
     Spielfeld::~Spielfeld()
     {
     }
     
     void Spielfeld::print()
     {
       for(int y=0; y<20; y++){
         for(int x=0; x<20; x++){
           cout << feld[x][19-y] << ".";
         }
         cout << endl;
       }
     }
     
     void Spielfeld::bewegen(char richtung, int anzahl)
     {
       if(richtung=='s'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x][pos.y--] = 'v';
           if(pos.y<0) pos.y = 19;
         }
       } else if(richtung=='a'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x--][pos.y] = '<';
           if(pos.x<0) pos.x = 19;
         }
       } else if(richtung=='d'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x++][pos.y] = '>';
            if(pos.x>19) pos.x = 0;
         }
       } else if(richtung=='w'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x][pos.y++] = '^';
           if(pos.y>19) pos.y = 0;
         }
       }
       feld[pos.x][pos.y] = 'X';
     }

    Dynamisch erzeugt: Spielfeld.h:

     class Spielfeld{
       public:
     
         struct Position{int x,y;};
     
         Spielfeld(int sizeX_, int sizeY_, int startX, int startY);
         ~Spielfeld();
     
         void bewegen(char richtung, int anzahl);
         void print();
     
       private:
         char **feld;    // dies ist ein Feld (*) von Feldern vons chars (char*)
         Position pos;
     
         int sizeX,sizeY;
     };

    Dynamisch erzeugt: Spielfeld.cpp:

     Spielfeld::Spielfeld(int sizeX_, int sizeY_, int startX, int startY)
       : sizeX(sizeX_),
         sizeY(sizeY_)
     {
       pos.x =startX;
       pos.y =startY;
       feld = new char *[sizeX];   // wir legen ein Feld an das auf ein Feld von chars zeigt, also char*
       for(int x=0; x < sizeX; x++){
         feld[x] = new char[sizeY];    // an jedem Platz von feld, werden nun sizeY chars angelegt
       }
     
       for(int x=0; x < sizeX; x++){
         for(int y=0; y< sizeY_; y++){
           feld[x][y] = ' ';
         }
       }
     }
     
     Spielfeld::~Spielfeld()
     { // beim Freigeben wird genausp vorgegangen wie beim Anlegen
       for(int x=0; x < sizeX; x++){
         delete [] feld[x];
       }
     
       delete [] feld;
     }
     
     void Spielfeld::print()
     {
       for(int y=0; y < sizeY; y++) {
         for(int x=0; x < sizeX; x++){
           cout << feld[x][sizeY-y] << ".";   // wenn 0,0 unten links sein soll 
                                              // muss y anders herum durchlaufen werden
         }
         cout << endl;
       }
     }
     
     void Spielfeld::bewegen(char richtung, int anzahl)
     {  // je nachdem in welche Richtung gegangen wird wird das letzte
        // Feld mit einem anderen Zeichen beschrieben, 
        // dann wird die posizion aktualisiert und am Ende X neu gesetzt
       if(richtung=='s'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x][pos.y--] = 'v';
           if(pos.y<0) pos.y = sizeY-1;
         }
       } else if(richtung=='a'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x--][pos.y] = '<';
           if(pos.x<0) pos.x = sizeX-1;
         }
       } else if(richtung=='d'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x++][pos.y] = '>';
           if(pos.x>(sizeX-1)) pos.x = 0;
          }
       } else if(richtung=='w'){
         for(int y=0; y < anzahl; y++){
           feld[pos.x][pos.y++] = '^';
           if(pos.y>(sizeY-1)) pos.y = 0;
         }
       }
       feld[pos.x][pos.y] = 'X';
     }

    Übung 10: Standard-Container und c++11

    Zur Aufgabe

     #include <cmath>
     #include <array>
     #include <vector>
     #include <chrono>
     #include <iostream>
     using namespace std;
     
     // simple print functon
     void printArray(const array<char,3> &toPrint)
     {
       for(const auto & i:toPrint)
         cout << i << " ";
     
       cout << endl;
     }
     
     // simple print functon
     void printVector(const vector<char> &toPrint)
     {
       for(const auto & i:toPrint)
         cout << i << " ";
     
       cout << endl;
     }
     
     // recursive function to add a new combination of variable length
     void addCombination(int length, vector<vector<char>> & combinations, vector<char> &nextCombination, const array<char,7> &alphabet)
     {
       for(const auto & i:alphabet){
         nextCombination[length-1] = i;
         if(length>1){
           addCombination(length-1,combinations,nextCombination,alphabet);
         }else{
           combinations.push_back(nextCombination);
         }
       }
     }
     
     // recursive function to add a new selecton of variable length
     void addSelection(int length, vector<vector<char>> & selections, vector<char> &nextSelection, vector<char> alphabet)
     {
       for(const auto & ch:alphabet){
         nextSelection[length-1] = ch;
         vector<char> newAlphabet;
         for(const auto & add:alphabet){
           if(add != ch){
             newAlphabet.push_back(add);
           }
         }
         if(length>1){
           addSelection(length-1,selections,nextSelection,newAlphabet);
         }else{
           selections.push_back(nextSelection);
         }
       }
     }
     
     // smart timer struct that start the clock at initialization
     struct Timer{
       Timer();
       ~Timer();
     
       chrono::high_resolution_clock::time_point start;
     };
     
     // start clock
     Timer::Timer(){
       start = chrono::high_resolution_clock::now();
     }
     
     //stop clock and print lapsed time
     Timer::~Timer(){
       cout << "Lapsed time was " << chrono::duration_cast<chrono::microseconds>(chrono::high_resolution_clock::now()-start).count() << " microseconds" << endl;
     }
     
     int main()
     {
       array<char,7> alphabet = {'c','d','e','f','g','a','h'};
     
       //Declaration of the result vectors
       vector<array<char,3>> combinations, selections;
       {
         cout << "Slow Solution Combinations : ";
         Timer t;                                   // start timer
         // iterate three times through all letters of the alphabet
         for (const auto & x1 : alphabet){
           for (const auto & x2 : alphabet){
             for (const auto & x3 : alphabet){
               combinations.push_back({x1,x2,x3});  // push_back is rather slow
             }
           }
         }
       } // timer destructor is called and time is printed on console
     
       {
         cout << "Slow Solution Selections : ";
         Timer t;
         // iterate three times through all letters of the alphabet
         for (const auto & x1 : alphabet){
           for (const auto & x2 : alphabet){
             for (const auto & x3 : alphabet){
               if(x1 != x2 && x1 != x3 && x2 != x3){
                 selections.push_back({x1,x2,x3});  // add only if all letters are different
               }
             }
           }
         }
       }
     
       {
         cout << "Fast Solution Combinations : ";
         Timer t;
         // if size of final vector is known before it is faster to initialize it
         // and set all entries using the [] operator
         combinations = vector<array<char,3>>(alphabet.size()*alphabet.size()*alphabet.size());
         int i=0;
         for (const auto & x1 : alphabet){
           for (const auto & x2 : alphabet){
             for (const auto & x3 : alphabet){
               combinations[i++] = {x1,x2,x3};
             }
           }
         }
       }
     
       {
         cout << "Fast Solution Selections : ";
         Timer t;
         selections = vector<array<char,3>>(alphabet.size()*(alphabet.size()-1)*(alphabet.size()-2));
         int i=0;
         for (const auto & x1 : alphabet){
           for (const auto & x2 : alphabet){
             for (const auto & x3 : alphabet){
               if(x1 != x2 && x1 != x3 && x2 != x3){
                 selections[i++] = {x1,x2,x3};
               }
             }
           }
         }
       }
     
       // for variable results use a vector of vectors
       vector<vector<char> > varCombinations, varSelections;
     
       int userLength;
     
       cout << "Select length of arrays:" << endl;
       cin >> userLength;
     
       if(userLength > alphabet.size()){
         cout << "Error no combination of " << alphabet.size() << " possible with " << userLength << " entries" << endl;
         return 0;
       }
     
       {
         Timer t;
         vector<char> nextArray(userLength); // initialize nextArray with requested length
         addCombination(userLength,varCombinations,nextArray,alphabet);
       }
     
       cout << varCombinations.size() << " combinations found for length " << userLength << endl;
     
       {
         Timer t;
         vector<char> nextArray(userLength);
         vector<char> alphabetVector;
         alphabetVector.insert(alphabetVector.end(),alphabet.begin(),alphabet.end());
     
         addSelection(userLength,varSelections,nextArray,alphabetVector);
       }
     
       cout << varSelections.size() << " combinations found for length " << userLength << endl;
     
     
       //for(const auto & c : combinations){
       //  printArray(c);
       //}
     
       //for(const auto & s : selections){
       //  printArray(s);
       //}
     
       return 0;
     }


    zum Seitenanfang