dsf

.clang-format

@@ -49,7 +49,7 @@ BreakConstructorInitializersBeforeComma: false
 BreakConstructorInitializers: BeforeColon
 BreakAfterJavaFieldAnnotations: false
 BreakStringLiterals: true
-ColumnLimit:     80
+ColumnLimit:     120
 CommentPragmas:  '^ IWYU pragma:'
 CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: false

02_Basics/CharConverter/Exercise/lib.cc

@@ -2,28 +2,45 @@
 
 bool is_numeric(const char character)
 {
+    return (character>='0' && character<='9') ? true : false;
 }
 
 bool is_alpha(const char character)
 {
+    return (is_upper_case(character) || is_lower_case(character));
 }
 
 bool is_alpha_numeric(const char character)
 {
+    return (is_alpha(character) || is_numeric(character));
 }
 
 bool is_upper_case(const char character)
 {
+    return (character>='A' && character<='Z');
 }
 
 bool is_lower_case(const char character)
 {
+    return (character>='a' && character<='z');
 }
 
 char to_upper_case(const char character)
 {
+    if (is_lower_case(character))
+    {
+        return character - 32;
+    }
+
+    return character;
 }
 
 char to_lower_case(const char character)
 {
+    if (is_upper_case(character))
+    {
+        return character + 32;
+    }
+
+    return character;
 }

02_Basics/IntCalculator/Exercise/lib.cc

@@ -4,12 +4,42 @@
 
 std::uint32_t modulo(const std::uint32_t number_a, const std::uint32_t number_b)
 {
+    if (number_b > 0)
+    {
+        return number_a % number_b;
+    }
+    else return 0;
 }
 
-std::uint32_t sum_of_digits(std::uint32_t number)
+std::uint32_t sum_of_digits(const std::uint32_t number)
 {
+   /* if (number==0)
+    {
+        return 1;
+    }*/
+
+    std::uint32_t digits = 0;
+    std::uint32_t number_loop = number;
+    do
+    {
+        digits++;
+        number_loop /= 10;
+    }while(number_loop > 0);
+
+    return digits;
+
 }
 
-std::uint32_t cross_sum(std::uint32_t number)
+std::uint32_t cross_sum(const std::uint32_t number)
 {
+    std::uint32_t cross_sumvar = 0;
+    std::uint32_t number_loop = number;
+
+    while (number_loop>0)
+    {
+        cross_sumvar+=number_loop%10;
+        number_loop/=10;
+    }
+
+    return cross_sumvar;
 }

02_Basics/MathCalculator/Exercise/lib.cc

@@ -5,8 +5,31 @@
 
 double calculate_pi(const std::uint32_t num_iterations)
 {
+    double calculate=0;
+
+    for (std::uint32_t n = 0; n <= num_iterations; n++)
+    {
+        calculate += (( 1.0 / (4.0 * n + 1.0) ) - ( 1.0 / (4.0 * n + 3.0) ));
+    }
+    return calculate*4;
 }
 
 void print_dec_to_bin(std::uint8_t value)
 {
+    std::cout << "Die Dezimalzahl : " << static_cast<std::uint32_t>(value) << " in binär ist : 0b";
+    for (std::int8_t exponent = 7; exponent >= 0; exponent--)
+    {
+        std::uint8_t exponenti8 = static_cast<std::uint8_t>(std::pow(2,exponent));
+
+        if (value >= exponenti8)
+        {
+            std::cout << "1";
+            value -= exponenti8;
+        }
+        else
+        {
+            std::cout << "0";
+        }
+    }
+    std::cout << "\n\n";
 }

02_Basics/MathCalculator/Exercise/main.cc

@@ -15,8 +15,8 @@ int main()
     double pi_calculated = calculate_pi(num_iterations);
 
     std::cout << std::setprecision(30);
-    std::cout << "pi (calculated): " << pi_calculated << '\n';
-    std::cout << "pi (correct): " << pi << '\n';
+    std::cout << "pi (calculated): \t" << pi_calculated << '\n';
+    std::cout << "pi (correct): \t\t" << pi << '\n';
 
     std::uint8_t dec = 0b10001110;
     print_dec_to_bin(dec);

02_Basics/TimeConverter/Exercise/lib.cc

@@ -4,24 +4,30 @@
 
 float convert_milliseconds_to_seconds(const float milliseconds)
 {
+    return milliseconds/1000;
 }
 
 float convert_seconds_to_minutes(const float seconds)
 {
+    return seconds/60;
 }
 
 float convert_minutes_to_hours(const float minutes)
 {
+    return minutes/60;
 }
 
 float convert_milliseconds_to_minutes(const float milliseconds)
 {
+    return convert_seconds_to_minutes(convert_milliseconds_to_seconds(milliseconds));
 }
 
 float convert_milliseconds_to_hours(const float milliseconds)
 {
+    return convert_minutes_to_hours(convert_milliseconds_to_minutes(milliseconds));
 }
 
 float convert_seconds_to_hours(const float seconds)
 {
+    return convert_minutes_to_hours(convert_seconds_to_minutes(seconds));
 }

03_ArrayPointer/AlgoLib/Exercise/lib.cc

@@ -7,22 +7,68 @@ bool all_of(const std::int32_t *array,
             const std::size_t length,
             const std::int32_t value)
 {
+    if (array!=nullptr && length>0)
+    {
+        std::int32_t counttruevalue = 0;
+        for (std::int32_t i = 0; i < length; i++)
+        {
+            if (array[i] == value) counttruevalue++;
+        }
+
+        return ((counttruevalue==length-1) ? (true):(false));
+    }
+
+    return false;
 }
 
 bool any_of(const std::int32_t *array,
             const std::size_t length,
             const std::int32_t value)
 {
+    if (array!=nullptr && length>0)
+    {
+        for (std::int32_t i = 0; i < length; i++)
+        {
+            if (array[i] == value) return true;
+        }
+
+        return false;
+    }
+
+    return false;
 }
 
 bool none_of(const std::int32_t *array,
              const std::size_t length,
              const std::int32_t value)
 {
+    if (array!=nullptr && length>0)
+    {
+        for (std::int32_t i = 0; i < length; i++)
+        {
+            if (array[i] == value) return false;
+        }
+
+        return true;
+    }
+
+    return false;
 }
 
 std::size_t count(const std::int32_t *array,
                   const std::size_t length,
                   const std::int32_t value)
 {
+    if (array!=nullptr && length>0)
+    {
+        std::int32_t counttruevalue = 0;
+    for (std::int32_t i = 0; i < length; i++)
+    {
+        if (array[i] == value) counttruevalue++;
+    }
+
+    return counttruevalue;
+    }
+
+    return 100;
 }

03_ArrayPointer/ArrayLibrary/Exercise/lib.cc

@@ -6,12 +6,52 @@
 
 void remove_duplicates(std::int32_t *array, std::size_t &length)
 {
+    if (array == nullptr || length < 2)
+    {
+        return;
+    }
+
+    for (std::size_t i = 0; i < length; i++) //äußere Schleife, äußeres Schleifenelement welches gerade verglichen wird
+    {
+        for (std::size_t j = i + 1; j < length;
+             j++) //innere Schleife, Elemente werden mit aüßerem Schleifenelement verglichen
+        {
+            if (array[i] == array[j]) //wenn Elemente gleich, dann length-- und alle nach links verschieben
+            {
+                length--;
+                for (std::size_t k = j; k < length; k++)
+                {
+                    array[k] = array[k + 1];
+                }
+            }
+        }
+    }
 }
 
 void rotate_left(std::int32_t *array, std::size_t length)
 {
+    if (array == nullptr || length < 2)
+    {
+        return;
+    }
+    auto memory = array[0];
+    for (std::size_t i = 0; i < length - 1; i++)
+    {
+        array[i] = array[i + 1];
+    }
+    array[length - 1] = memory;
 }
 
 void rotate_right(std::int32_t *array, std::size_t length)
 {
+    if (array == nullptr || length < 2)
+    {
+        return;
+    }
+    auto memory = array[length - 1];
+    for (std::size_t i = length - 1; i > 0; i--)
+    {
+        array[i] = array[i - 1];
+    }
+    array[0] = memory;
 }