translation: Translate to Spanish (iluwatar#2893)

* Translate Iterator pattern to Spanish

* Translate to Spanish:
Servant pattern
Sharding pattern
Spatial-partition pattern
Special-case pattern
specification pattern
State pattern
Strategy pattern
Subclass-case pattern

* Update language to es

* Fixing Missing translation

Author: DavidMedinaO

localization/es/servant/README.md

@@ -0,0 +1,235 @@
+---
+title: Servant
+category: Behavioral
+language: es
+tag:
+- Decoupling
+---
+
+## Propósito
+Servant se utiliza para proporcionar algún comportamiento a un grupo de clases.
+En lugar de definir ese comportamiento en cada clase - o cuando no podemos factorizar
+este comportamiento en la clase padre común - se define una vez en el Servant.
+
+## Explicación
+
+Ejemplo del mundo real
+
+> El Rey, la Reina y otros miembros reales de palacio necesitan sirvientes que les den de comer,
+> organizar bebidas, etc.
+
+En otras palabras
+
+> Garantiza que un objeto servidor preste determinados servicios a un grupo de clases atendidas.
+
+Wikipedia dice
+
+> En ingeniería de software, el patrón Servant define un objeto utilizado para ofrecer alguna funcionalidad
+> a un grupo de clases sin definir esa funcionalidad en cada una de ellas. Un Servant es una clase
+> cuya instancia (o incluso sólo clase) proporciona métodos que se encargan de un servicio deseado, mientras que
+> los objetos para los que (o con los que) el Servant hace algo, se toman como parámetros.
+
+**Ejemplo programático**
+
+La clase Servant puede prestar servicios a otros miembros reales de palacio.
+
+```java
+/**
+ * Servant.
+ */
+public class Servant {
+
+  public String name;
+
+  /**
+   * Constructor.
+   */
+  public Servant(String name) {
+    this.name = name;
+  }
+
+  public void feed(Royalty r) {
+    r.getFed();
+  }
+
+  public void giveWine(Royalty r) {
+    r.getDrink();
+  }
+
+  public void giveCompliments(Royalty r) {
+    r.receiveCompliments();
+  }
+
+  /**
+   * Check if we will be hanged.
+   */
+  public boolean checkIfYouWillBeHanged(List<Royalty> tableGuests) {
+    return tableGuests.stream().allMatch(Royalty::getMood);
+  }
+}
+```
+
+Royalty es una interfaz. Es implementada por las clases King, y Queen para obtener servicios de servant.
+
+```java
+interface Royalty {
+
+    void getFed();
+
+    void getDrink();
+
+    void changeMood();
+
+    void receiveCompliments();
+
+    boolean getMood();
+}
+```
+La clase King implementa la interfaz Royalty.
+```java
+public class King implements Royalty {
+
+    private boolean isDrunk;
+    private boolean isHungry = true;
+    private boolean isHappy;
+    private boolean complimentReceived;
+
+    @Override
+    public void getFed() {
+        isHungry = false;
+    }
+
+    @Override
+    public void getDrink() {
+        isDrunk = true;
+    }
+
+    public void receiveCompliments() {
+        complimentReceived = true;
+    }
+
+    @Override
+    public void changeMood() {
+        if (!isHungry && isDrunk) {
+            isHappy = true;
+        }
+        if (complimentReceived) {
+            isHappy = false;
+        }
+    }
+
+    @Override
+    public boolean getMood() {
+        return isHappy;
+    }
+}
+```
+La clase Queen implementa la interfaz Royalty.
+```java
+public class Queen implements Royalty {
+
+    private boolean isDrunk = true;
+    private boolean isHungry;
+    private boolean isHappy;
+    private boolean isFlirty = true;
+    private boolean complimentReceived;
+
+    @Override
+    public void getFed() {
+        isHungry = false;
+    }
+
+    @Override
+    public void getDrink() {
+        isDrunk = true;
+    }
+
+    public void receiveCompliments() {
+        complimentReceived = true;
+    }
+
+    @Override
+    public void changeMood() {
+        if (complimentReceived && isFlirty && isDrunk && !isHungry) {
+            isHappy = true;
+        }
+    }
+
+    @Override
+    public boolean getMood() {
+        return isHappy;
+    }
+
+    public void setFlirtiness(boolean f) {
+        this.isFlirty = f;
+    }
+
+}
+```
+
+Luego:
+
+```java
+public class App {
+
+    private static final Servant jenkins = new Servant("Jenkins");
+    private static final Servant travis = new Servant("Travis");
+
+    /**
+     * Program entry point.
+     */
+    public static void main(String[] args) {
+        scenario(jenkins, 1);
+        scenario(travis, 0);
+    }
+
+    /**
+     * Can add a List with enum Actions for variable scenarios.
+     */
+    public static void scenario(Servant servant, int compliment) {
+        var k = new King();
+        var q = new Queen();
+
+        var guests = List.of(k, q);
+
+        // feed
+        servant.feed(k);
+        servant.feed(q);
+        // serve drinks
+        servant.giveWine(k);
+        servant.giveWine(q);
+        // compliment
+        servant.giveCompliments(guests.get(compliment));
+
+        // outcome of the night
+        guests.forEach(Royalty::changeMood);
+
+        // check your luck
+        if (servant.checkIfYouWillBeHanged(guests)) {
+            LOGGER.info("{} will live another day", servant.name);
+        } else {
+            LOGGER.info("Poor {}. His days are numbered", servant.name);
+        }
+    }
+}
+```
+
+La salida de la consola
+
+```
+Jenkins will live another day
+Poor Travis. His days are numbered
+```
+
+
+## Diagrama de clases
+![alt text](./etc/servant-pattern.png "Servant")
+
+## Aplicabilidad
+Utiliza el patrón Servant cuando
+
+* Cuando queremos que algunos objetos realicen una acción común y no queremos definir esta acción como un método en cada clase.
+
+## Créditos
+
+* [Let's Modify the Objects-First Approach into Design-Patterns-First](http://edu.pecinovsky.cz/papers/2006_ITiCSE_Design_Patterns_First.pdf)

localization/es/servant/etc/servant-pattern.png

@@ -0,0 +1,27 @@
+---
+title: Sharding 
+category: Behavioral
+language: es
+tag:  
+ - Performance
+ - Cloud distributed
+---  
+  
+## Propósito
+El patrón sharding significa dividir el almacén de datos en particiones horizontales o shards. Cada fragmento tiene el mismo esquema, pero contiene su propio subconjunto de datos.
+Un fragmento es un almacén de datos en sí mismo (puede contener los datos de muchas entidades de diferentes tipos), que se ejecuta en un servidor que actúa como nodo de almacenamiento.
+
+## Diagrama de clases
+![alt text](./etc/sharding.urm.png "Sharding pattern class diagram")
+
+## Aplicabilidad
+Este patrón ofrece las siguientes ventajas:
+
+- Se puede ampliar el sistema añadiendo más fragmentos que se ejecuten en nodos de almacenamiento adicionales.
+- El sistema puede utilizar hardware comercial en lugar de ordenadores especializados (y caros) para cada nodo de almacenamiento.
+- Se puede reducir la contención y mejorar el rendimiento equilibrando la carga de trabajo entre los shards.
+- En la nube, los shards pueden ubicarse físicamente cerca de los usuarios que accederán a los datos.
+
+## Créditos
+  
+* [Sharding pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/sharding)

localization/es/sharding/README.md

@@ -0,0 +1,73 @@
+---
+title: Spatial Partition
+category: Behavioral
+language: es
+tag:
+ - Performance
+ - Game programming
+---
+
+## Propósito
+
+Como se explica en el libro  [Game Programming Patterns](http://gameprogrammingpatterns.com/spatial-partition.html) 
+por Bob Nystrom, spatial partition pattern ayuda a localizar eficazmente los objetos almacenándolos en una
+estructura de datos organizada por sus posiciones.
+
+## Explicación
+
+Digamos que usted está construyendo un juego de guerra con cientos, o incluso miles de jugadores, que se enfrentan en el campo de batalla.
+La posición de cada jugador se actualiza en cada fotograma. La forma más sencilla de manejar
+todas las interacciones que tienen lugar en el campo es comprobar la posición de cada jugador con la de todos los demás.
+posición de cada jugador:
+
+```java
+public void handleMeLee(Unit units[], int numUnits) {
+  for (var a = 0; a < numUnits - 1; a++)
+  {
+    for (var b = a + 1; b < numUnits; b++)
+    {
+      if (units[a].position() == units[b].position())
+      {
+        handleAttack(units[a], units[b]);
+      }
+    }
+  }
+}
+```
+
+Esto incluirá un montón de controles innecesarios entre jugadores que están demasiado alejados como para tener alguna
+influencia entre ellos. Los bucles anidados dan a esta operación una complejidad O(n^2), que tiene que ser
+cada fotograma, ya que muchos de los objetos del campo pueden moverse en cada fotograma. La idea
+detrás del patrón de diseño de Partición Espacial es permitir una rápida localización de los objetos utilizando una estructura de datos que está organizada por sus posiciones.
+que está organizada por sus posiciones, de modo que cuando se realiza una operación como la anterior,
+no es necesario cotejar la posición de cada objeto con la de todos los demás. La estructura de datos
+puede utilizarse para almacenar objetos en movimiento y estáticos, aunque para seguir la pista de los objetos en movimiento,
+sus posiciones tendrán que restablecerse cada vez que se muevan. Esto significaría tener que crear una nueva
+instancia de la estructura de datos cada vez que un objeto se mueva, lo que consumiría memoria adicional. La dirección
+estructuras de datos comunes utilizadas para este patrón de diseño son:
+
+* Grid
+* Árbol Quad
+* Árbol K-d
+* BSP
+* Jerarquía de volúmenes límite
+
+En nuestra implementación, utilizamos la estructura de datos Quadtree que reducirá la complejidad temporal de
+O(n^2) a O(nlogn), lo que reduce significativamente los cálculos necesarios en el caso de un gran número de objetos.
+significativamente en el caso de un gran número de objetos.
+
+## Diagrama de clases
+
+![alt text](./etc/spatial-partition.urm.png "Spatial Partition pattern class diagram")
+
+## Aplicabilidad
+
+Utilice el patrón Spatial Partition cuando:
+
+* Cuando se necesita mantener un registro de un gran número de posiciones de objetos, que se actualizan cada fotograma.
+* Cuando es aceptable cambiar memoria por velocidad, ya que la creación y actualización de la estructura de datos consumirá memoria extra.
+
+## Créditos
+
+* [Game Programming Patterns/Spatial Partition](http://gameprogrammingpatterns.com/spatial-partition.html) por Bob Nystrom
+* [Quadtree tutorial](https://www.youtube.com/watch?v=OJxEcs0w_kE) por Daniel Schiffman