Euler #34

Tras un largo parón, otro problema del proyecto Euler, de nuevo lo solucionamos con Python. Tratando los números como cadenas de texto y convirtiendo los dígitos de nuevo a enteros el problema es muy sencillo de resolver.

https://projecteuler.net/problem=34

def fact(n):
 if n <= 1:
  return 1
 else:
  return n * fact(n - 1)

candidates = []
n = 3
while True:
# print "Analizyng", n
 n_str = str(n)
 partial_sum = 0
 for digit in n_str:
  partial_sum += fact(int(digit))
 if partial_sum == n:
  candidates.append(n)
 if n > 1000000:
  break
 n += 1

#print candidates
print sum(candidates)

Euler #33

https://projecteuler.net/problem=33

De nuevo, la facilidad que ofrece Python para pasar de unos tipos a otros y los módulos estándar que trae hacen que este problema sea trivial.

Se puede compactar más la solución, pero así se ve claro cómo vamos filtrando poco a poco los números candidatos hasta llegar a la solución. También ayuda mucho el enunciado del problema, estableciendo cuántos resultados son esperables.

#!/usr/bin/env python
from fractions import Fraction
from operator import mul

fracts = []
for d in range(10, 100):
 for n in range(10, 100):
  if n / d < 1 and n % 10 != 0 and d % 10 != 0:
   num = str(n)
   den = str(d)
   for x in range(1, 10):
    xstr = str(x)
    if (num[0] == xstr and den[1] == xstr) or (num[1] == xstr and den[0] == xstr):
     new_n = int(num.replace(xstr, '', 1))
     new_d = int(den.replace(xstr, '', 1))
     if (new_n * d == new_d * n):
      fracts.append(Fraction(new_n, new_d))

print reduce(mul, fracts, 1)

La función "reduce" es muy útil para operar con listas en bloque. Es un atajo para no tener que escribir bucles:

tot = 1
for f in fracts:
    tot *= f
print tot

Así mismo, la clase Fraction es lo suficientemente inteligente para lidiar con enteros, operar con fracciones, simplificarlas,...

Euler #32

Llevaba bastante tiempo parado con la resolución de problemas del proyecto Euler.
Vamos con el número 32. La resolución con Python es muy fácil convirtiendo enteros en "strings":

#!/usr/bin/env python

numbers = []

for a in range(9999):
  for b in range(9999):
    p = a*b
    asString = str(a) + str(b) + str(p)
    if len(asString) > 9:
      break
    if len(asString) == 9 and \
     '1' in asString and \
     '2' in asString and \
     '3' in asString and \
     '4' in asString and \
     '5' in asString and \
     '6' in asString and \
     '7' in asString and \
     '8' in asString and \
     '9' in asString:
     if not p in numbers:
       numbers.append(p)
       print a, "*", b, " = ", p, " => ", asString

print sum(numbers)

Meld, tremenda herramienta

Hasta ahora había utilizado siempre Meld para apañar merges y conflictos cuando trabajo con Git, pero tiene muchas más utilidades. Acabo de descubrir, tras unos cuantos años, que también compara directorios, y lo hace de una forma muy fácil y vistosa.

Puede mostrar los ficheros que están un directorio y los que no, los que son más recientes, los borrados... y por supuesto, el "side to side" de cualquier fichero.

Por ponerlo en contexto, lo que se muestra es un "theme" de Wordpress que ha sido muy modificado y se le quiere parchear con los nuevos cambios del desarrollador. En verde, a la derecha, nos muestra los ficheros nuevos; tachados, a la izquierda, los que no están presentes; en negrita azul, los que tienen cambios,...

Por supuesto, se puede hacer un diff de los ficheros y editarlos directamente.

Más conjuntos de Mandelbrot

En la anterior entrada vimos por encima qué era el conjunto de Mandelbrot y cómo se podía generar el gráfico. Recordamos que todo se basaba en la función generadora z²+c. Se puede cambiar la función y repetir el proceso con otras. Estudiemos otras variantes:

• (z+c)(z-c)
• z³+c
• z⁴+c

Para implementar estas nuevas funciones, dado que hay que hacer algunas operaciones un tanto tediosas, pensé en utilizar alguna librería Javascript que facilitase el trabajo con números complejos. Probé Mathjs, pero es demasiado lenta, así que se ha quedado todo como Javascript plano.


De nuevo, obtenemos unos bonitos fractales.

(z+c)(z-c)

z³+ c

z⁴+c

En esta página tenemos el código modificado:

https://david-aa.github.io/math/mandelbrot.html