diff --git a/crazy-optionals/src/main/java/com/bobocode/CrazyOptionals.java b/crazy-optionals/src/main/java/com/bobocode/CrazyOptionals.java
index d81fe02..8522fb1 100644
--- a/crazy-optionals/src/main/java/com/bobocode/CrazyOptionals.java
+++ b/crazy-optionals/src/main/java/com/bobocode/CrazyOptionals.java
@@ -11,9 +11,8 @@
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.math.BigDecimal;
-import java.util.List;
-import java.util.Optional;
-import java.util.OptionalDouble;
+import java.util.*;
+import java.util.stream.Collectors;
 
 public class CrazyOptionals {
 
@@ -24,7 +23,7 @@ public class CrazyOptionals {
      * @return optional object that holds text
      */
     public static Optional<String> optionalOfString(@Nullable String text) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return Optional.ofNullable(text);
     }
 
     /**
@@ -34,7 +33,10 @@ public static Optional<String> optionalOfString(@Nullable String text) {
      * @param amount          money to deposit
      */
     public static void deposit(AccountProvider accountProvider, BigDecimal amount) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        accountProvider.getAccount()
+                .ifPresent(account -> {
+                    account.setBalance(account.getBalance().add(amount));
+                });
     }
 
     /**
@@ -44,7 +46,7 @@ public static void deposit(AccountProvider accountProvider, BigDecimal amount) {
      * @return optional object that holds account
      */
     public static Optional<Account> optionalOfAccount(@Nonnull Account account) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return Optional.of(account);
     }
 
     /**
@@ -56,7 +58,7 @@ public static Optional<Account> optionalOfAccount(@Nonnull Account account) {
      * @return account from provider or defaultAccount
      */
     public static Account getAccount(AccountProvider accountProvider, Account defaultAccount) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount().orElse(defaultAccount);
     }
 
     /**
@@ -67,7 +69,8 @@ public static Account getAccount(AccountProvider accountProvider, Account defaul
      * @param accountService
      */
     public static void processAccount(AccountProvider accountProvider, AccountService accountService) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        accountProvider.getAccount()
+                .ifPresentOrElse(accountService::processAccount, accountService::processWithNoAccount);
     }
 
     /**
@@ -78,7 +81,8 @@ public static void processAccount(AccountProvider accountProvider, AccountServic
      * @return provided or generated account
      */
     public static Account getOrGenerateAccount(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .orElseGet(Accounts::generateAccount);
     }
 
     /**
@@ -88,7 +92,8 @@ public static Account getOrGenerateAccount(AccountProvider accountProvider) {
      * @return optional balance
      */
     public static Optional<BigDecimal> retrieveBalance(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .map(Account::getBalance);
     }
 
     /**
@@ -99,7 +104,7 @@ public static Optional<BigDecimal> retrieveBalance(AccountProvider accountProvid
      * @return provided account
      */
     public static Account getAccount(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount().orElseThrow(() -> new AccountNotFoundException("No Account provided!"));
     }
 
     /**
@@ -109,7 +114,8 @@ public static Account getAccount(AccountProvider accountProvider) {
      * @return optional credit balance
      */
     public static Optional<BigDecimal> retrieveCreditBalance(CreditAccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .flatMap(CreditAccount::getCreditBalance);
     }
 
 
@@ -121,7 +127,8 @@ public static Optional<BigDecimal> retrieveCreditBalance(CreditAccountProvider a
      * @return optional gmail account
      */
     public static Optional<Account> retrieveAccountGmail(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .filter(account -> account.getEmail().contains("gmail"));
     }
 
     /**
@@ -134,7 +141,7 @@ public static Optional<Account> retrieveAccountGmail(AccountProvider accountProv
      * @return account got from either accountProvider or fallbackProvider
      */
     public static Account getAccountWithFallback(AccountProvider accountProvider, AccountProvider fallbackProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount().or(fallbackProvider::getAccount).orElseThrow(NoSuchElementException::new);
     }
 
     /**
@@ -145,7 +152,9 @@ public static Account getAccountWithFallback(AccountProvider accountProvider, Ac
      * @return account with the highest balance
      */
     public static Account getAccountWithMaxBalance(List<Account> accounts) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accounts.stream()
+                .max(Comparator.comparing(Account::getBalance))
+                .orElseThrow(NoSuchElementException::new);
     }
 
     /**
@@ -155,7 +164,11 @@ public static Account getAccountWithMaxBalance(List<Account> accounts) {
      * @return the lowest balance values
      */
     public static OptionalDouble findMinBalanceValue(List<Account> accounts) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        Optional<Account> account = accounts.stream()
+                .min(Comparator.comparing(Account::getBalance));
+
+        return account.isPresent() ? OptionalDouble.of(account.get().getBalance().doubleValue()) : OptionalDouble.empty();
+
     }
 
     /**
@@ -165,7 +178,9 @@ public static OptionalDouble findMinBalanceValue(List<Account> accounts) {
      * @param accountService
      */
     public static void processAccountWithMaxBalance(List<Account> accounts, AccountService accountService) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        accounts.stream()
+                .max(Comparator.comparing(Account::getBalance))
+                .ifPresent(accountService::processAccount);
     }
 
     /**
@@ -175,7 +190,12 @@ public static void processAccountWithMaxBalance(List<Account> accounts, AccountS
      * @return total credit balance
      */
     public static double calculateTotalCreditBalance(List<CreditAccount> accounts) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accounts.stream()
+                .map(CreditAccount::getCreditBalance)
+                .map(b -> b.orElse(BigDecimal.ZERO).doubleValue())
+                .mapToDouble(Double::longValue)
+                .sum();
+
     }
 }
 
diff --git a/declarative-sum-of-squares/src/main/java/com/bobocode/SumOfSquares.java b/declarative-sum-of-squares/src/main/java/com/bobocode/SumOfSquares.java
index fc0dfde..8b86c3a 100644
--- a/declarative-sum-of-squares/src/main/java/com/bobocode/SumOfSquares.java
+++ b/declarative-sum-of-squares/src/main/java/com/bobocode/SumOfSquares.java
@@ -3,6 +3,7 @@
 
 import com.bobocode.exception.InvalidRangeException;
 
+import java.util.stream.IntStream;
 
 /**
  * This class allow to calculate a sum of squares of integer number in a certain range. It was implemented using
@@ -25,11 +26,8 @@ static int calculateSumOfSquaresInRange(int startInclusive, int endInclusive) {
             throw new InvalidRangeException();
         }
 
-        // todo: refactor using functional approach
-        int sumOfSquares = 0;
-        for (int i = startInclusive; i <= endInclusive; i++) {
-            sumOfSquares += i * i;
-        }
-        return sumOfSquares;
+        return IntStream.range(startInclusive, endInclusive + 1)
+                .map(i -> i * i)
+                .sum();
     }
 }
diff --git a/lambda-math-functions/src/main/java/com.bobocode/Functions.java b/lambda-math-functions/src/main/java/com.bobocode/Functions.java
index 80ebc20..09d5076 100644
--- a/lambda-math-functions/src/main/java/com.bobocode/Functions.java
+++ b/lambda-math-functions/src/main/java/com.bobocode/Functions.java
@@ -1,5 +1,7 @@
 package com.bobocode;
 
+import java.util.function.Function;
+
 public class Functions {
     /**
      * A static factory method that creates an integer function map with basic functions:
@@ -14,8 +16,33 @@ public class Functions {
     public static FunctionMap<Integer, Integer> intFunctionMap() {
         FunctionMap<Integer, Integer> intFunctionMap = new FunctionMap<>();
 
-        // todo: add simple functions to the function map (abs, sng, increment, decrement, square)
+        intFunctionMap.addFunction("abs", Functions::abs);
+        intFunctionMap.addFunction("sgn", Functions::sgn);
+        intFunctionMap.addFunction("increment", Functions::increment);
+        intFunctionMap.addFunction("decrement", Functions::decrement);
+        intFunctionMap.addFunction("square", Functions::square);
 
         return intFunctionMap;
     }
+
+    private static Integer abs(int number) {
+        return number < 0 ? number * -1 : number;
+    }
+
+    private static Integer sgn(int number) {
+        if (number == 0) return 0;
+        return number < 0 ? -1 : 1;
+    }
+
+    private static Integer increment(int number) {
+        return number + 1;
+    }
+
+    private static Integer decrement(int number) {
+        return number - 1;
+    }
+
+    private static Integer square(int number) {
+        return number * number;
+    }
 }
diff --git a/linked-list/src/main/java/com/bobocode/LinkedList.java b/linked-list/src/main/java/com/bobocode/LinkedList.java
index bd6176a..ec27d82 100644
--- a/linked-list/src/main/java/com/bobocode/LinkedList.java
+++ b/linked-list/src/main/java/com/bobocode/LinkedList.java
@@ -1,5 +1,7 @@
 package com.bobocode;
 
+import java.util.Arrays;
+
 /**
  * {@link LinkedList} is a list implementation that is based on singly linked generic nodes. A node is implemented as
  * inner static class {@link Node<T>}. In order to keep track on nodes, {@link LinkedList} keeps a reference to a head node.
@@ -7,6 +9,8 @@
  * @param <T> generic type parameter
  */
 public class LinkedList<T> implements List<T> {
+    private Node<T> head;
+    private int size = 0;
 
     /**
      * This method creates a list of provided elements
@@ -15,8 +19,12 @@ public class LinkedList<T> implements List<T> {
      * @param <T>      generic type
      * @return a new list of elements the were passed as method parameters
      */
-    public static <T> List<T> of(T... elements) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+    @SafeVarargs
+    static <T> List<T> of(T... elements) {
+        List<T> linkedList = new LinkedList<>();
+        Arrays.stream(elements)
+                .forEach(linkedList::add);
+        return linkedList;
     }
 
     /**
@@ -26,7 +34,14 @@ public static <T> List<T> of(T... elements) {
      */
     @Override
     public void add(T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (isEmpty()) {
+            head = new Node<>(element);
+            head.next = head;
+            head.prev = head;
+            size++;
+        } else {
+            insertNode(element, head);
+        }
     }
 
     /**
@@ -38,7 +53,15 @@ public void add(T element) {
      */
     @Override
     public void add(int index, T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (index == 0) {
+            if (isEmpty()) {
+                add(element);
+            } else {
+                head = insertNode(element, head);
+            }
+        } else {
+            insertNode(element, findNode(index - 1).next);
+        }
     }
 
     /**
@@ -50,7 +73,8 @@ public void add(int index, T element) {
      */
     @Override
     public void set(int index, T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        Node<T> node = findNode(index);
+        node.value = element;
     }
 
     /**
@@ -62,7 +86,7 @@ public void set(int index, T element) {
      */
     @Override
     public T get(int index) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return findNode(index).value;
     }
 
     /**
@@ -73,7 +97,20 @@ public T get(int index) {
      */
     @Override
     public void remove(int index) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (index == 0) {
+            Node<T> newHead = head.next;
+            newHead.prev = head.prev;
+            head.prev.next = newHead;
+            head = newHead;
+            size--;
+            return;
+        }
+        Node<T> node = findNode(index);
+        Node<T> previousNode = node.prev;
+
+        previousNode.next = node.next;
+        node.next.prev = previousNode;
+        size--;
     }
 
 
@@ -84,7 +121,17 @@ public void remove(int index) {
      */
     @Override
     public boolean contains(T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (isEmpty()) {
+            return false;
+        }
+        Node<T> node = head;
+        while(node.next != head) {
+            if (node.value == element) {
+                return true;
+            }
+            node = node.next;
+        }
+        return false;
     }
 
     /**
@@ -94,7 +141,7 @@ public boolean contains(T element) {
      */
     @Override
     public boolean isEmpty() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size == 0;
     }
 
     /**
@@ -104,7 +151,7 @@ public boolean isEmpty() {
      */
     @Override
     public int size() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size;
     }
 
     /**
@@ -112,6 +159,44 @@ public int size() {
      */
     @Override
     public void clear() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        head = null;
+        size = 0;
+    }
+
+    private Node<T> findNode(int index) {
+        if (size - 1 < index || index < 0 || isEmpty()) {
+            throw new IndexOutOfBoundsException();
+        }
+        Node<T> node = head;
+        while(index > 0) {
+            index--;
+            node = node.next;
+        }
+        return node;
+    }
+
+    private Node<T> insertNode(T element, Node<T> nextNode) {
+        Node<T> newNode = new Node<>(element);
+        Node<T> prevNode = nextNode.prev;
+
+        newNode.prev = prevNode;
+        newNode.next = nextNode;
+
+        prevNode.next = newNode;
+        nextNode.prev = newNode;
+
+        size++;
+
+        return newNode;
+    }
+
+    private class Node<V> {
+        private V value;
+        private Node<V> next;
+        private Node<V> prev;
+
+        Node(V value) {
+            this.value = value;
+        }
     }
 }
diff --git a/linked-queue/src/main/java/com/bobocode/LinkedQueue.java b/linked-queue/src/main/java/com/bobocode/LinkedQueue.java
index 3cde892..8ed94c0 100644
--- a/linked-queue/src/main/java/com/bobocode/LinkedQueue.java
+++ b/linked-queue/src/main/java/com/bobocode/LinkedQueue.java
@@ -8,6 +8,9 @@
  * @param <T> a generic parameter
  */
 public class LinkedQueue<T> implements Queue<T> {
+    private int size = 0;
+    private Node<T> head;
+    private Node<T> tale;
 
     /**
      * Adds an element to the end of the queue.
@@ -15,7 +18,14 @@ public class LinkedQueue<T> implements Queue<T> {
      * @param element the element to add
      */
     public void add(T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (isEmpty()) {
+            head = new Node<>(element);
+            tale = head;
+        } else {
+            tale.next = new Node<>(element);
+            tale = tale.next;
+        }
+        size++;
     }
 
     /**
@@ -24,7 +34,13 @@ public void add(T element) {
      * @return an element that was retrieved from the head or null if queue is empty
      */
     public T poll() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (isEmpty()) {
+            return null;
+        }
+        T value = head.value;
+        head = head.next;
+        size--;
+        return value;
     }
 
     /**
@@ -33,7 +49,7 @@ public T poll() {
      * @return an integer value that is a size of queue
      */
     public int size() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size;
     }
 
     /**
@@ -42,6 +58,15 @@ public int size() {
      * @return {@code true} if the queue is empty, returns {@code false} if it's not
      */
     public boolean isEmpty() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size == 0;
+    }
+
+    private class Node<V> {
+        private Node<V> next;
+        private V value;
+
+        Node(V value) {
+            this.value = value;
+        }
     }
 }