diff --git a/.clang-format b/.clang-format
index 4a6e50a..3241cee 100644
--- a/.clang-format
+++ b/.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
diff --git a/02_Basics/CharConverter/Exercise/lib.cc b/02_Basics/CharConverter/Exercise/lib.cc
index 359d655..2a20374 100644
--- a/02_Basics/CharConverter/Exercise/lib.cc
+++ b/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;
 }
diff --git a/02_Basics/IntCalculator/Exercise/lib.cc b/02_Basics/IntCalculator/Exercise/lib.cc
index 21f9e21..ff57126 100644
--- a/02_Basics/IntCalculator/Exercise/lib.cc
+++ b/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;
 }
diff --git a/02_Basics/MathCalculator/Exercise/lib.cc b/02_Basics/MathCalculator/Exercise/lib.cc
index a5a7c9a..55d7314 100644
--- a/02_Basics/MathCalculator/Exercise/lib.cc
+++ b/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";
 }
diff --git a/02_Basics/MathCalculator/Exercise/main.cc b/02_Basics/MathCalculator/Exercise/main.cc
index d82535d..d90b2f4 100644
--- a/02_Basics/MathCalculator/Exercise/main.cc
+++ b/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);
diff --git a/02_Basics/TimeConverter/Exercise/lib.cc b/02_Basics/TimeConverter/Exercise/lib.cc
index 7644b72..8cf91e6 100644
--- a/02_Basics/TimeConverter/Exercise/lib.cc
+++ b/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));
 }
diff --git a/03_ArrayPointer/AlgoLib/Exercise/lib.cc b/03_ArrayPointer/AlgoLib/Exercise/lib.cc
index 69328f9..25f1953 100644
--- a/03_ArrayPointer/AlgoLib/Exercise/lib.cc
+++ b/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;
 }
diff --git a/03_ArrayPointer/ArrayLibrary/Exercise/lib.cc b/03_ArrayPointer/ArrayLibrary/Exercise/lib.cc
index 6ca288e..75bf874 100644
--- a/03_ArrayPointer/ArrayLibrary/Exercise/lib.cc
+++ b/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;
 }
diff --git a/03_ArrayPointer/StringLibrary/Exercise/lib.cc b/03_ArrayPointer/StringLibrary/Exercise/lib.cc
index 39eb4b2..4491df3 100644
--- a/03_ArrayPointer/StringLibrary/Exercise/lib.cc
+++ b/03_ArrayPointer/StringLibrary/Exercise/lib.cc
@@ -59,16 +59,6 @@ char to_upper_case(const char character)
     return character;
 }
 
-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))
@@ -79,30 +69,97 @@ char to_lower_case(const char character)
     return character;
 }
 
-char to_lower_case_(const char character)
+
+/** END PREV FUNCS **/
+
+char *to_upper_case(char *text)
 {
-    if (is_upper_case(character))
+    if (text == nullptr)
     {
-        return character + 32;
+        return nullptr;
     }
 
-    return character;
-}
+    auto *currenttext = new char[static_cast<unsigned long>(string_length(text))];
 
-/** END PREV FUNCS **/
+    int length = 0;
+    while (*(text + length) != '\0')
+    {
+        *(currenttext + length) = *(text + length);
+        length++;
+    }
 
-char *to_upper_case(char *text)
-{
+    length = 0;
+    while (*(currenttext + length) != '\0')
+    {
+        if (is_lower_case(*(currenttext + length)))
+        {
+            *(currenttext + length) = to_upper_case(*(currenttext + length));
+        }
+        length++;
+    }
+
+    return currenttext;
 }
 
 char *to_lower_case(char *text)
 {
+    if (text == nullptr)
+    {
+        return nullptr;
+    }
+
+    auto *currenttext = new char[static_cast<unsigned long>(string_length(text))];
+
+    int length = 0;
+    while (*(text + length) != '\0')
+    {
+        *(currenttext + length) = *(text + length);
+        length++;
+    }
+
+    length = 0;
+    while (*(currenttext + length) != '\0')
+    {
+        if (is_upper_case(*(currenttext + length)))
+        {
+            *(currenttext + length) = to_lower_case(*(currenttext + length));
+        }
+        length++;
+    }
+
+
+    return currenttext;
 }
 
-std::size_t string_length(char *text)
+std::size_t string_length(const char *text)
 {
+    if (text == nullptr)
+    {
+        return 0;
+    }
+    std::size_t counter = 0;
+    while (*text != '\0')
+    {
+        text++;
+        counter++;
+    }
+    return counter;
 }
 
 bool string_equal(const char *string1, const char *string2)
 {
+    if (string1 == nullptr || string2 == nullptr)
+    {
+        return false;
+    }
+    while (*string1 != '\0' || *string2 != '\0')
+    {
+        if (*string1 != *string2)
+        {
+            return false;
+        }
+        string1++;
+        string2++;
+    }
+    return true;
 }
diff --git a/03_ArrayPointer/StringLibrary/Exercise/main.cc b/03_ArrayPointer/StringLibrary/Exercise/main.cc
index 5f34512..1deffd2 100644
--- a/03_ArrayPointer/StringLibrary/Exercise/main.cc
+++ b/03_ArrayPointer/StringLibrary/Exercise/main.cc
@@ -9,14 +9,22 @@ void test_cases();
 int main()
 {
     char in_text[50]{};
+    char copy_text[50]{};
     char compare_text1[50]{"jan"};
     char compare_text2[50]{"ja"};
 
     std::cout << "Please enter any text: ";
     std::cin >> in_text;
 
-    std::cout << "to_upper_case: " << to_upper_case(in_text) << '\n';
-    std::cout << "to_lower_case: " << to_lower_case(in_text) << '\n';
+    char *toupca = to_upper_case(in_text);
+    std::cout << "to_upper_case: " << toupca << '\n';
+    delete toupca;
+    toupca = nullptr;
+    char *toloca = to_lower_case(in_text);
+    std::cout << "to_lower_case: " << toloca << '\n';
+    delete toloca;
+    toloca = nullptr;
+    std::cout << "origin: " << in_text << '\n';
     std::cout << "string_length: " << string_length(in_text) << '\n';
     std::cout << std::boolalpha;
     std::cout << "jan == jan: " << string_equal(in_text, compare_text1) << '\n';