adding problems

_posts/2015-06-08-comerciante-de-naranjas.md

@@ -22,47 +22,4 @@ Mostrar un entero: la cantidad en soles que el comerciante debe retirar del banc
 #### Salida
 ```
 16
-```
-
-## Soluciones
-Lo primero que debemos observar es que el límite para el precio de una naranja es $1000$ soles (deben ser naranjas muy especiales), y si consideramos que el costo de la última naranja podría ser $10^{12}$ soles nos daremos cuenta de que ese es un número muy grande.
-En C++ los enteros (generalmente) son almacenados en un tipo de dato llamado integer de 4 bytes, eso quiere decir que tiene 32 bits (31 en realidad porque almacenamos el signo en un bit) para representar números, esto es cualquier número entre $2^{31}$ ($–2,147,483,648$) hasta $2^{31}-1$ ($2,147,483,647$), es decir approximadamente (2.1 veces) $10^9$.
-
-Como el costo total podría exceder esa cantidad no podemos utilizar integers para resolver el problema. Por suerte también existe otro tipo de dato que nos permite almacenar números enteros mayores y es el long long con 8 bytes, por lo tanto tiene 64 bits para representar números (63 quitando el bit del signo), esto es cualquier número entre $-2^{63}$ ($-9,223,372,036,854,775,808$) hasta $2^{63}-1$ ($9,223,372,036,854,775,807$).
-
-Entonces la solución más simple sería
-
-``` cpp
-#include <iostream>
-
-using namespace std;
-
-void main() {
-	int k, w, n;
-	cin >> k >> n >> w;
-	long long total = 0;
-	for (int i = 1; i <= w; ++i)
-		total += i*k;
-	if (total > n)
-		cout << total - n << endl;
-	else
-		cout << 0 << endl;
-}
-```
-
-Sin embargo, si recordamos nuestras clases de matemática podemos ver que $k$ siempre es una constante, entonces podríamos factorizarlo y luego nos quedamos con un sumatorio de la siguiente forma $1 + 2 + 3 + \ldots + w$ que para nuestra suerte tiene una fórmula cerrada que es $\sum_{i=1}^{w} = \frac{w(w+1)}{2}$.
-
-Si modificamos ligeramente el código tenemos:
-
-``` cpp
-#include <iostream>
-
-using namespace std;
-
-void main() {
-	long long k, w, n;
-	cin >> k >> n >> w;
-	long long total = k * (w *(w + 1)) / 2;
-	cout << (total > n ? total - n : 0 ) << endl;
-}
-```
+```

_posts/2015-07-04-limites-del-factorial.md

@@ -0,0 +1,14 @@
+---
+layout: post
+title:  "Limites de Factorial"
+categories: fácil matemática
+---
+
+## Problema
+
+En lenguajes de programación como C++ para manipular enteros se utilizan `int`s o `long long`s. Por razones de eficiencia estos tipos de datos no manipulan números arbitrariamente grandes. Si sabemos que los datos siempre van a ser positivos podemos agrandar nuestro rango positivo utilizando `unsigned int` o `unsigned long long`. 
+
+Calcular ¿cuál es el mayor número para el cual se puede calcular la función factorial utilizando `unsigned int`s?
+Calcular ¿cuál es el mayor número para el cual se puede calcular la función factorial utilizando `unsigned long long`s?
+
+¿Puedes explicar por qué?

_posts/2015-07-04-números-de-primos.md

@@ -0,0 +1,9 @@
+---
+layout: post
+title:  "Cantidad de Primos"
+categories: fácil matemática
+---
+
+## Problema
+
+Un número primo es un número natural mayor que $1$ que tiene únicamente dos divisores distintos: él mismo y el $1$. Juanito está intrigado por saber cuántos números primos hay, en particular él quiere saber cuántos número primos hay entre $1$ y $10^1, 10^2, \ldots , 10^8$ pero no sabe cómo hacerlo. Tu tarea consiste en ayudar a Juanito 

_posts/2015-07-04-palabras-de-cesar.md

@@ -0,0 +1,39 @@
+---
+layout: post
+title:  "Juego de palabras"
+categories: fácil matemática estructura-de-datos fuerza-bruta
+---
+
+## Problema
+
+A Cesar le gusta jugar con las palabras y, dada una palabra, quiere saber cuántas diferentes palabras se pueden generar si añadimos exactamente una letra del alfabeto internacional (todas las 26 letras entre la _a_ y la _z_, en este caso omitimos la _ñ_) en cualquier lugar de la palabra.
+
+Las palabras de Cesar generalmente carecen de sentido, así que si el está jugando con la palabra `"a"` se pueden formar las siguientes palabras: `"ab", "ac", ..., "az", "ba", "ca", ..., "za"`, y '"aa"', produciendo 51 palabras distintas.
+
+### Entrada
+
+La entrada es una palabra $s$ ($1 \leq |s| \leq 20$). La palabra $s$ es una cadena formada únicamente por caracteres minúsculos del alfabeto internacional.
+
+### Salida
+
+Número de palabras que podrían ser generadas.
+
+## Ejemplo
+#### Entrada
+```
+a
+```
+#### Salida
+```
+51
+```
+
+## Ejemplo
+#### Entrada
+```
+ja
+```
+#### Salida
+```
+76
+```

_posts/_soluciones/2015-06-08-comerciante-de-naranjas.md

@@ -0,0 +1,43 @@
+## Solución
+
+Lo primero que debemos observar es que el límite para el precio de una naranja es $1000$ soles (deben ser naranjas muy especiales), y si consideramos que el costo de la última naranja podría ser $10^{12}$ soles nos daremos cuenta de que ese es un número muy grande.
+En C++ los enteros (generalmente) son almacenados en un tipo de dato llamado integer de 4 bytes, eso quiere decir que tiene 32 bits (31 en realidad porque almacenamos el signo en un bit) para representar números, esto es cualquier número entre $2^{31}$ ($–2,147,483,648$) hasta $2^{31}-1$ ($2,147,483,647$), es decir approximadamente (2.1 veces) $10^9$.
+
+Como el costo total podría exceder esa cantidad no podemos utilizar integers para resolver el problema. Por suerte también existe otro tipo de dato que nos permite almacenar números enteros mayores y es el long long con 8 bytes, por lo tanto tiene 64 bits para representar números (63 quitando el bit del signo), esto es cualquier número entre $-2^{63}$ ($-9,223,372,036,854,775,808$) hasta $2^{63}-1$ ($9,223,372,036,854,775,807$).
+
+Entonces la solución más simple sería
+
+``` cpp
+#include <iostream>
+
+using namespace std;
+
+void main() {
+	int k, w, n;
+	cin >> k >> n >> w;
+	long long total = 0;
+	for (int i = 1; i <= w; ++i)
+		total += i*k;
+	if (total > n)
+		cout << total - n << endl;
+	else
+		cout << 0 << endl;
+}
+```
+
+Sin embargo, si recordamos nuestras clases de matemática podemos ver que $k$ siempre es una constante, entonces podríamos factorizarlo y luego nos quedamos con un sumatorio de la siguiente forma $1 + 2 + 3 + \ldots + w$ que para nuestra suerte tiene una fórmula cerrada que es $\sum_{i=1}^{w} = \frac{w(w+1)}{2}$.
+
+Si modificamos ligeramente el código tenemos:
+
+``` cpp
+#include <iostream>
+
+using namespace std;
+
+void main() {
+	long long k, w, n;
+	cin >> k >> n >> w;
+	long long total = k * (w *(w + 1)) / 2;
+	cout << (total > n ? total - n : 0 ) << endl;
+}
+```