Estamos creando la funcion de las N-torres:
donde debemos crear un algoritmo que nos cuenta las veces que el orden se
repite en estos bloques.
La siguiente función actúa como una especie de fábrica dirigida por for loops y alguna comprensión de lista o quizás un desempaquetado.
La siguiente función se llama Solution(T): que hace lo explicado.

```python
T = ["aab", "cab", "baa", "baa"]
```

```python
T2 = ["zzz", "zbz", "zbz", "dgf"]
```

```python
T3 =['abc', 'cba', 'cab', 'bac', 'bca']
```

```python
def Solution(T):
  import numpy as np
  """
  IF YOU PASS A LIST OF STRINGS WHERE A SWAP IS DONE OR NOT, THAT TELLS YOU THE
  MAXIMUM REPEATED ORDER OF BLOCKS
  """
  lista_ = []
  def swap_string(string):
    x,y,z = list(string)
    if (x==y) and (y!=z):
      return str(x+z+y)
    elif (y==z) and (x!=y):
      return str(y+x+z)
    elif (x!=y) and (y!=z):
      return str(x+y+z),str(y+x+z), str(x+z+y)
    else:
      return str(x+y+z)

##  Las condiciones son tales que si los números coinciden en magnitud no es
## computacionalmente necesario hacer un swap.
## Otra  cosa es que estamos ante un problema de algebra linear de una matriz
## de rango (3,N), es decir si hay una cantidad M de variables y además M > N,
## entonces el swap no será necesario del todo. porque habría más variables que
## grados de libertad.

  for elemento in T:
    lista_.append(swap_string(elemento))
  A = list(np.array(lista_).flatten())
  return max([A.count(value) for value in A])

## Luego el código transforma a una lista 1-D para que podamos contar los
## valores one by one, cuyo orden se repite el máximo de veces luego de un swap
## o de no hacer swap. =).
##

```

```python

```

```python

S = "[{()}]"
```

```python
S = "[{(})]"
```

```python
def Solution(S):
  """
  FUNCTION THAT ALLOWS TO LET US KNOW IF STRINGS ARE WELL NESTED OR NOT BY
  RETURNING TRUE OR FALSE IF IT'S WELL NESTED.
  MAYBE THERE IS SOME EASY WAY TO ONE LINE THIS PROBLEM BUT NEED TO COMPARED
  SYMBOLS BY HALF RANGE
  """
  diccionario = {'(': ')', '[': ']', '{': '}'}
  ####### El algoritmo funciona de la siguiente manera:
  ####### definimos un diccionario clave valor con los simbolos (igual creo que se puede mejorar)

  ####### Los for loops nos ayudan a ver que cada elemento hasta la mitad del string se corresponde
  ####### a las claves del diccionario y luego todo elemento de más de la mitad del string se corresponden con
  ####### los valores del diccionario.

  ##### Se añade en una lista si estan bien aninados todos los elementos de strings
  ##### Y finalmente si todos están bien anidados entonces la funcion devuelve 1
  ###### Y sino, devuelve 0.

  N = len(S)
  half = int(N/2)
  lista_final = []
  for clave, valor in diccionario.items():
    for indice in range(half+1):
      if S[indice] == clave:
        if S[N-indice-1] == valor:
          lista_final.append(1)
        else:
          lista_final.append(0)
  if 0 in lista_final:
    return 0
  else:
    return 1
```

```python
def Solution(nums, k):
  """
  THE FUNCTION RETURNS TRUE IN CASE YOU CAN SPLIT AN ARRAY IN GROUPS OF K-UNITS.
  ELSE RETURN FALSE.
  """
  #########################
  ########## La función crea listas que contengan todos los números del array dado
  ########## generados por un List(range(nums[0], nums[0]+k)), debido a que
  ########## son números consecutivos, un range nos permite hacer eso,
  ########## luego eliminamos los elementos de ese range que se encuentren en nums ya que están ordenados y,
  ########## volvemos a coger la variable List(range(nums[0], nums[0]+k))
  ########## para que GENERE las listas subsiguientes.
  lista_k = []
  grupos_totales = int(len(nums)/k)
  nums = sorted(nums)

  if len(nums) % k == 0:
    print('You can do the split')
    for i in range(grupos_totales):
      lista = list(range(nums[0],nums[0]+k))
      lista_k.append(lista)
      for element in lista:
        if element in nums:
          nums.remove(element)

  if (len(lista_k) == grupos_totales) and (len(nums) ==0):
    return True, print(lista_k)
  else:
    return False , print('No way to do the split')

```

```python
Solution([3,2,1,2,3,4,3,4,5,9,10,11,12,13,14], 3)
```

    You can do the split
    [[1, 2, 3], [2, 3, 4], [3, 4, 5], [9, 10, 11], [12, 13, 14]]

    (True, None)

```python
nums = [1,2,3,4]
k = 3
Solution([1,2,3,4],3)
```

    No way to do the split

    (False, None)

```python
#########################################################
#########################################################
```

```python

```

En este último ejercicio, se aborda el tema del precio de una, o varias transacciones de compra.

Dadas las variables, price_ether: representa el precio por transacción; nums_verifications: representa el número de imágenes
"registradas" hasta el momento.

Si hay que calcular el (n) número de transacciones tales el coste por imagen sea 0.10€.

Entonces, \begin{equation}
n = \frac { \text{price_ether} \times \text{nums_verications} }{\text{price_per_image = 0.1€}}
\end{equation}

```python

```

```python
def calculate_n(price_ether, new_verifications,):
  #esta funcion devuelve el número de imagenes a introducir si se quiere que el precio por imagen sea de 0.10
  return int(price_ether * new_verifications / 0.1)
```

```python
def calculate_n(price_ether, new_verifications,verification_cost):
  """
  calcula la cantidad de imagenes necesarias por paquetes para que cueste el verification_cost
  o no calcula eso y me lo estoy inventando.
  """
  return int(price_ether * new_verifications / verification_cost)
```

```python
calculate_n(1.44,100, 0.25)
```

    576

```python

```