Divide and conquer

.gitignore

@@ -1 +1,3 @@
 .DS_Store
+*.iml
+.idea/

Divide and Conquer/README.md

@@ -0,0 +1,24 @@
+## Dividir para conquistar
+"Dividir para conquistar" é um princípio fundamental na programação e algoritmos que se baseia na estratégia de resolver um problema **dividindo-o em partes menores**, mais simples e mais gerenciáveis. Esse método permite lidar com problemas complexos de forma mais eficiente, reduzindo a complexidade geral da solução.
+
+Em termos práticos, o "dividir para conquistar" envolve três etapas principais:
+
+### Divisão
+O problema original é dividido em subproblemas menores. Essa divisão pode ser realizada de forma recursiva ou iterativa, dependendo da natureza do problema.
+
+### Conquista
+Cada subproblema é resolvido de forma independente. Isso pode envolver aplicar a mesma estratégia "dividir para conquistar" recursivamente nos subproblemas até que eles se tornem trivialmente resolvíveis.
+
+### Combinação
+As soluções dos subproblemas são combinadas para formar a solução do problema original. Esta etapa garante que a solução para o problema global seja construída corretamente a partir das soluções dos subproblemas.
+
+Segundo o livro `Entendendo Algoritmos, escrito por Aditya Bhargava`, esses passos podem ser divididos em dois:
+1. **Descubra o caso-base** (_caso envolva um array, o caso-base muitas vezes será um array vazio ou um array com apenas um elemento_).
+2. **Você deve chegar o mais perto possível de um array vazio a cada recursão.**
+
+
+### CASOS DE USO
+
+O "dividir para conquistar" é amplamente utilizado em algoritmos eficientes para problemas como ordenação (por exemplo, merge sort, quicksort), busca (por exemplo, binary search), e problemas de divisão e conquista em geral. 
+
+Ele não apenas simplifica a abordagem de solução de problemas complexos, mas também pode melhorar significativamente o desempenho do algoritmo quando implementado corretamente, reduzindo a complexidade temporal e espacial em comparação com abordagens mais ingênuas ou lineares.

Divide and Conquer/divide-and-conquer/.gitignore

@@ -0,0 +1,38 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

Divide and Conquer/divide-and-conquer/README.md

@@ -0,0 +1,9 @@
+## Dividir para conquistar
+
+Este projeto contem três exercícios do livro `Entendendo Algoritmos - Aditya Y. Bhargava`. Além disso, também foram implementados testes unitários para análise dos cenários.
+
+### Exercícios
+
+1. Escreva o código pra a função soma, vista anteriormente. (Arquivo: `Exercice1.java`)
+2. Escreva uma função recursiva que conte o número de itens em uma lista. (Arquivo: `Exercice2.java`)
+3. Encontre o valor mais alto em uma lista. (Arquivo: `Exercice3.java`)

Divide and Conquer/divide-and-conquer/pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.example</groupId>
+    <artifactId>divide-and-conquer</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>19</maven.compiler.source>
+        <maven.compiler.target>19</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.1</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

Divide and Conquer/divide-and-conquer/src/main/java/org/example/Exercice1.java

@@ -0,0 +1,29 @@
+package org.example;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Exercice1 {
+    private static final int FIRST_POSITION_IN_LIST = 0;
+    private static final int SECOND_POSITION_IN_LIST = 1;
+
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(1, 2, 3, 4);
+        System.out.println("Result: "+ sum(list));
+    }
+
+    public static int sum(List<Integer> list) {
+        System.out.println("Actual list: " + list);
+
+        if (list.isEmpty()) {
+            return 0;
+        }
+
+        if (list.size() < 2) {
+            return list.get(FIRST_POSITION_IN_LIST);
+        }
+
+        return list.get(FIRST_POSITION_IN_LIST) + sum(list.subList(SECOND_POSITION_IN_LIST, list.size()));
+    }
+}

Divide and Conquer/divide-and-conquer/src/main/java/org/example/Exercice2.java

@@ -0,0 +1,25 @@
+package org.example;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Exercice2 {
+    private static final int SECOND_POSITION_IN_LIST = 1;
+
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(1, 2, 3, 4);
+        System.out.println("Result: "+ countListSize(list));
+    }
+
+    public static int countListSize(List<Integer> list) {
+        if (list.isEmpty()) {
+            return 0;
+        }
+
+        if (list.size() < 2) {
+            return 1;
+        }
+
+        return 1 + countListSize(list.subList(SECOND_POSITION_IN_LIST, list.size()));
+    }
+}

Divide and Conquer/divide-and-conquer/src/main/java/org/example/Exercice3.java

@@ -0,0 +1,28 @@
+package org.example;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Exercice3 {
+    private static final int FIRST_POSITION_IN_LIST = 0;
+    private static final int SECOND_POSITION_IN_LIST = 1;
+
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(1, 2, 3, 4, 6, 1, 5, 33, 2, 1);
+        System.out.println("Result: "+ getGreatestNumberInList(list));
+    }
+
+    public static int getGreatestNumberInList(List<Integer> list) {
+        if (list.isEmpty()) {
+            return 0;
+        }
+
+        int firstNumber = list.get(FIRST_POSITION_IN_LIST);
+
+        if (list.size() < 2) {
+            return firstNumber;
+        }
+
+        return Math.max(firstNumber, getGreatestNumberInList(list.subList(SECOND_POSITION_IN_LIST, list.size())));
+    }
+}

Divide and Conquer/divide-and-conquer/src/test/java/org/example/Exercice1Test.java

@@ -0,0 +1,33 @@
+package org.example;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+
+public class Exercice1Test {
+
+    @Test
+    public void given_emptyList_should_returnCorrectSum() {
+        List<Integer> list = new ArrayList<>();
+
+        Assert.assertEquals(0, Exercice1.sum(list));
+    }
+
+    @Test
+    public void given_listWithOneItem_should_returnCorrectSum() {
+        List<Integer> list = Arrays.asList(3);
+
+        Assert.assertEquals(3, Exercice1.sum(list));
+    }
+
+    @Test
+    public void given_listWithManyItems_should_returnCorrectSum() {
+        List<Integer> list = Arrays.asList(3, 3, 4, 5, 7, 2);
+
+        Assert.assertEquals(24, Exercice1.sum(list));
+    }
+}

Divide and Conquer/divide-and-conquer/src/test/java/org/example/Exercice2Test.java

@@ -0,0 +1,31 @@
+package org.example;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Exercice2Test {
+    @Test
+    public void given_emptyList_should_returnCorrectSize() {
+        List<Integer> list = new ArrayList<>();
+
+        Assert.assertEquals(list.size(), Exercice2.countListSize(list));
+    }
+
+    @Test
+    public void given_listWithOneItem_should_returnCorrectSize() {
+        List<Integer> list = Arrays.asList(3);
+
+        Assert.assertEquals(list.size(), Exercice2.countListSize(list));
+    }
+
+    @Test
+    public void given_listWithManyItems_should_returnCorrectSize() {
+        List<Integer> list = Arrays.asList(3, 3, 4, 5, 7, 2);
+
+        Assert.assertEquals(list.size(), Exercice2.countListSize(list));
+    }
+}

Divide and Conquer/divide-and-conquer/src/test/java/org/example/Exercice3Test.java

@@ -0,0 +1,32 @@
+package org.example;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Exercice3Test {
+    @Test
+    public void given_emptyList_should_returnGreatestItem() {
+        List<Integer> list = new ArrayList<>();
+
+        Assert.assertEquals(0, Exercice3.getGreatestNumberInList(list));
+    }
+
+    @Test
+    public void given_listWithOneItem_should_returnGreatestItem() {
+        List<Integer> list = Arrays.asList(3);
+
+        Assert.assertEquals(3, Exercice3.getGreatestNumberInList(list));
+    }
+
+    @Test
+    public void given_listWithManyItems_should_rreturnGreatestItem() {
+        List<Integer> list = Arrays.asList(3, 3, 4, 5, 7, 2, 88, 1, 4, 6, 7, 10, 81);
+
+        Assert.assertEquals(88, Exercice3.getGreatestNumberInList(list));
+    }
+
+}