<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="es">
	<id>https://www.glc.us.es/~jalonso/SLEAM2010/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Frubioc</id>
	<title>Software Libre para la Enseñanza y el Aprendizaje de las Matemáticas (2010-11) - Contribuciones del usuario [es]</title>
	<link rel="self" type="application/atom+xml" href="https://www.glc.us.es/~jalonso/SLEAM2010/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Frubioc"/>
	<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php/Especial:Contribuciones/Frubioc"/>
	<updated>2026-07-18T08:40:43Z</updated>
	<subtitle>Contribuciones del usuario</subtitle>
	<generator>MediaWiki 1.31.0</generator>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=206</id>
		<title>2010 Ejercicio 5: Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=206"/>
		<updated>2010-04-21T13:52:55Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 1 (en wxMaxima 0.84) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en wxMaxima 0.84) ==&lt;br /&gt;
&lt;br /&gt;
Una solución usando el lenguaje de cálculo simbólico Máxima es:&lt;br /&gt;
&lt;br /&gt;
  (i%1) cont: 0$&lt;br /&gt;
        for i: 1 step 1 while cont&amp;lt;10001 do &lt;br /&gt;
        (&lt;br /&gt;
           if (primep(i) = true) then(&lt;br /&gt;
           cont: cont+1),&lt;br /&gt;
           if (cont = 10001) then(&lt;br /&gt;
             print(&amp;quot;El Número primo en la posición 10001 es: &amp;quot;,i))&lt;br /&gt;
        );&lt;br /&gt;
&lt;br /&gt;
  (o%1)  El Número primo en la posición 10001 es: 104743&lt;br /&gt;
         done&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=205</id>
		<title>2010 Ejercicio 5: Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=205"/>
		<updated>2010-04-21T13:46:11Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 1 (en Groovy) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en wxMaxima 0.84) ==&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=204</id>
		<title>2010 Ejercicio 5: Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=204"/>
		<updated>2010-04-21T13:45:49Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Enunciado */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=203</id>
		<title>2010 Ejercicio 5: Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_5:_Buscar_el_n%C3%BAmero_primo_que_ocupa_la_posici%C3%B3n_10001_en_la_secuencia_de_n%C3%BAmeros_primos&amp;diff=203"/>
		<updated>2010-04-21T13:45:14Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: Página creada con &amp;#039;== Enunciado == Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.  == Solución 1 (en Groovy) == La solución que propongo está escrita en lenguaje Groovy. Este …&amp;#039;&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=Ejercicios_del_proyecto_Euler_2010&amp;diff=202</id>
		<title>Ejercicios del proyecto Euler 2010</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=Ejercicios_del_proyecto_Euler_2010&amp;diff=202"/>
		<updated>2010-04-21T13:44:31Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En esta sección se encuentran ejercicios del [http://projecteuler.net/ proyecto Euler] realizados con los sistemas de software libre.&lt;br /&gt;
* [[Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5]].&lt;br /&gt;
* [[Ejercicio 2: Sumar los términos pares de la sucesión de Fibonacci que no superen los 4000000]].&lt;br /&gt;
* [[Ejercicio 3: Calcular el mayor factor primo de un número compuesto]].&lt;br /&gt;
* [[Ejercicio 4: Calcular el mayor palíndromo producto de números de 3 cifras]].&lt;br /&gt;
* [[Ejercicio 5: Buscar el número primo que ocupa la posición 10001 en la secuencia de números primos]].&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=201</id>
		<title>2010 Ejercicio 2: Sumar los términos pares de la sucesión de Fibonacci que no superen los 4000000</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=201"/>
		<updated>2010-04-20T21:56:01Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución alternativa (con wxMaxima 0.8.4) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los términos pares de la sucesión de Fibonacci menores de 4000000.&lt;br /&gt;
&lt;br /&gt;
== Solución ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Aunque el enunciado presenta la sucesión de Fibonacci como 1,2,3,5,... en muchos otros sitios aparece como 0,1,1,2,3,5,... De todas formas, como nos quedamos con los términos pares no hay problema&lt;br /&gt;
&lt;br /&gt;
Solución: 4613732. Primero construyo la sucesión y a continuación sumo los términos pares. Obsérvese el uso de índices negativos para acceder a las posiciones última y penúltima de la lista y así construir el siguiente término de la sucesión&lt;br /&gt;
 def sucesion = [1, 2]&lt;br /&gt;
 &lt;br /&gt;
 while (sucesion.last() &amp;lt; 4000000) {&lt;br /&gt;
     sucesion &amp;lt;&amp;lt; sucesion .getAt(-1) + sucesion .getAt(-2)&lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 def suma_pares = sucesion.findAll { it % 2 == 0 }.sum()&lt;br /&gt;
 println suma_pares&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución alternativa (con wxMaxima 0.8.4) ==&lt;br /&gt;
La solución que propongo está escrita en Maxima, que es un sistema de cálculo simbólico escrito en Lisp.&lt;br /&gt;
&lt;br /&gt;
Mi solución es: &amp;#039;&amp;#039;&amp;#039;3524578&amp;#039;&amp;#039;&amp;#039;.  Esta solución se corresponde con la suma de n números de Fibonacci, siendo n par &lt;br /&gt;
y Fib[n] menor que 4000000.  Concretamente el algoritmo realiza un total de 34 iteraciones (de la 0 a la 33), &lt;br /&gt;
siendo el último término de Fibonacci sumado Fib[32].  El algoritmo utilizado es el siguiente:&lt;br /&gt;
&lt;br /&gt;
  (%i1) &lt;br /&gt;
         fib1[0]:0$&lt;br /&gt;
         fib1[1]:1$&lt;br /&gt;
         fib1[n]:=fib1[n-1]+fib1[n-2]$&lt;br /&gt;
         s: 0$&lt;br /&gt;
         for i: 0 step 1 while fib1[i] &amp;lt; 4000000 do &lt;br /&gt;
         (&lt;br /&gt;
           print (&amp;quot;Fibonacci it. &amp;quot;,i,&amp;quot; = &amp;quot;,fib1[i]),  &lt;br /&gt;
           if (i &amp;gt;= 2) then (&lt;br /&gt;
             if (mod(i,2) = 0) then(&lt;br /&gt;
               s: s+fib1[i],&lt;br /&gt;
               print(&amp;quot;La suma par es: &amp;quot;, s)&lt;br /&gt;
             )&lt;br /&gt;
           )&lt;br /&gt;
         );&lt;br /&gt;
&lt;br /&gt;
Dicho algoritmo imprime para cada iteración &amp;#039;&amp;#039;i&amp;#039;&amp;#039; el término de la sucesión de Fibonacci correspondiente (Fib[i]), &lt;br /&gt;
así como la suma acumulada si la iteración &amp;#039;&amp;#039;i&amp;#039;&amp;#039; es par.  Un ejemplo del resultado obtenido será el siguiente:&lt;br /&gt;
 &lt;br /&gt;
 (%o1)&lt;br /&gt;
         Fibonacci it. 0 = 0&lt;br /&gt;
         Fibonacci it. 1 = 1&lt;br /&gt;
         Fibonacci it. 2 = 1&lt;br /&gt;
         La suma par es: 1&lt;br /&gt;
         Fibonacci it. 3 = 2&lt;br /&gt;
         Fibonacci it. 4 = 3&lt;br /&gt;
         La suma par es: 4&lt;br /&gt;
         Fibonacci it. 5 = 5&lt;br /&gt;
         Fibonacci it. 6 = 8&lt;br /&gt;
         La suma par es: 12&lt;br /&gt;
         ....&lt;br /&gt;
         ....&lt;br /&gt;
         Fibonacci it. 30 = 832040&lt;br /&gt;
         La suma par es: 1346268&lt;br /&gt;
         Fibonacci it. 31 = 1346269&lt;br /&gt;
         Fibonacci it. 32 = 2178309&lt;br /&gt;
         La suma par es: 3524577&lt;br /&gt;
         Fibonacci it. 33 = 3524578&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=200</id>
		<title>2010 Ejercicio 2: Sumar los términos pares de la sucesión de Fibonacci que no superen los 4000000</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=200"/>
		<updated>2010-04-20T21:55:09Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución alternativa (con wxMaxima 0.8.4) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los términos pares de la sucesión de Fibonacci menores de 4000000.&lt;br /&gt;
&lt;br /&gt;
== Solución ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Aunque el enunciado presenta la sucesión de Fibonacci como 1,2,3,5,... en muchos otros sitios aparece como 0,1,1,2,3,5,... De todas formas, como nos quedamos con los términos pares no hay problema&lt;br /&gt;
&lt;br /&gt;
Solución: 4613732. Primero construyo la sucesión y a continuación sumo los términos pares. Obsérvese el uso de índices negativos para acceder a las posiciones última y penúltima de la lista y así construir el siguiente término de la sucesión&lt;br /&gt;
 def sucesion = [1, 2]&lt;br /&gt;
 &lt;br /&gt;
 while (sucesion.last() &amp;lt; 4000000) {&lt;br /&gt;
     sucesion &amp;lt;&amp;lt; sucesion .getAt(-1) + sucesion .getAt(-2)&lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 def suma_pares = sucesion.findAll { it % 2 == 0 }.sum()&lt;br /&gt;
 println suma_pares&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución alternativa (con wxMaxima 0.8.4) ==&lt;br /&gt;
La solución que propongo está escrita en Maxima, que es un sistema de cálculo simbólico escrito en Lisp.&lt;br /&gt;
&lt;br /&gt;
Mi solución es: &amp;#039;&amp;#039;&amp;#039;3524578&amp;#039;&amp;#039;&amp;#039;.  Esta solución se corresponde con la suma de n números de Fibonacci, siendo n par &lt;br /&gt;
y Fib[n] menor que 4000000.  Concretamente el algoritmo realiza un total de 34 iteraciones (de la 0 a la 33), &lt;br /&gt;
siendo el último término de Fibonacci sumado Fib[32].&lt;br /&gt;
&lt;br /&gt;
  (%i1) &lt;br /&gt;
         fib1[0]:0$&lt;br /&gt;
         fib1[1]:1$&lt;br /&gt;
         fib1[n]:=fib1[n-1]+fib1[n-2]$&lt;br /&gt;
         s: 0$&lt;br /&gt;
         for i: 0 step 1 while fib1[i] &amp;lt; 4000000 do &lt;br /&gt;
         (&lt;br /&gt;
           print (&amp;quot;Fibonacci it. &amp;quot;,i,&amp;quot; = &amp;quot;,fib1[i]),  &lt;br /&gt;
           if (i &amp;gt;= 2) then (&lt;br /&gt;
             if (mod(i,2) = 0) then(&lt;br /&gt;
               s: s+fib1[i],&lt;br /&gt;
               print(&amp;quot;La suma par es: &amp;quot;, s)&lt;br /&gt;
             )&lt;br /&gt;
           )&lt;br /&gt;
         );&lt;br /&gt;
&lt;br /&gt;
El algoritmo imprime para cada iteración &amp;#039;&amp;#039;i&amp;#039;&amp;#039; el término de la sucesión de Fibonacci correspondiente (Fib[i]), &lt;br /&gt;
así como la suma acumulada si la iteración &amp;#039;&amp;#039;i&amp;#039;&amp;#039; es par.  Un ejemplo del resultado obtenido será el siguiente:&lt;br /&gt;
 &lt;br /&gt;
 (%o1)&lt;br /&gt;
         Fibonacci it. 0 = 0&lt;br /&gt;
         Fibonacci it. 1 = 1&lt;br /&gt;
         Fibonacci it. 2 = 1&lt;br /&gt;
         La suma par es: 1&lt;br /&gt;
         Fibonacci it. 3 = 2&lt;br /&gt;
         Fibonacci it. 4 = 3&lt;br /&gt;
         La suma par es: 4&lt;br /&gt;
         Fibonacci it. 5 = 5&lt;br /&gt;
         Fibonacci it. 6 = 8&lt;br /&gt;
         La suma par es: 12&lt;br /&gt;
         ....&lt;br /&gt;
         ....&lt;br /&gt;
         Fibonacci it. 30 = 832040&lt;br /&gt;
         La suma par es: 1346268&lt;br /&gt;
         Fibonacci it. 31 = 1346269&lt;br /&gt;
         Fibonacci it. 32 = 2178309&lt;br /&gt;
         La suma par es: 3524577&lt;br /&gt;
         Fibonacci it. 33 = 3524578&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=199</id>
		<title>2010 Ejercicio 2: Sumar los términos pares de la sucesión de Fibonacci que no superen los 4000000</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=199"/>
		<updated>2010-04-20T21:45:28Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución alternativa (con wxMaxima 0.8.4) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los términos pares de la sucesión de Fibonacci menores de 4000000.&lt;br /&gt;
&lt;br /&gt;
== Solución ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Aunque el enunciado presenta la sucesión de Fibonacci como 1,2,3,5,... en muchos otros sitios aparece como 0,1,1,2,3,5,... De todas formas, como nos quedamos con los términos pares no hay problema&lt;br /&gt;
&lt;br /&gt;
Solución: 4613732. Primero construyo la sucesión y a continuación sumo los términos pares. Obsérvese el uso de índices negativos para acceder a las posiciones última y penúltima de la lista y así construir el siguiente término de la sucesión&lt;br /&gt;
 def sucesion = [1, 2]&lt;br /&gt;
 &lt;br /&gt;
 while (sucesion.last() &amp;lt; 4000000) {&lt;br /&gt;
     sucesion &amp;lt;&amp;lt; sucesion .getAt(-1) + sucesion .getAt(-2)&lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 def suma_pares = sucesion.findAll { it % 2 == 0 }.sum()&lt;br /&gt;
 println suma_pares&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución alternativa (con wxMaxima 0.8.4) ==&lt;br /&gt;
La solución que propongo está escrita en Maxima, que es un sistema de cálculo simbólico escrito en Lisp.&lt;br /&gt;
&lt;br /&gt;
Mi solución es: &amp;#039;&amp;#039;&amp;#039;3524578&amp;#039;&amp;#039;&amp;#039;.  Esta solución se corresponde con la suma de n números de Fibonacci, siendo n par &lt;br /&gt;
y Fib[n] menor que 4000000.  Concretamente el algoritmo realiza un total de 34 iteraciones (de la 0 a la 33), &lt;br /&gt;
siendo el último término de Fibonacci sumado Fib[32].&lt;br /&gt;
&lt;br /&gt;
 (%i1) &lt;br /&gt;
  fib1[0]:0$&lt;br /&gt;
  fib1[1]:1$&lt;br /&gt;
  fib1[n]:=fib1[n-1]+fib1[n-2]$&lt;br /&gt;
  s: 0$&lt;br /&gt;
  for i: 0 step 1 while fib1[i] &amp;lt; 4000000 do &lt;br /&gt;
  (&lt;br /&gt;
    print (&amp;quot;Fibonacci it. &amp;quot;,i,&amp;quot; = &amp;quot;,fib1[i]),  &lt;br /&gt;
    if (i &amp;gt;= 2) then (&lt;br /&gt;
      if (mod(i,2) = 0) then(&lt;br /&gt;
        s: s+fib1[i],&lt;br /&gt;
        print(&amp;quot;La suma par es: &amp;quot;, s)&lt;br /&gt;
      )&lt;br /&gt;
    )&lt;br /&gt;
  );&lt;br /&gt;
&lt;br /&gt;
El algoritmo lo que muestra exactamente es una traza con la suma para cada una de las iteraciones. Un ejemplo del resultado&lt;br /&gt;
obtenido será el siguiente.&lt;br /&gt;
 &lt;br /&gt;
 (%o1)&lt;br /&gt;
 Fibonacci it. 0 = 0&lt;br /&gt;
 Fibonacci it. 1 = 1&lt;br /&gt;
 Fibonacci it. 2 = 1&lt;br /&gt;
 La suma par es: 1&lt;br /&gt;
 Fibonacci it. 3 = 2&lt;br /&gt;
 Fibonacci it. 4 = 3&lt;br /&gt;
 La suma par es: 4&lt;br /&gt;
 Fibonacci it. 5 = 5&lt;br /&gt;
 Fibonacci it. 6 = 8&lt;br /&gt;
 La suma par es: 12&lt;br /&gt;
 ....&lt;br /&gt;
 ....&lt;br /&gt;
 Fibonacci it. 30 = 832040&lt;br /&gt;
 La suma par es: 1346268&lt;br /&gt;
 Fibonacci it. 31 = 1346269&lt;br /&gt;
 Fibonacci it. 32 = 2178309&lt;br /&gt;
 La suma par es: 3524577&lt;br /&gt;
 Fibonacci it. 33 = 3524578&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=198</id>
		<title>2010 Ejercicio 2: Sumar los términos pares de la sucesión de Fibonacci que no superen los 4000000</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=198"/>
		<updated>2010-04-20T21:43:59Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución alternativa (con wxMaxima 0.8.4) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los términos pares de la sucesión de Fibonacci menores de 4000000.&lt;br /&gt;
&lt;br /&gt;
== Solución ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Aunque el enunciado presenta la sucesión de Fibonacci como 1,2,3,5,... en muchos otros sitios aparece como 0,1,1,2,3,5,... De todas formas, como nos quedamos con los términos pares no hay problema&lt;br /&gt;
&lt;br /&gt;
Solución: 4613732. Primero construyo la sucesión y a continuación sumo los términos pares. Obsérvese el uso de índices negativos para acceder a las posiciones última y penúltima de la lista y así construir el siguiente término de la sucesión&lt;br /&gt;
 def sucesion = [1, 2]&lt;br /&gt;
 &lt;br /&gt;
 while (sucesion.last() &amp;lt; 4000000) {&lt;br /&gt;
     sucesion &amp;lt;&amp;lt; sucesion .getAt(-1) + sucesion .getAt(-2)&lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 def suma_pares = sucesion.findAll { it % 2 == 0 }.sum()&lt;br /&gt;
 println suma_pares&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución alternativa (con wxMaxima 0.8.4) ==&lt;br /&gt;
La solución que propongo está escrita en Maxima, que es un sistema de cálculo simbólico escrito en Lisp.&lt;br /&gt;
&lt;br /&gt;
Mi solución es: &amp;#039;&amp;#039;&amp;#039;3524578&amp;#039;&amp;#039;&amp;#039;.  Esta solución se corresponde con la suma de n números de Fibonacci, siendo n par &lt;br /&gt;
y Fib[n] menor que 4000000.  Concretamente el algoritmo realiza un total de 34 iteraciones (de la 0 a la 33), &lt;br /&gt;
siendo el último término de Fibonacci sumado Fib[32].&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
 (%i1) &lt;br /&gt;
  fib1[0]:0$&lt;br /&gt;
  fib1[1]:1$&lt;br /&gt;
  fib1[n]:=fib1[n-1]+fib1[n-2]$&lt;br /&gt;
  s: 0$&lt;br /&gt;
  for i: 0 step 1 while fib1[i] &amp;lt; 4000000 do &lt;br /&gt;
  (&lt;br /&gt;
    print (&amp;quot;Fibonacci it. &amp;quot;,i,&amp;quot; = &amp;quot;,fib1[i]),  &lt;br /&gt;
    if (i &amp;gt;= 2) then (&lt;br /&gt;
      if (mod(i,2) = 0) then(&lt;br /&gt;
        s: s+fib1[i],&lt;br /&gt;
        print(&amp;quot;La suma par es: &amp;quot;, s)&lt;br /&gt;
      )&lt;br /&gt;
    )&lt;br /&gt;
  );&lt;br /&gt;
&lt;br /&gt;
El algoritmo lo que muestra exactamente es una traza con la suma para cada una de las iteraciones. Un ejemplo del resultado&lt;br /&gt;
obtenido será el siguiente.&lt;br /&gt;
 &lt;br /&gt;
 (%o1)&lt;br /&gt;
 Fibonacci it. 0 = 0&lt;br /&gt;
 Fibonacci it. 1 = 1&lt;br /&gt;
 Fibonacci it. 2 = 1&lt;br /&gt;
 La suma par es: 1&lt;br /&gt;
 Fibonacci it. 3 = 2&lt;br /&gt;
 Fibonacci it. 4 = 3&lt;br /&gt;
 La suma par es: 4&lt;br /&gt;
 Fibonacci it. 5 = 5&lt;br /&gt;
 Fibonacci it. 6 = 8&lt;br /&gt;
 La suma par es: 12&lt;br /&gt;
 ....&lt;br /&gt;
 ....&lt;br /&gt;
 Fibonacci it. 30 = 832040&lt;br /&gt;
 La suma par es: 1346268&lt;br /&gt;
 Fibonacci it. 31 = 1346269&lt;br /&gt;
 Fibonacci it. 32 = 2178309&lt;br /&gt;
 La suma par es: 3524577&lt;br /&gt;
 Fibonacci it. 33 = 3524578&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=197</id>
		<title>2010 Ejercicio 2: Sumar los términos pares de la sucesión de Fibonacci que no superen los 4000000</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_2:_Sumar_los_t%C3%A9rminos_pares_de_la_sucesi%C3%B3n_de_Fibonacci_que_no_superen_los_4000000&amp;diff=197"/>
		<updated>2010-04-20T21:42:54Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los términos pares de la sucesión de Fibonacci menores de 4000000.&lt;br /&gt;
&lt;br /&gt;
== Solución ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Aunque el enunciado presenta la sucesión de Fibonacci como 1,2,3,5,... en muchos otros sitios aparece como 0,1,1,2,3,5,... De todas formas, como nos quedamos con los términos pares no hay problema&lt;br /&gt;
&lt;br /&gt;
Solución: 4613732. Primero construyo la sucesión y a continuación sumo los términos pares. Obsérvese el uso de índices negativos para acceder a las posiciones última y penúltima de la lista y así construir el siguiente término de la sucesión&lt;br /&gt;
 def sucesion = [1, 2]&lt;br /&gt;
 &lt;br /&gt;
 while (sucesion.last() &amp;lt; 4000000) {&lt;br /&gt;
     sucesion &amp;lt;&amp;lt; sucesion .getAt(-1) + sucesion .getAt(-2)&lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 def suma_pares = sucesion.findAll { it % 2 == 0 }.sum()&lt;br /&gt;
 println suma_pares&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución alternativa (con wxMaxima 0.8.4) ==&lt;br /&gt;
La solución que propongo está escrita en Maxima, que es un sistema de cálculo simbólico escrito en Lisp.&lt;br /&gt;
&lt;br /&gt;
Mi solución es: 3524578.  Esta solución se corresponde con la suma de n números de Fibonacci, siendo n par &lt;br /&gt;
y Fib[n] menor que 4000000.  Concretamente el algoritmo realiza un total de 34 iteraciones (de la 0 a la 33), &lt;br /&gt;
siendo el último término de Fibonacci sumado Fib[32].&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
(%i1) &lt;br /&gt;
  fib1[0]:0$&lt;br /&gt;
  fib1[1]:1$&lt;br /&gt;
  fib1[n]:=fib1[n-1]+fib1[n-2]$&lt;br /&gt;
  s: 0$&lt;br /&gt;
  for i: 0 step 1 while fib1[i] &amp;lt; 4000000 do &lt;br /&gt;
  (&lt;br /&gt;
    print (&amp;quot;Fibonacci it. &amp;quot;,i,&amp;quot; = &amp;quot;,fib1[i]),  &lt;br /&gt;
    if (i &amp;gt;= 2) then (&lt;br /&gt;
      if (mod(i,2) = 0) then(&lt;br /&gt;
        s: s+fib1[i],&lt;br /&gt;
        print(&amp;quot;La suma par es: &amp;quot;, s)&lt;br /&gt;
      )&lt;br /&gt;
    )&lt;br /&gt;
  );&lt;br /&gt;
&lt;br /&gt;
El algoritmo lo que muestra exactamente es una traza con la suma para cada una de las iteraciones. Un ejemplo del resultado&lt;br /&gt;
obtenido será el siguiente.&lt;br /&gt;
 &lt;br /&gt;
 (%o1)&lt;br /&gt;
 Fibonacci it. 0 = 0&lt;br /&gt;
 Fibonacci it. 1 = 1&lt;br /&gt;
 Fibonacci it. 2 = 1&lt;br /&gt;
 La suma par es: 1&lt;br /&gt;
 Fibonacci it. 3 = 2&lt;br /&gt;
 Fibonacci it. 4 = 3&lt;br /&gt;
 La suma par es: 4&lt;br /&gt;
 Fibonacci it. 5 = 5&lt;br /&gt;
 Fibonacci it. 6 = 8&lt;br /&gt;
 La suma par es: 12&lt;br /&gt;
&lt;br /&gt;
 ....&lt;br /&gt;
 ....&lt;br /&gt;
&lt;br /&gt;
 Fibonacci it. 30 = 832040&lt;br /&gt;
 La suma par es: 1346268&lt;br /&gt;
 Fibonacci it. 31 = 1346269&lt;br /&gt;
 Fibonacci it. 32 = 2178309&lt;br /&gt;
 La suma par es: 3524577&lt;br /&gt;
 Fibonacci it. 33 = 3524578&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=179</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=179"/>
		<updated>2010-04-19T21:55:45Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 3 (utilizando wxMaxima 0.8.4) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php, por ejemplo, sol.php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0;&lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol.php&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 3 (utilizando wxMaxima 0.8.4) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de cálculo simbólico Máxima.&lt;br /&gt;
&lt;br /&gt;
  (i%1) suma : 0$&lt;br /&gt;
        for i:1 thru 999 do (&lt;br /&gt;
        if( mod(i,3)=0 or mod(i,5)=0 ) then (&lt;br /&gt;
        suma : suma + i))$&lt;br /&gt;
        print (&amp;quot;La suma es: &amp;quot;, suma)$;&lt;br /&gt;
&lt;br /&gt;
  (o%1) La suma es: 233168&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=178</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=178"/>
		<updated>2010-04-19T21:55:06Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 3 (utilizando wxMaxima 0.8.4) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php, por ejemplo, sol.php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0;&lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol.php&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 3 (utilizando wxMaxima 0.8.4) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de cálculo simbólico Máxima.&lt;br /&gt;
&lt;br /&gt;
  (i%1) suma : 0$&lt;br /&gt;
        for i:1 thru 999 do (&lt;br /&gt;
        if(mod (i,3)=0 or mod (i,5)=0) then (&lt;br /&gt;
        suma : suma + i))$&lt;br /&gt;
        print (&amp;quot;La suma es: &amp;quot;, suma)$;&lt;br /&gt;
&lt;br /&gt;
  (o%1) La suma es: 233168&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=177</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=177"/>
		<updated>2010-04-19T21:50:07Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 3 (utilizando wxMaxima 0.8.4) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php, por ejemplo, sol.php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0;&lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol.php&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 3 (utilizando wxMaxima 0.8.4) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de cálculo simbólico Máxima.&lt;br /&gt;
&lt;br /&gt;
  (i%1) suma : 0;&lt;br /&gt;
        for i:1 thru 999 do (&lt;br /&gt;
        if(mod (i,3)=0 or mod (i,5)=0) then (&lt;br /&gt;
        suma : suma + i));&lt;br /&gt;
        print (&amp;quot;La suma es: &amp;quot;, suma);&lt;br /&gt;
&lt;br /&gt;
  (o%1) 0&lt;br /&gt;
  (o%2) done&lt;br /&gt;
       La suma es: 233168&lt;br /&gt;
  (o%3) 233168&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=176</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=176"/>
		<updated>2010-04-19T21:49:42Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php, por ejemplo, sol.php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0;&lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol.php&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 3 (utilizando wxMaxima 0.8.4) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de cálculo simbólico Máxima.&lt;br /&gt;
&lt;br /&gt;
  (i%1) suma : 0;&lt;br /&gt;
        for i:1 thru 999 do (&lt;br /&gt;
        if(mod (i, 3)=0 or mod (i, 5)=0) then (&lt;br /&gt;
        suma : suma + i));&lt;br /&gt;
        print (&amp;quot;La suma es: &amp;quot;, suma);&lt;br /&gt;
&lt;br /&gt;
  (o%1) 0&lt;br /&gt;
  (o%2) done&lt;br /&gt;
       La suma es: 233168&lt;br /&gt;
  (o%3) 233168&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=173</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=173"/>
		<updated>2010-04-19T20:25:04Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php, por ejemplo, sol.php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0;&lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=172</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=172"/>
		<updated>2010-04-19T17:52:44Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0;&lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=171</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=171"/>
		<updated>2010-04-19T17:51:21Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
&lt;br /&gt;
 $suma = 0;&lt;br /&gt;
&lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=170</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=170"/>
		<updated>2010-04-19T17:42:41Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
 { &lt;br /&gt;
   if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
     $suma = $suma + $i;&lt;br /&gt;
 } &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=169</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=169"/>
		<updated>2010-04-19T17:37:57Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
  if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
  &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
 sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=168</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=168"/>
		<updated>2010-04-19T17:37:43Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
  if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
  &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, &lt;br /&gt;
sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=167</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=167"/>
		<updated>2010-04-19T17:37:30Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
 - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
 - Crear un archivo .php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
  if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
  &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
 - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
 - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=166</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=166"/>
		<updated>2010-04-19T17:35:59Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
    - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
    - Crear un archivo .php con el siguiente código:&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
  if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i;&lt;br /&gt;
  &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
 ?&amp;gt;&lt;br /&gt;
&lt;br /&gt;
    - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
    - Acceder a la url del archivo.  Si estamos en local y por ejemplo hemos guardado nuestro archivo en la carpeta pruebas, sólo tendremos que poner la siguiente ruta en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=165</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=165"/>
		<updated>2010-04-19T17:31:43Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: /* Solución 2 (en PHP) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
    - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
    - Crear un archivo .php con el siguiente código.&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
 $suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
  if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i&lt;br /&gt;
  &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
&lt;br /&gt;
 &amp;lt;?php&lt;br /&gt;
&lt;br /&gt;
    - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
    - Acceder al archivo mediante el navegador.  Si estamos en local y por ejemplo hemos guardado nuestro archivo .php en la carpeta pruebas, sólo tendremos que poner la siguiente url en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
	<entry>
		<id>https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=164</id>
		<title>2010 Ejercicio 1: Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5</title>
		<link rel="alternate" type="text/html" href="https://www.glc.us.es/~jalonso/SLEAM2010/index.php?title=2010_Ejercicio_1:_Sumar_los_enteros_menores_de_1000_que_sean_m%C3%BAltiplos_de_3_%C3%B3_5&amp;diff=164"/>
		<updated>2010-04-19T17:31:10Z</updated>

		<summary type="html">&lt;p&gt;Frubioc: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Enunciado ==&lt;br /&gt;
Sumar los enteros menores de 1000 que sean múltiplos de 3 ó 5.&lt;br /&gt;
&lt;br /&gt;
== Solución 1 (en Groovy) ==&lt;br /&gt;
La solución que propongo está escrita en lenguaje Groovy. Este es un lenguaje muy reciente con licencia libre y derivado del Java, por tanto entra dentro de la categoría de lenguajes orientados a objetos. En la página http://groovyconsole.appspot.com/ podemos introducir el código y ejecutarlo pulsando &amp;quot;Execute Script&amp;quot;. &lt;br /&gt;
&lt;br /&gt;
Quien desee aprender más acerca de dicho lenguaje puede visitar la página http://groovy.codehaus.org/. Actualmente me gano la vida programando en dicho lenguaje ;)&lt;br /&gt;
&lt;br /&gt;
Solución: 233168&lt;br /&gt;
&lt;br /&gt;
 def suma = 0&lt;br /&gt;
 &lt;br /&gt;
 for (i in 1..999) {&lt;br /&gt;
     if (i%3 == 0 || i%5 == 0) {&lt;br /&gt;
         suma = suma + i&lt;br /&gt;
     }   &lt;br /&gt;
 }&lt;br /&gt;
 &lt;br /&gt;
 println(suma)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solución 2 (en PHP) ==&lt;br /&gt;
&lt;br /&gt;
Otra solución alternativa es usar un lenguaje de programación interpretado como PHP.  Aunque originalmente, fue concebido para la creación de páginas web dinámicas también nos permite resolver este tipo de problemas.  Para probar la solución sólo tendremos que realizar lo siguiente:&lt;br /&gt;
&lt;br /&gt;
    - Tener un servidor que interprete PHP, como por ejemplo Apache.&lt;br /&gt;
    - Crear un archivo .php con el siguiente código.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;?php&lt;br /&gt;
$suma = 0&lt;br /&gt;
 &lt;br /&gt;
for ($i=1; $i&amp;lt;1000; $i++) &lt;br /&gt;
  if ($i%3 == 0 || $i%5 == 0) &lt;br /&gt;
    $suma = $suma + $i&lt;br /&gt;
  &lt;br /&gt;
 echo &amp;quot;La suma de los enteros menores de 1000 que sean múltiplos de 3 ó 5 es: &amp;quot;.$suma;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;?php&lt;br /&gt;
&lt;br /&gt;
    - Guardar el archivo en la carpeta de documentos del servidor.&lt;br /&gt;
    - Acceder al archivo mediante el navegador.  Si estamos en local y por ejemplo hemos guardado nuestro archivo .php en la carpeta pruebas, sólo tendremos que poner la siguiente url en la barra de dirección del navegador: http://localhost/pruebas/sol2.php&lt;/div&gt;</summary>
		<author><name>Frubioc</name></author>
		
	</entry>
</feed>