diff --git a/1-0-java-basics/1-3-1-crazy-generics/src/main/java/com/bobocode/basics/CrazyGenerics.java b/1-0-java-basics/1-3-1-crazy-generics/src/main/java/com/bobocode/basics/CrazyGenerics.java
index 8aeb3997b..225cb8415 100644
--- a/1-0-java-basics/1-3-1-crazy-generics/src/main/java/com/bobocode/basics/CrazyGenerics.java
+++ b/1-0-java-basics/1-3-1-crazy-generics/src/main/java/com/bobocode/basics/CrazyGenerics.java
@@ -1,14 +1,12 @@
 package com.bobocode.basics;
 
 import com.bobocode.basics.util.BaseEntity;
-import com.bobocode.util.ExerciseNotCompletedException;
+import com.google.common.collect.Iterators;
 import lombok.Data;
 
 import java.io.Serializable;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Objects;
+import java.util.*;
+import java.util.function.Predicate;
 
 /**
  * {@link CrazyGenerics} is an exercise class. It consists of classes, interfaces and methods that should be updated
@@ -33,8 +31,8 @@ public class CrazyGenerics {
      * @param <T> – value type
      */
     @Data
-    public static class Sourced { // todo: refactor class to introduce type parameter and make value generic
-        private Object value;
+    public static class Sourced<T> { // todo: refactor class to introduce type parameter and make value generic
+        private T value;
         private String source;
     }
 
@@ -45,11 +43,11 @@ public static class Sourced { // todo: refactor class to introduce type paramete
      * @param <T> – actual, min and max type
      */
     @Data
-    public static class Limited {
+    public static class Limited<T extends Number> {
         // todo: refactor class to introduce type param bounded by number and make fields generic numbers
-        private final Object actual;
-        private final Object min;
-        private final Object max;
+        private final T actual;
+        private final T min;
+        private final T max;
     }
 
     /**
@@ -59,8 +57,12 @@ public static class Limited {
      * @param <T> – source object type
      * @param <R> - converted result type
      */
-    public interface Converter { // todo: introduce type parameters
+    public interface Converter<T, R> { // todo: introduce type parameters
         // todo: add convert method
+        default R convert(T obj) {
+            return (R) obj;
+        }
+
     }
 
     /**
@@ -70,10 +72,10 @@ public interface Converter { // todo: introduce type parameters
      *
      * @param <T> – value type
      */
-    public static class MaxHolder { // todo: refactor class to make it generic
-        private Object max;
+    public static class MaxHolder<T extends Comparable<? super T>> { // todo: refactor class to make it generic
+        private T max;
 
-        public MaxHolder(Object max) {
+        public MaxHolder(T max) {
             this.max = max;
         }
 
@@ -82,11 +84,13 @@ public MaxHolder(Object max) {
          *
          * @param val a new value
          */
-        public void put(Object val) {
-            throw new ExerciseNotCompletedException(); // todo: update parameter and implement the method
+        public void put(T val) {
+            if (max.compareTo(val) < 0) {
+                max = val;
+            }
         }
 
-        public Object getMax() {
+        public T getMax() {
             return max;
         }
     }
@@ -97,8 +101,8 @@ public Object getMax() {
      *
      * @param <T> – the type of objects that can be processed
      */
-    interface StrictProcessor { // todo: make it generic
-        void process(Object obj);
+    interface StrictProcessor<T extends Serializable & Comparable<? super T>> { // todo: make it generic
+        void process(T obj);
     }
 
     /**
@@ -108,10 +112,10 @@ interface StrictProcessor { // todo: make it generic
      * @param <T> – a type of the entity that should be a subclass of {@link BaseEntity}
      * @param <C> – a type of any collection
      */
-    interface CollectionRepository { // todo: update interface according to the javadoc
-        void save(Object entity);
+    interface CollectionRepository<T extends BaseEntity, C extends Collection<T>> { // todo: update interface according to the javadoc
+        void save(T entity);
 
-        Collection<Object> getEntityCollection();
+        C getEntityCollection();
     }
 
     /**
@@ -120,7 +124,7 @@ interface CollectionRepository { // todo: update interface according to the java
      *
      * @param <T> – a type of the entity that should be a subclass of {@link BaseEntity}
      */
-    interface ListRepository { // todo: update interface according to the javadoc
+    interface ListRepository<T extends BaseEntity> extends CollectionRepository<T, java.util.List<T>> { // todo: update interface according to the javadoc
     }
 
     /**
@@ -133,7 +137,21 @@ interface ListRepository { // todo: update interface according to the javadoc
      *
      * @param <E> a type of collection elements
      */
-    interface ComparableCollection { // todo: refactor it to make generic and provide a default impl of compareTo
+    interface ComparableCollection<E> extends Collection<E>, Comparable<Collection<?>> { // todo: refactor it to make generic and provide a default impl of compareTo
+
+        @Override
+        default int compareTo(Collection<?> collection) {
+            int val = 0;
+            Iterator<E> iterator = (Iterator<E>) collection.iterator();
+
+            while (iterator.hasNext()) {
+                int size1 = Iterators.size(iterator);
+                int size2 = Iterators.size((Iterator<?>) iterator.next());
+                 val = Integer.compare(size1, size2);
+            }
+            return val;
+        }
+
     }
 
     /**
@@ -147,7 +165,7 @@ static class CollectionUtil {
          *
          * @param list
          */
-        public static void print(List<Integer> list) {
+        public static void print(List<?> list) {
             // todo: refactor it so the list of any type can be printed, not only integers
             list.forEach(element -> System.out.println(" – " + element));
         }
@@ -160,8 +178,13 @@ public static void print(List<Integer> list) {
          * @param entities provided collection of entities
          * @return true if at least one of the elements has null id
          */
-        public static boolean hasNewEntities(Collection<BaseEntity> entities) {
-            throw new ExerciseNotCompletedException(); // todo: refactor parameter and implement method
+        public static boolean hasNewEntities(Collection<? extends BaseEntity> entities) {
+            for (BaseEntity entity : entities) {
+                if (entity == null) {
+                    return true;
+                }
+            }
+            return false;
         }
 
         /**
@@ -173,8 +196,13 @@ public static boolean hasNewEntities(Collection<BaseEntity> entities) {
          * @param validationPredicate criteria for validation
          * @return true if all entities fit validation criteria
          */
-        public static boolean isValidCollection() {
-            throw new ExerciseNotCompletedException(); // todo: add method parameters and implement the logic
+        public static boolean isValidCollection(Collection<? extends BaseEntity> entities, Predicate<? super BaseEntity> validationPredicate) {
+            for (BaseEntity entity : entities) {
+                if (!validationPredicate.test(entity)) {
+                    return false;
+                }
+            }
+            return true;
         }
 
         /**
@@ -187,8 +215,17 @@ public static boolean isValidCollection() {
          * @param <T>          entity type
          * @return true if entities list contains target entity more than once
          */
-        public static boolean hasDuplicates() {
-            throw new ExerciseNotCompletedException(); // todo: update method signature and implement it
+        public static <T extends BaseEntity> boolean hasDuplicates(List<T> entities, T targetEntity) {
+            int count = 0;
+            for (T entity : entities) {
+                if (Objects.equals(entity.getUuid(), targetEntity.getUuid())) {
+                    count++;
+                    if (count > 1) {
+                        return true;
+                    }
+                }
+            }
+            return false;
         }
 
         /**
@@ -200,7 +237,20 @@ public static boolean hasDuplicates() {
          * @param <T>        type of elements
          * @return optional max value
          */
-        // todo: create a method and implement its logic manually without using util method from JDK
+        public static <T> Optional<T> findMax(Iterable<T> elements, Comparator<? super T> comparator) {
+            Iterator<T> iterator = elements.iterator();
+            if (!iterator.hasNext()) {
+                return Optional.empty();
+            }
+            T max = iterator.next();
+            while (iterator.hasNext()) {
+                T current = iterator.next();
+                if (comparator.compare(current, max) > 0) {
+                    max = current;
+                }
+            }
+            return Optional.of(max);
+        }
 
         /**
          * findMostRecentlyCreatedEntity is a generic util method that accepts a collection of entities and returns the
@@ -214,7 +264,14 @@ public static boolean hasDuplicates() {
          * @param <T>      entity type
          * @return an entity from the given collection that has the max createdOn value
          */
-        // todo: create a method according to JavaDoc and implement it using previous method
+        public static <T extends BaseEntity> T findMostRecentlyCreatedEntity(Collection<T> entities) {
+            if (entities.isEmpty()) {
+                throw new NoSuchElementException("Collection is empty");
+            }
+            Comparator<T> createdOnComparator = Comparator.comparing(BaseEntity::getCreatedOn);
+            Optional<T> maxEntity = findMax(entities, createdOnComparator);
+            return maxEntity.get();
+        }
 
         /**
          * An util method that allows to swap two elements of any list. It changes the list so the element with the index
@@ -225,10 +282,12 @@ public static boolean hasDuplicates() {
          * @param i        index of the element to swap
          * @param j        index of the other element to swap
          */
-        public static void swap(List<?> elements, int i, int j) {
+        public static void swap(List elements, int i, int j) {
             Objects.checkIndex(i, elements.size());
             Objects.checkIndex(j, elements.size());
-            throw new ExerciseNotCompletedException(); // todo: complete method implementation 
+            Object temp = elements.get(i);
+            elements.set(i, elements.get(j));
+            elements.set(j, temp);
         }
 
     }