Serabe Reloaded » Maths

Simple mathematical concepts I: Induction.

Serabe — Sun, 28 Mar 2010 23:54:17 +0000

After reading this and this I realized something is really, really wrong about mathematical concepts out there. Proof by induction is a really, really simple yet powerful proof method. In this post, I will talk about induction for natural numbers.

Induction is based on two steps, usually called basis and inductive step. I will proof that 1+2+…+n=n(n+1)/2 for all natural numbers using induction.

Basis or base case consists on proving the predicate for an initial value, usually a small one. In the example 1=1*2/2=1.
Inductive step consists on supposing the if the predicate holds for n, then it also holds for n+1. In the example:

1+2+…+n+(n+1)=(n+1)+n(n+1)/2 because we supposed that predicate held for n. We need to prove that this expression is equivalent to (n+1)(n+2)/2. Indeed,

(n+1)+n(n+1)/2=(n+1)(1+n/2)=(n+1)((2+n)/2)=(n+1)(2+n)/2

so the predicate has been proofed for all natural numbers.

Why does induction work?

Think of any natural number, as big as you want. Got it? We know that the predicate holds for 1, and that if the predicate holds for a number it holds for its successor. So it holds for 2, and for 3 and so on until it reach your number.

Other types of induction.

There are several types of inductions. Two of these types are structural induction and complete induction.

photo credit: hartboy

Problema 2

Serabe — Sun, 23 Mar 2008 21:37:14 +0000

Enunciado:
Suma todos los nÃºmeros pares de la sucesiÃ³n de Fibonacci menores que un cuatro millÃ³n.

Primera soluciÃ³n:

La primera soluciÃ³n es muy simple. Hay un mÃ©todo que devuelve un array con todos los nÃºmeros de la sucesiÃ³n de Fibonacci menores que un mÃ¡ximo max tomando como inicio un array de dos elementos arr.

PLAIN TEXT

RUBY:

def fib1(max,arr=[1,1])
while(arr.last ) do
arr <<(arr.last+arr[arr.size-2])
end
arr.pop
arr
end

DespuÃ©s simplemente se eliminan los impares y se suman los que quedan.

PLAIN TEXT

RUBY:

def euler2a(max, ini=[1,1])
fib1(max,ini).delete_if{|x| x%2 == 1}.inject{|memo,obj| memo+obj}
end
puts euler2a(4e6)

Segunda soluciÃ³n:

Esta soluciÃ³n es un poco mejor. Se va a hacer un nuevo mÃ©todo que calcule todos los nÃºmeros de la sucesiÃ³n de Fibonacci menores que un mÃ¡ximo max pero que sÃ³lo almacene aquellos que pasen una condiciÃ³n que se le pasa como bloque:

PLAIN TEXT

RUBY:

def fib2(max,a=1,b=1)
arr = []
arr <if yield(a)

  while(b) do

    arr <if yield(b)

a,b=b,a+b

end

arr

end

DespuÃ©s sÃ³lo hace falta pasar el filtro adecuado, y sumar los resultados:
PLAIN TEXT

RUBY:

def euler2b(max,a=1,b=1)

fib2(max,a,b){|x| x%2==0}.inject{|memo,obj| memo+obj}

end

puts euler2b(4e6)

Tercera soluciÃ³n:

Esta tercera soluciÃ³n es una modificaciÃ³n directa de la segunda. En vez de almacenar los datos, se suman directamente.

PLAIN TEXT

RUBY:

def fib3(max,a=1,b=1)

res = 0

res += a if yield(a)

while(b) do

res += b if yield(b)

a,b=b,a+b

end

res

end

def euler2c(max,a=1,b=1)

fib3(max,a,b){|x| x%2==0}

end

puts euler2c(4e6)

Y eso es todo.

ActualizaciÃ³n: Hay diferencias entre la pÃ¡gina de PyEuler y la del Proyecto Euler. El problema ha sido actualizado para corresponderse con esta Ãºltima.

Tweets del 19-03-2008

Serabe — Wed, 19 Mar 2008 22:59:59 +0000

Â¿Un objeto imposible? http://tinyurl.com/2nnd7b #

Problema 1

Serabe — Wed, 27 Feb 2008 12:20:56 +0000

Empiezo aquÃ una serie de artÃculos de periodicidad variable que lo Ãºnico que pretende es ser algo similar (de una manera muy amplia) a PyEuler. La lista completa de problemas estÃ¡ en el Proyecto Euler y, como no podÃa ser de otra manera, empiezo por el primero.

Enunciado:
Halla la suma de todos los nÃºmeros menores que 1000 y mÃºltiplos de 3 o de 5.

SoluciÃ³n 1:

PLAIN TEXT

RUBY:

def euler1a(e, numbers)

(1..e).select{|x| numbers.any?{|y| (x%y == 0)}}.inject{|memo,o| memo+=o}

end

puts euler1a(1000,[3,5])

La explicaciÃ³n es simple. Tenemos un rango desde 1 hasta el lÃmite, filtramos los que son mÃºltiplos de algÃºn elemento del array y despuÃ©s se suman.

SoluciÃ³n 2:

PLAIN TEXT

RUBY:

def euler1b(e,numbers)

(1..e).inject(0){|memo,o| (numbers.any?{|x| (o%x)==0}) ? memo+o : memo }

end

puts euler1b(1000,[3,5])

Ã‰ste es similar al anterior, sÃ³lo que se suma segÃºn se recorre el rango.

SoluciÃ³n 3:
Para este necesitamos antes un par de funciones. La primera, halla el mÃ¡ximo comÃºn divisor de dos nÃºmeros. Para ello, bÃ¡sicamente usa el algoritmo de Euclides.

PLAIN TEXT

RUBY:

def mcd(n1,n2)

if n1

mcd(n2,n1)

elsif (n1%n2) == 0

n2

else

mcd(n2,n1%n2)

end

end

Por otra parte, estÃ¡ la funciÃ³n que calcula el mÃnimo comÃºn mÃºltiplo. Para ello usa su relaciÃ³n con el m.c.d..

PLAIN TEXT

RUBY:

def mcm(n1,n2)

n1*n2/mcd(n1,n2)

end

Con esto, ya podemos pasar a la tercera soluciÃ³n, que es diferente de las otras dos en que sÃ³lo sirve si utilizamos dos nÃºmeros como filtro.

PLAIN TEXT

RUBY:

def euler1c(limit, n1, n2)

(n1*((limit/n1)*((limit/n1)+1)/2)+n2*((limit/n2)*((limit/n2)+1)/2)-mcm(n1,n2)*((limit/mcm(n1,n2))*((limit/mcm(n1,n2))+1)/2))

end

puts euler1c(1000,3,5)

La explicaciÃ³n es un poco mÃ¡s complicada, pues implica teorÃa bÃ¡sica de conjuntos y la conocida fÃ³rmula de la suma de 1 a n.

Ahora es vuestro turno. Â¿CÃ³mo se os ocurre hacerlo?