docs: add rest of Spanish docs for project Euler
This commit is contained in:
Beau Carnes
@ -0,0 +1,74 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f36e1000cf542c50fe80
|
||||
challengeType: 5
|
||||
title: 'Problem 1: Multiples of 3 and 5'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si enumeramos todos los números naturales por debajo de 10 que son múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23.
|
||||
Halla la suma de todos los múltiplos de 3 o 5 debajo de <code>number</code> valor del parámetro proporcionado.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>multiplesOf3and5(1000)</code> debe devolver 233168.
|
||||
testString: 'assert.strictEqual(multiplesOf3and5(1000), 233168, "<code>multiplesOf3and5(1000)</code> should return 233168.");'
|
||||
- text: <code>multiplesOf3and5(49)</code> debe devolver 543.
|
||||
testString: 'assert.strictEqual(multiplesOf3and5(49), 543, "<code>multiplesOf3and5(49)</code> should return 543.");'
|
||||
- text: <code>multiplesOf3and5(19564)</code> debe devolver 89301183.
|
||||
testString: 'assert.strictEqual(multiplesOf3and5(19564), 89301183, "<code>multiplesOf3and5(19564)</code> should return 89301183.");'
|
||||
- text: Su función no está devolviendo el resultado correcto utilizando nuestros valores de prueba.
|
||||
testString: 'assert.strictEqual(multiplesOf3and5(8456), 16687353, "Your function is not returning the correct result using our tests values.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function multiplesOf3and5(number) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
multiplesOf3and5(1000);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
const multiplesOf3and5 = (number) => {
|
||||
var total = 0;
|
||||
|
||||
for(var i = 0; i < number; i++) {
|
||||
if(i % 3 == 0 || i % 5 == 0) {
|
||||
total += i;
|
||||
}
|
||||
}
|
||||
return total;
|
||||
};
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,99 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3761000cf542c50fe89
|
||||
challengeType: 5
|
||||
title: 'Problem 10: Summation of primes'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La suma de los números primos debajo de 10 es 2 + 3 + 5 + 7 = 17.
|
||||
Encuentra la suma de todos los números primos debajo de n.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>primeSummation(17)</code> debe devolver 41.
|
||||
testString: 'assert.strictEqual(primeSummation(17), 41, "<code>primeSummation(17)</code> should return 41.");'
|
||||
- text: <code>primeSummation(2001)</code> debe devolver 277050.
|
||||
testString: 'assert.strictEqual(primeSummation(2001), 277050, "<code>primeSummation(2001)</code> should return 277050.");'
|
||||
- text: <code>primeSummation(140759)</code> debe devolver 873608362.
|
||||
testString: 'assert.strictEqual(primeSummation(140759), 873608362, "<code>primeSummation(140759)</code> should return 873608362.");'
|
||||
- text: <code>primeSummation(2000000)</code> debe devolver 142913828922.
|
||||
testString: 'assert.strictEqual(primeSummation(2000000), 142913828922, "<code>primeSummation(2000000)</code> should return 142913828922.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function primeSummation(n) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
primeSummation(2000000);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
//noprotect
|
||||
function primeSummation(n) {
|
||||
// Initialise an array containing only prime numbers
|
||||
let primes = [2];
|
||||
let result = 2;
|
||||
|
||||
function isPrime(y, primes) {
|
||||
// Find sqrt(y)
|
||||
const sqrt = Math.floor(Math.sqrt(y));
|
||||
|
||||
// Divide y by each applicable prime, return false if any of them divide y
|
||||
for (let i = 0; i < primes.length && primes[i] <= sqrt; i++) {
|
||||
if (y % primes[i] === 0) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// At this point x must be prime
|
||||
return true;
|
||||
}
|
||||
|
||||
// For every odd integer, add it to the array if it is prime
|
||||
for (let x = 3; x < n; x += 2) {
|
||||
if (isPrime(x, primes)) {
|
||||
if (x > n) {
|
||||
return result;
|
||||
} else {
|
||||
result += x;
|
||||
primes.push(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d01000cf542c50fee3
|
||||
challengeType: 5
|
||||
title: 'Problem 100: Arranged probability'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si una caja contiene veintiún discos de colores, compuestos por quince discos azules y seis discos rojos, y se tomaron dos discos al azar, se puede ver que la probabilidad de tomar dos discos azules, P (BB) = (15 / 21) × (14/20) = 1/2.
|
||||
El siguiente acuerdo de este tipo, para el que hay exactamente un 50% de probabilidades de tomar dos discos azules al azar, es una caja que contiene ochenta y cinco discos azules y treinta y cinco discos rojos.
|
||||
Al encontrar el primer arreglo que contenga más de 1012 = 1,000,000,000,000 de discos en total, determine la cantidad de discos azules que contendría la caja.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler100()</code> debe devolver 756872327473.
|
||||
testString: 'assert.strictEqual(euler100(), 756872327473, "<code>euler100()</code> should return 756872327473.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler100() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler100();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d21000cf542c50fee4
|
||||
challengeType: 5
|
||||
title: 'Problem 101: Optimum polynomial'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si se nos presentan los primeros k términos de una secuencia, es imposible decir con certeza el valor del siguiente término, ya que hay infinitas funciones polinomiales que pueden modelar la secuencia.
|
||||
Como ejemplo, consideremos la secuencia de números de cubo. Esto se define por la función de generación, un = n3: 1, 8, 27, 64, 125, 216, ...
|
||||
Supongamos que solo se nos dieron los dos primeros términos de esta secuencia. Trabajando sobre el principio de que "simple es lo mejor", deberíamos asumir una relación lineal y predecir que el próximo término sea 15 (diferencia común 7). Incluso si se nos presentaran los primeros tres términos, por el mismo principio de simplicidad, se debería asumir una relación cuadrática.
|
||||
Definiremos OP (k, n) como el noveno término de la función de generación polinomial óptima para los primeros k términos de una secuencia. Debe quedar claro que OP (k, n) generará con precisión los términos de la secuencia para n ≤ k, y potencialmente el primer término incorrecto (FIT) será OP (k, k + 1); en cuyo caso lo llamaremos un mal OP (BOP).
|
||||
Como base, si solo nos dieran el primer término de secuencia, sería más sensato asumir la constancia; es decir, para n ≥ 2, OP (1, n) = u1.
|
||||
Por lo tanto se obtiene la siguiente OPs para la secuencia cúbico:
|
||||
|
||||
OP (1, n) = 1
|
||||
1, 1, 1, 1, ...
|
||||
OP (2, n) = 7n-6
|
||||
1, 8, 15, ...
|
||||
OP (3, n) = 6n2−11n + 6
|
||||
1, 8, 27, 58, ...
|
||||
OP (4, n) = n3
|
||||
1, 8, 27, 64, 125, ...
|
||||
|
||||
Es evidente que no existen BOP para k ≥ 4.
|
||||
Al considerar la suma de FIT generados por los BOP (indicados en rojo arriba), obtenemos 1 + 15 + 58 = 74.
|
||||
Considere la siguiente generación polinómica de décimo grado función:
|
||||
un = 1 - n + n2 - n3 + n4 - n5 + n6 - n7 + n8 - n9 + n10
|
||||
Encuentre la suma de FIT para los BOP.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler101()</code> debe devolver 37076114526.
|
||||
testString: 'assert.strictEqual(euler101(), 37076114526, "<code>euler101()</code> should return 37076114526.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler101() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler101();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d21000cf542c50fee5
|
||||
challengeType: 5
|
||||
title: 'Problem 102: Triangle containment'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tres puntos distintos se trazan al azar en un plano cartesiano, para el cual -1000 ≤ x, y ≤ 1000, de manera que se forma un triángulo.
|
||||
Considere los siguientes dos triángulos:
|
||||
A (-340,495), B (-153, -910), C (835, -947)
|
||||
X (-175,41), Y (-421, -714), Z ( 574, -645)
|
||||
Puede verificarse que el triángulo ABC contiene el origen, mientras que el triángulo XYZ no.
|
||||
Utilizando triangles.txt (clic con el botón derecho y 'Guardar enlace / Objetivo como ...'), un archivo de texto de 27K que contiene las coordenadas de mil triángulos "aleatorios", encuentre el número de triángulos para los cuales el interior contiene el origen .
|
||||
NOTA: Los dos primeros ejemplos en el archivo representan los triángulos en el ejemplo dado arriba.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler102()</code> debe devolver 228.
|
||||
testString: 'assert.strictEqual(euler102(), 228, "<code>euler102()</code> should return 228.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler102() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler102();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d61000cf542c50fee7
|
||||
challengeType: 5
|
||||
title: 'Problem 103: Special subset sums: optimum'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea S (A) la suma de elementos en el conjunto A de tamaño n. Lo llamaremos conjunto de suma especial si para dos subconjuntos disjuntos no vacíos, B y C, las siguientes propiedades son verdaderas:
|
||||
S (B) ≠ S (C); es decir, las sumas de subconjuntos no pueden ser iguales.
|
||||
Si B contiene más elementos que C, entonces S (B)> S (C).
|
||||
Si S (A) se minimiza para un n dado, lo llamaremos un conjunto de suma especial óptimo. Los primeros cinco conjuntos de suma especial óptimos se dan a continuación.
|
||||
n = 1: {1} n = 2: {1, 2} n = 3: {2, 3, 4} n = 4: {3, 5, 6, 7} n = 5: {6, 9, 11, 12, 13}
|
||||
Parece que para un conjunto óptimo dado, A = {a1, a2, ..., an}, el siguiente conjunto óptimo tiene la forma B = {b, a1 + b, a2 + b , ..., an + b}, donde b es el elemento "medio" en la fila anterior.
|
||||
Al aplicar esta "regla" esperaríamos que el conjunto óptimo para n = 6 sea A = {11, 17, 20, 22, 23, 24}, con S (A) = 117. Sin embargo, esto no es el óptimo conjunto, ya que simplemente hemos aplicado un algoritmo para proporcionar un conjunto casi óptimo. El conjunto óptimo para n = 6 es A = {11, 18, 19, 20, 22, 25}, con S (A) = 115 y la cadena del conjunto correspondiente: 111819202225.
|
||||
Dado que A es una suma especial óptima establecida para n = 7, encuentra su cadena de conjunto.
|
||||
NOTA: Este problema está relacionado con el Problema 105 y el Problema 106.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler103()</code> debe devolver 20313839404245.
|
||||
testString: 'assert.strictEqual(euler103(), 20313839404245, "<code>euler103()</code> should return 20313839404245.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler103() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler103();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d51000cf542c50fee6
|
||||
challengeType: 5
|
||||
title: 'Problem 104: Pandigital Fibonacci ends'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La secuencia de Fibonacci se define por la relación de recurrencia:
|
||||
Fn = Fn − 1 + Fn − 2, donde F1 = 1 y F2 = 1.
|
||||
Resulta que F541, que contiene 113 dígitos, es el primer número de Fibonacci para el cual los últimos nueve dígitos son 1-9 pandigital (contienen todos los dígitos del 1 al 9, pero no necesariamente en orden). Y F2749, que contiene 575 dígitos, es el primer número de Fibonacci para el cual los primeros nueve dígitos son 1-9 pandigital.
|
||||
Dado que Fk es el primer número de Fibonacci para el cual los primeros nueve dígitos Y los últimos nueve dígitos son 1-9 pandigital, encuentre k.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler104()</code> debe devolver 329468.
|
||||
testString: 'assert.strictEqual(euler104(), 329468, "<code>euler104()</code> should return 329468.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler104() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler104();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d61000cf542c50fee8
|
||||
challengeType: 5
|
||||
title: 'Problem 105: Special subset sums: testing'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea S (A) la suma de elementos en el conjunto A de tamaño n. Lo llamaremos conjunto de suma especial si para dos subconjuntos disjuntos no vacíos, B y C, las siguientes propiedades son verdaderas:
|
||||
S (B) ≠ S (C); es decir, las sumas de subconjuntos no pueden ser iguales.
|
||||
Si B contiene más elementos que C, entonces S (B)> S (C).
|
||||
Por ejemplo, {81, 88, 75, 42, 87, 84, 86, 65} no es un conjunto de suma especial porque 65 + 87 + 88 = 75 + 81 + 84, mientras que {157, 150, 164, 119, 79, 159, 161, 139, 158} satisface ambas reglas para todas las combinaciones posibles de pares de subconjuntos y S (A) = 1286.
|
||||
Utilizando sets.txt (clic derecho y "Guardar enlace / Destinar como ..."), un 4K archivo de texto con cien conjuntos que contienen de siete a doce elementos (los dos ejemplos dados más arriba son los dos primeros conjuntos del archivo), identifique todos los conjuntos de suma especial, A1, A2, ..., Ak, y encuentre el valor de S (A1) + S (A2) + ... + S (Ak).
|
||||
NOTA: Este problema está relacionado con el Problema 103 y el Problema 106.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler105()</code> debe devolver 73702.
|
||||
testString: 'assert.strictEqual(euler105(), 73702, "<code>euler105()</code> should return 73702.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler105() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler105();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d71000cf542c50fee9
|
||||
challengeType: 5
|
||||
title: 'Problem 106: Special subset sums: meta-testing'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea S (A) la suma de elementos en el conjunto A de tamaño n. Lo llamaremos conjunto de suma especial si para dos subconjuntos disjuntos no vacíos, B y C, las siguientes propiedades son verdaderas:
|
||||
S (B) ≠ S (C); es decir, las sumas de subconjuntos no pueden ser iguales.
|
||||
Si B contiene más elementos que C, entonces S (B)> S (C).
|
||||
Para este problema, supondremos que un conjunto dado contiene n elementos estrictamente crecientes y ya cumple la segunda regla.
|
||||
Sorprendentemente, de los 25 pares de subconjuntos posibles que se pueden obtener de un conjunto para el cual n = 4, solo uno de estos pares debe probarse para determinar la igualdad (primera regla). De manera similar, cuando n = 7, solo se deben probar 70 de los 966 pares de subconjuntos.
|
||||
Para n = 12, ¿cuántos de los 261625 pares de subconjuntos que se pueden obtener deben probarse para determinar la igualdad?
|
||||
NOTA: Este problema está relacionado con el Problema 103 y el Problema 105.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler106()</code> debe devolver 21384.
|
||||
testString: 'assert.strictEqual(euler106(), 21384, "<code>euler106()</code> should return 21384.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler106() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler106();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,71 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d91000cf542c50feea
|
||||
challengeType: 5
|
||||
title: 'Problem 107: Minimal network'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La siguiente red no dirigida consta de siete vértices y doce aristas con un peso total de 243.
|
||||
|
||||
|
||||
La misma red puede representarse mediante la siguiente matriz.
|
||||
ABCDEFG
|
||||
A-161221 ---
|
||||
B16--1720--
|
||||
C12--28-31-
|
||||
D211728-181923
|
||||
E-20-18--11
|
||||
F - 3119--27
|
||||
G --- 231127-
|
||||
Sin embargo, es posible optimizar la red eliminando algunos bordes y aun así asegurar que todos los puntos de la red permanezcan conectados. La red que logra el máximo ahorro se muestra a continuación. Tiene un peso de 93, lo que representa un ahorro de 243 - 93 = 150 de la red original.
|
||||
|
||||
|
||||
Utilizando network.txt (haga clic con el botón derecho y 'Guardar enlace / destino como ...'), un archivo de texto de 6K que contiene una red con cuarenta vértices, y dado en forma matricial, encuentre el ahorro máximo que se puede lograr eliminando Bordes redundantes al tiempo que se asegura de que la red permanezca conectada.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler107()</code> debe devolver 259679.
|
||||
testString: 'assert.strictEqual(euler107(), 259679, "<code>euler107()</code> should return 259679.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler107() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler107();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3d91000cf542c50feeb
|
||||
challengeType: 5
|
||||
title: 'Problem 108: Diophantine Reciprocals I'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En la siguiente ecuación x, y yn son enteros positivos.
|
||||
1 / <var>x</var> + 1 / <var>y</var> = 1 / <var>n</var>
|
||||
Para <var>n</var> = 4 hay exactamente tres soluciones distintas:
|
||||
1/5 + 1/20 = 1/4 <br /> 1/6 + 1/12 = 1/4 <br /> 1/8 + 1/8 = 1/4
|
||||
¿Cuál es el valor mínimo de <var>n</var> para el cual el número de soluciones distintas excede mil?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>diophantineOne()</code> debe devolver 180180.
|
||||
testString: 'assert.strictEqual(diophantineOne(), 180180, "<code>diophantineOne()</code> should return 180180.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function diophantineOne() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
diophantineOne();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,102 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3db1000cf542c50feec
|
||||
challengeType: 5
|
||||
title: 'Problem 109: Darts'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En el juego de dardos, un jugador lanza tres dardos en un tablero objetivo que está dividido en veinte secciones del mismo tamaño numeradas del uno al veinte.
|
||||
|
||||
|
||||
La puntuación de un dardo está determinada por el número de la región en la que cae el dardo. Un dardo que cae fuera del anillo exterior rojo / verde tiene una puntuación de cero. Las regiones negras y cremas dentro de este anillo representan puntuaciones individuales. Sin embargo, el anillo exterior rojo / verde y el anillo medio obtienen puntuaciones dobles y triples respectivamente.
|
||||
En el centro del tablero hay dos círculos concéntricos llamados la región del toro u ojo de buey. El toro exterior vale 25 puntos y el toro interior es doble, vale 50 puntos.
|
||||
Hay muchas variaciones en las reglas, pero en el juego más popular, los jugadores comenzarán con una puntuación de 301 o 501 y el primer jugador que reduzca su total de carreras a cero será el ganador. Sin embargo, es normal jugar un sistema de "dobles", lo que significa que el jugador debe obtener un doble (incluida la doble diana en el centro del tablero) en su dardo final para ganar; cualquier otro dardo que reduzca su total acumulado a uno o más bajo significa que el puntaje para ese conjunto de tres dardos es "busto".
|
||||
Cuando un jugador puede terminar con su puntaje actual, se le llama "checkout" y el checkout más alto es 170: T20 T20 D25 (dos agudos, 20 y doble toro).
|
||||
Hay exactamente once formas distintas de pago y envío en una puntuación de 6:
|
||||
|
||||
D3
|
||||
|
||||
|
||||
D1
|
||||
D2
|
||||
|
||||
S2
|
||||
D2
|
||||
|
||||
D2
|
||||
D1
|
||||
|
||||
S4
|
||||
D1
|
||||
|
||||
S1
|
||||
S1
|
||||
D2
|
||||
S1
|
||||
T1
|
||||
D1
|
||||
S1
|
||||
S3
|
||||
D1
|
||||
D1
|
||||
D1
|
||||
D1
|
||||
D1
|
||||
S2
|
||||
D1
|
||||
S2
|
||||
S2
|
||||
D1
|
||||
|
||||
Tenga en cuenta que D1 D2 se considera diferente a D2 D1 cuando terminan en diferentes dobles. Sin embargo, la combinación S1 T1 D1 se considera la misma que T1 S1 D1.
|
||||
Además, no incluiremos fallos al considerar combinaciones; por ejemplo, D3 es lo mismo que 0 D3 y 0 0 D3.
|
||||
Increíblemente, hay 42336 maneras distintas de verificar en total.
|
||||
¿De cuántas maneras distintas puede un jugador pagar con un puntaje menor a 100?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler109()</code> debe devolver 38182.
|
||||
testString: 'assert.strictEqual(euler109(), 38182, "<code>euler109()</code> should return 38182.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler109() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler109();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,189 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3781000cf542c50fe8a
|
||||
challengeType: 5
|
||||
title: 'Problem 11: Largest product in a grid'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En la siguiente cuadrícula de 20 × 20, cuatro números a lo largo de una línea diagonal se han marcado en rojo.
|
||||
|
||||
<div style='text-align: center;'> 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 </div>
|
||||
<div style='text-align: center;'> 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 </div>
|
||||
<div style='text-align: center;'> 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 </div>
|
||||
<div style='text-align: center;'> 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 </div>
|
||||
<div style='text-align: center;'> 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 </div>
|
||||
<div style='text-align: center;'> 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 </div>
|
||||
<div style='text-align: center;'> 32 98 81 28 64 23 67 10 <span style='color: red'><b>26</b></span> 38 40 67 59 54 70 66 18 38 64 70 </div>
|
||||
<div style='text-align: center;'> 67 26 20 68 02 62 12 20 95 <span style='color: red'><b>63</b></span> 94 39 63 08 40 91 66 49 94 21 </div>
|
||||
<div style='text-align: center;'> 24 55 58 05 66 73 99 26 97 17 <span style='color: red'><b>78</b></span> 78 96 83 14 88 34 89 63 72 </div>
|
||||
<div style='text-align: center;'> 21 36 23 09 75 00 76 44 20 45 35 <span style='color: red'><b>14</b></span> 00 61 33 97 34 31 33 95 </div>
|
||||
<div style='text-align: center;'> 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 </div>
|
||||
<div style='text-align: center;'> 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 </div>
|
||||
<div style='text-align: center;'> 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 </div>
|
||||
<div style='text-align: center;'> 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 </div>
|
||||
<div style='text-align: center;'> 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 </div>
|
||||
<div style='text-align: center;'> 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 </div>
|
||||
<div style='text-align: center;'> 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 </div>
|
||||
<div style='text-align: center;'> 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 </div>
|
||||
<div style='text-align: center;'> 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 </div>
|
||||
<div style='text-align: center;'> 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 </div>
|
||||
|
||||
El producto de estos números es 26 × 63 × 78 × 14 = 1788696.
|
||||
¿Cuál es el mayor producto de cuatro números adyacentes en la misma dirección (arriba, abajo, izquierda, derecha o diagonal) en una cuadrícula de <code>arr</code> dada?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>largestGridProduct(grid)</code> debe devolver 70600674.
|
||||
testString: 'assert.strictEqual(largestGridProduct(grid), 70600674, "<code>largestGridProduct(grid)</code> should return 70600674.");'
|
||||
- text: <code>largestGridProduct(testGrid)</code> debe devolver 14169081.
|
||||
testString: 'assert.strictEqual(largestGridProduct(testGrid), 14169081, "<code>largestGridProduct(testGrid)</code> should return 14169081.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function largestGridProduct(arr) {
|
||||
// Good luck!
|
||||
return arr;
|
||||
}
|
||||
|
||||
// Only change code above this line
|
||||
const grid = [
|
||||
[8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
|
||||
[49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
|
||||
[81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
|
||||
[52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
|
||||
[22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
|
||||
[24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
|
||||
[32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
|
||||
[67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
|
||||
[24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
|
||||
[21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
|
||||
[78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
|
||||
[16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
|
||||
[86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
|
||||
[19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
|
||||
[4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
|
||||
[88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
|
||||
[4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
|
||||
[20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
|
||||
[20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
|
||||
[1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
|
||||
];
|
||||
|
||||
const testGrid = [
|
||||
[40, 17, 81, 18, 57],
|
||||
[74, 4, 36, 16, 29],
|
||||
[36, 42, 69, 73, 45],
|
||||
[51, 54, 69, 16, 92],
|
||||
[7, 97, 57, 32, 16]
|
||||
];
|
||||
|
||||
largestGridProduct(testGrid);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function largestGridProduct(arr) {
|
||||
let maxProduct = 0;
|
||||
let currProduct = 0;
|
||||
|
||||
function maxProductChecker(n) {
|
||||
if (n > maxProduct) {
|
||||
return maxProduct = n;
|
||||
}
|
||||
}
|
||||
|
||||
// loop rows
|
||||
for (let r = 0; r < arr.length; r++) {
|
||||
// loop columns
|
||||
for (let c = 0; c < arr[r].length; c++) {
|
||||
const limit = arr[r].length - 3;
|
||||
|
||||
// check horizontal
|
||||
if (c < limit) {
|
||||
currProduct = arr[r][c] * arr[r][c + 1] * arr[r][c + 2] * arr[r][c + 3];
|
||||
maxProductChecker(currProduct);
|
||||
}
|
||||
|
||||
// check vertical
|
||||
if (r < limit) {
|
||||
currProduct = arr[r][c] * arr[r + 1][c] * arr[r + 2][c] * arr[r + 3][c];
|
||||
maxProductChecker(currProduct);
|
||||
}
|
||||
|
||||
// check diagonal [\]
|
||||
if (c < limit && r < limit) {
|
||||
currProduct = arr[r][c] * arr[r + 1][c + 1] * arr[r + 2][c + 2] * arr[r + 3][c + 3];
|
||||
maxProductChecker(currProduct);
|
||||
}
|
||||
|
||||
// check diagonal [/]
|
||||
if (c > 3 && r < limit) {
|
||||
currProduct = arr[r][c] * arr[r + 1][c - 1] * arr[r + 2][c - 2] * arr[r + 3][c - 3];
|
||||
maxProductChecker(currProduct);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return maxProduct;
|
||||
}
|
||||
|
||||
const grid = [ [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
|
||||
[49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
|
||||
[81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
|
||||
[52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
|
||||
[22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
|
||||
[24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
|
||||
[32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
|
||||
[67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
|
||||
[24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
|
||||
[21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
|
||||
[78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
|
||||
[16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
|
||||
[86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
|
||||
[19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
|
||||
[4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
|
||||
[88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
|
||||
[4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
|
||||
[20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
|
||||
[20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
|
||||
[1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
|
||||
];
|
||||
|
||||
const testGrid = [
|
||||
[40, 17, 81, 18, 57],
|
||||
[74, 4, 36, 16, 29],
|
||||
[36, 42, 69, 73, 45],
|
||||
[51, 54, 69, 16, 92],
|
||||
[7, 97, 57, 32, 16]
|
||||
];
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3db1000cf542c50feed
|
||||
challengeType: 5
|
||||
title: 'Problem 110: Diophantine Reciprocals II'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En la siguiente ecuación x, y yn son enteros positivos.
|
||||
1 / <var>x</var> + 1 / <var>y</var> = 1 / <var>n</var>
|
||||
Se puede verificar que cuando <var>n</var> = 1260 hay 113 soluciones distintas y este es el valor mínimo de <var>n</var> para el cual el número total de soluciones distintas supera las cien.
|
||||
¿Cuál es el valor mínimo de <var>n</var> para el cual el número de soluciones distintas supera los cuatro millones?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>diophantineTwo</code> debe devolver 9350130049860600.
|
||||
testString: 'assert.strictEqual(diophantineTwo(), 9350130049860600, "<code>diophantineTwo()</code> should return 9350130049860600.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function diophantineTwo() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
diophantineTwo();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,108 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3db1000cf542c50feee
|
||||
challengeType: 5
|
||||
title: 'Problem 111: Primes with runs'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considerando los números primos de 4 dígitos que contienen dígitos repetidos, está claro que no pueden ser todos iguales: 1111 es divisible por 11, 2222 es divisible por 22, y así sucesivamente. Pero hay nueve números primos de 4 dígitos que contienen tres:
|
||||
1117, 1151, 1171, 1181, 1511, 1811, 2111, 4111, 8111
|
||||
Diremos que M (n, d) representa el número máximo de dígitos repetidos para un primo de n dígitos donde d es el dígito repetido, N (n, d) representa el número de dichos primos y S (n, d) representa la suma de estos primos.
|
||||
Entonces, M (4, 1) = 3 es el número máximo de dígitos repetidos para un primo de 4 dígitos donde uno es el dígito repetido, hay N (4, 1) = 9 primos de este tipo, y la suma de estos primos es S (4, 1) = 22275. Resulta que para d = 0, solo es posible tener M (4, 0) = 2 dígitos repetidos, pero hay N (4, 0) = 13 de estos casos.
|
||||
De la misma manera obtenemos los siguientes resultados para números primos de 4 dígitos.
|
||||
|
||||
Dígitos, d
|
||||
M (4, d)
|
||||
N (4, d)
|
||||
S (4, d)
|
||||
0
|
||||
2
|
||||
13
|
||||
67061
|
||||
1
|
||||
3
|
||||
9
|
||||
22275
|
||||
2
|
||||
3
|
||||
1
|
||||
2221
|
||||
3
|
||||
3
|
||||
12
|
||||
46214
|
||||
4
|
||||
3
|
||||
2
|
||||
8888
|
||||
5
|
||||
3
|
||||
1
|
||||
5557
|
||||
6
|
||||
3
|
||||
1
|
||||
6661
|
||||
7
|
||||
3
|
||||
9
|
||||
57863
|
||||
8
|
||||
3
|
||||
1
|
||||
8887
|
||||
9
|
||||
3
|
||||
7
|
||||
48073
|
||||
|
||||
Para d = 0 a 9, la suma de todos los S (4, d) es 273700.
|
||||
Halla la suma de todos los S (10, d).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler111()</code> debe devolver 612407567715.
|
||||
testString: 'assert.strictEqual(euler111(), 612407567715, "<code>euler111()</code> should return 612407567715.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler111() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler111();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3dd1000cf542c50feef
|
||||
challengeType: 5
|
||||
title: 'Problem 112: Bouncy numbers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Trabajando de izquierda a derecha, si no se supera un dígito por el dígito a su izquierda, se llama un número creciente; por ejemplo, 134468.
|
||||
De manera similar, si un dígito a su derecha no supera un dígito, se le llama número decreciente; por ejemplo, 66420.
|
||||
Llamaremos un entero positivo que no está aumentando ni disminuyendo un número "abultado"; por ejemplo, 155349.
|
||||
Claramente, no puede haber números inflables por debajo de cien, pero solo la mitad de los números por debajo de mil (525) son inflables. De hecho, el menor número para el cual la proporción de números inflables alcanza por primera vez el 50% es 538.
|
||||
Sorprendentemente, los números inflables se vuelven cada vez más comunes y, cuando llegamos a 21780, la proporción de números inflables es igual al 90%.
|
||||
Encuentre el número mínimo para el cual la proporción de números inflables es exactamente el 99%.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler112()</code> debe devolver 1587000.
|
||||
testString: 'assert.strictEqual(euler112(), 1587000, "<code>euler112()</code> should return 1587000.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler112() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler112();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3dd1000cf542c50fef0
|
||||
challengeType: 5
|
||||
title: 'Problem 113: Non-bouncy numbers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Trabajando de izquierda a derecha, si no se supera un dígito por el dígito a su izquierda, se llama un número creciente; por ejemplo, 134468.
|
||||
De manera similar, si un dígito a su derecha no supera un dígito, se le llama número decreciente; por ejemplo, 66420.
|
||||
Llamaremos a un entero positivo que no está aumentando ni disminuyendo un número "abultado"; por ejemplo, 155349.
|
||||
A medida que n aumenta, la proporción de números bouncy debajo de n aumenta, de modo que solo hay 12951 números por debajo de un millón que no son bouncy y solo 277032 números no bouncy por debajo de 1010.
|
||||
Cuántos números debajo de un googol (10100) no son inflables?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler113()</code> debe devolver 51161058134250.
|
||||
testString: 'assert.strictEqual(euler113(), 51161058134250, "<code>euler113()</code> should return 51161058134250.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler113() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler113();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,163 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e01000cf542c50fef2
|
||||
challengeType: 5
|
||||
title: 'Problem 114: Counting block combinations I'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una fila que mide siete unidades de longitud tiene bloques rojos con una longitud mínima de tres unidades colocadas en ella, de manera que dos bloques rojos (que pueden tener longitudes diferentes) están separados por al menos un cuadrado negro. Hay exactamente diecisiete maneras de hacer esto.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
¿De cuántas maneras se puede llenar una fila que mide cincuenta unidades de longitud?
|
||||
NOTA: Aunque el ejemplo anterior no se presta a la posibilidad, en general se permite mezclar tamaños de bloque. Por ejemplo, en una fila que mide ocho unidades de longitud, puede usar rojo (3), negro (1) y rojo (4).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler114()</code> debe devolver 16475640049.
|
||||
testString: 'assert.strictEqual(euler114(), 16475640049, "<code>euler114()</code> should return 16475640049.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler114() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler114();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3df1000cf542c50fef1
|
||||
challengeType: 5
|
||||
title: 'Problem 115: Counting block combinations II'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
NOTA: Esta es una versión más difícil del Problema 114.
|
||||
Una fila que mide n unidades de longitud tiene bloques rojos con una longitud mínima de m unidades colocadas en ella, de manera que dos bloques rojos (que pueden tener longitudes diferentes) Están separados por al menos un cuadrado negro.
|
||||
Deje que la función de conteo de relleno, F (m, n), represente el número de formas en que se puede llenar una fila.
|
||||
Por ejemplo, F (3, 29) = 673135 y F (3, 30) = 1089155.
|
||||
Es decir, para m = 3, se puede ver que n = 30 es el valor más pequeño para el cual la función de conteo de relleno Primero supera el millón.
|
||||
De la misma manera, para m = 10, se puede verificar que F (10, 56) = 880711 y F (10, 57) = 1148904, por lo que n = 57 es el valor mínimo para el cual la función de conteo de relleno primero Supera el millón.
|
||||
Para m = 50, encuentre el valor mínimo de n para el cual la función de recuento de relleno excede primero un millón.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler115()</code> debe devolver 168.
|
||||
testString: 'assert.strictEqual(euler115(), 168, "<code>euler115()</code> should return 168.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler115() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler115();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,131 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e01000cf542c50fef3
|
||||
challengeType: 5
|
||||
title: 'Problem 116: Red, green or blue tiles'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una fila de cinco azulejos cuadrados negros debe tener un número de sus azulejos reemplazados por azulejos oblongos de colores elegidos entre rojo (longitud dos), verde (longitud tres) o azul (longitud cuatro).
|
||||
Si se eligen azulejos rojos, hay exactamente siete formas en que esto se puede hacer.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Si se eligen azulejos verdes, hay tres formas.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Y si se eligen azulejos azules, hay dos formas.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Suponiendo que los colores no se pueden mezclar, hay 7 + 3 + 2 = 12 formas de reemplazar los azulejos negros en una fila que mide cinco unidades de longitud.
|
||||
¿De cuántas maneras diferentes se pueden reemplazar los azulejos negros en una fila de cincuenta unidades de longitud si no se pueden mezclar los colores y se debe usar al menos un azulejo de color?
|
||||
NOTA: Esto está relacionado con el Problema 117.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler116()</code> debe devolver 20492570929.
|
||||
testString: 'assert.strictEqual(euler116(), 20492570929, "<code>euler116()</code> should return 20492570929.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler116() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler116();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,141 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e21000cf542c50fef4
|
||||
challengeType: 5
|
||||
title: 'Problem 117: Red, green, and blue tiles'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Usando una combinación de azulejos cuadrados negros y azulejos oblongos elegidos entre: azulejos rojos que miden dos unidades, azulejos verdes que miden tres unidades, y azulejos azules que miden cuatro unidades, es posible alinear una fila de cinco unidades de longitud en exactamente quince formas diferentes .
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
¿De cuántas maneras se puede formar una fila de cincuenta unidades de longitud?
|
||||
NOTA: Esto está relacionado con el Problema 116.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler117()</code> debe devolver 100808458960497.
|
||||
testString: 'assert.strictEqual(euler117(), 100808458960497, "<code>euler117()</code> should return 100808458960497.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler117() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler117();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,57 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e21000cf542c50fef5
|
||||
challengeType: 5
|
||||
title: 'Problem 118: Pandigital prime sets'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Usando todos los dígitos del 1 al 9 y concatenándolos libremente para formar enteros decimales, se pueden formar diferentes conjuntos. Es interesante que con el conjunto {2,5,47,89,631}, todos los elementos que pertenecen a él son primos.
|
||||
¿Cuántos conjuntos distintos que contienen cada uno de los dígitos del uno al nueve exactamente una vez contienen solo elementos primos?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler118()</code> debe devolver 44680.
|
||||
testString: 'assert.strictEqual(euler118(), 44680, "<code>euler118()</code> should return 44680.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler118() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler118();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,106 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3781000cf542c50fe8b
|
||||
challengeType: 5
|
||||
title: 'Problem 12: Highly divisible triangular number'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La secuencia de los números de triángulos se genera al sumar los números naturales. Entonces, el número del séptimo triángulo sería 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. Los primeros diez términos serían:
|
||||
<div style='text-align: center;'> 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ... </div>
|
||||
Listemos los factores de los primeros siete números de triángulos:
|
||||
<div style='padding-left: 4em;'> <b>1:</b> 1 </div>
|
||||
<div style='padding-left: 4em;'> <b>3:</b> 1, 3 </div>
|
||||
<div style='padding-left: 4em;'> <b>6:</b> 1, 2, 3, 6 </div>
|
||||
<div style='padding-left: 4em;'> <b>10:</b> 1, 2, 5, 10 </div>
|
||||
<div style='padding-left: 4em;'> <b>15:</b> 1, 3, 5, 15 </div>
|
||||
<div style='padding-left: 4em;'> <b>21:</b> 1, 3, 7, 21 </div>
|
||||
<div style='padding-left: 4em;'> <b>28:</b> 1, 2, 4, 7, 14, 28 </div>
|
||||
Podemos ver que 28 es el primer número de triángulo que tiene más de cinco divisores.
|
||||
¿Cuál es el valor del primer número de triángulo que tiene más de <code>n</code> divisores?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>divisibleTriangleNumber(5)</code> debe devolver 28.
|
||||
testString: 'assert.strictEqual(divisibleTriangleNumber(5), 28, "<code>divisibleTriangleNumber(5)</code> should return 28.");'
|
||||
- text: <code>divisibleTriangleNumber(23)</code> debe devolver 630.
|
||||
testString: 'assert.strictEqual(divisibleTriangleNumber(23), 630, "<code>divisibleTriangleNumber(23)</code> should return 630.");'
|
||||
- text: <code>divisibleTriangleNumber(167)</code> debe devolver 1385280.
|
||||
testString: 'assert.strictEqual(divisibleTriangleNumber(167), 1385280, "<code>divisibleTriangleNumber(167)</code> should return 1385280.");'
|
||||
- text: <code>divisibleTriangleNumber(374)</code> debe devolver 17907120.
|
||||
testString: 'assert.strictEqual(divisibleTriangleNumber(374), 17907120, "<code>divisibleTriangleNumber(374)</code> should return 17907120.");'
|
||||
- text: <code>divisibleTriangleNumber(500)</code> debe devolver 76576500.
|
||||
testString: 'assert.strictEqual(divisibleTriangleNumber(500), 76576500, "<code>divisibleTriangleNumber(500)</code> should return 76576500.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function divisibleTriangleNumber(n) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
divisibleTriangleNumber(500);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function divisibleTriangleNumber(n) {
|
||||
let counter = 1;
|
||||
let triangleNumber = counter++;
|
||||
|
||||
function getFactors(num) {
|
||||
let factors = [];
|
||||
|
||||
let possibleFactor = 1;
|
||||
let sqrt = Math.sqrt(num);
|
||||
|
||||
while (possibleFactor <= sqrt) {
|
||||
if (num % possibleFactor == 0) {
|
||||
factors.push(possibleFactor);
|
||||
var otherPossibleFactor = num / possibleFactor;
|
||||
if (otherPossibleFactor > possibleFactor) {
|
||||
factors.push(otherPossibleFactor);
|
||||
}
|
||||
}
|
||||
possibleFactor++;
|
||||
}
|
||||
|
||||
return factors;
|
||||
}
|
||||
|
||||
while (getFactors(triangleNumber).length < n) {
|
||||
triangleNumber += counter++;
|
||||
}
|
||||
console.log(triangleNumber)
|
||||
return triangleNumber;
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e41000cf542c50fef7
|
||||
challengeType: 5
|
||||
title: 'Problem 120: Square remainders'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea r el resto cuando (a − 1) n + (a + 1) n esté dividido por a2.
|
||||
Por ejemplo, si a = 7 y n = 3, entonces r = 42: 63 + 83 = 728 ≡ 42 mod 49. Y como n varía, también lo hará r, pero para a = 7 resulta que rmax = 42 .
|
||||
Para 3 ≤ a ≤ 1000, encuentre ∑ rmax.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler120()</code> debe devolver 333082500.
|
||||
testString: 'assert.strictEqual(euler120(), 333082500, "<code>euler120()</code> should return 333082500.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler120() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler120();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e51000cf542c50fef8
|
||||
challengeType: 5
|
||||
title: 'Problem 121: Disc game prize fund'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una bolsa contiene un disco rojo y un disco azul. En un juego de azar, un jugador toma un disco al azar y se nota su color. Después de cada vuelta, el disco vuelve a la bolsa, se agrega un disco rojo adicional y se toma otro disco al azar.
|
||||
El jugador paga £ 1 para jugar y gana si ha tomado más discos azules que discos rojos al final del juego.
|
||||
Si el juego se juega durante cuatro turnos, la probabilidad de que un jugador gane es exactamente el 11/120, por lo que el fondo de premios máximo que el banquero debe asignar para ganar en este juego sería de £ 10 antes de que esperen incurrir en una pérdida. Tenga en cuenta que cualquier pago será una cantidad total de libras y también incluye el £ 1 original pagado para jugar el juego, por lo que en el ejemplo dado, el jugador en realidad gana £ 9.
|
||||
Encuentre el fondo máximo de premios que se debe asignar a un solo juego en el que se juegan quince turnos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler121()</code> debe devolver 2269.
|
||||
testString: 'assert.strictEqual(euler121(), 2269, "<code>euler121()</code> should return 2269.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler121() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler121();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e61000cf542c50fef9
|
||||
challengeType: 5
|
||||
title: 'Problem 122: Efficient exponentiation'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La forma más ingenua de calcular n15 requiere catorce multiplicaciones:
|
||||
n × n × ... × n = n15
|
||||
Pero utilizando un método "binario" puedes calcularlo en seis multiplicaciones:
|
||||
n × n = n2n2 × n2 = n4n4 × n4 = n8n8 × n4 = n12n12 × n2 = n14n14 × n = n15
|
||||
Sin embargo, todavía es posible calcularlo en solo cinco multiplicaciones:
|
||||
n × n = n2n2 × n = n3n3 × n3 = n6n6 × n6 = n12n12 × n3 = n15
|
||||
Definiremos m (k) como el número mínimo de multiplicaciones para calcular nk; por ejemplo m (15) = 5.
|
||||
Para 1 ≤ k ≤ 200, encuentre ∑ m (k).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler122()</code> debe devolver 1582.
|
||||
testString: 'assert.strictEqual(euler122(), 1582, "<code>euler122()</code> should return 1582.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler122() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler122();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e71000cf542c50fefa
|
||||
challengeType: 5
|
||||
title: 'Problem 123: Prime square remainders'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea pn el primer primo: 2, 3, 5, 7, 11, ..., y sea r el resto cuando (pn − 1) n + (pn + 1) n esté dividido por pn2.
|
||||
Por ejemplo, cuando n = 3, p3 = 5, y 43 + 63 = 280 ≡ 5 mod 25.
|
||||
El valor mínimo de n para el cual el resto primero excede 109 es 7037.
|
||||
Encuentre el valor mínimo de n para el cual el resto primero excede 1010.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler123()</code> debe devolver 21035.
|
||||
testString: 'assert.strictEqual(euler123(), 21035, "<code>euler123()</code> should return 21035.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler123() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler123();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,98 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e81000cf542c50fefb
|
||||
challengeType: 5
|
||||
title: 'Problem 124: Ordered radicals'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El radical de n, rad (n), es el producto de los distintos factores primos de n. Por ejemplo, 504 = 23 × 32 × 7, entonces rad (504) = 2 × 3 × 7 = 42.
|
||||
Si calculamos rad (n) para 1 ≤ n ≤ 10, luego los clasificamos en rad (n), y clasificando en n si los valores radicales son iguales, obtenemos:
|
||||
Sin clasificar
|
||||
|
||||
Ordenados
|
||||
n
|
||||
rad (n)
|
||||
|
||||
n
|
||||
rad (n)
|
||||
k
|
||||
11
|
||||
|
||||
111
|
||||
22
|
||||
|
||||
222
|
||||
33
|
||||
|
||||
423
|
||||
42
|
||||
|
||||
824
|
||||
55
|
||||
|
||||
335
|
||||
66
|
||||
|
||||
936
|
||||
77
|
||||
|
||||
557
|
||||
82
|
||||
|
||||
668
|
||||
93
|
||||
|
||||
779
|
||||
1010
|
||||
|
||||
101010
|
||||
Sea E (k) el elemento kth en la columna ordenada n ; por ejemplo, E (4) = 8 y E (6) = 9.
|
||||
Si rad (n) está ordenado por 1 ≤ n ≤ 100000, encuentre E (10000).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler124()</code> debe devolver 21417.
|
||||
testString: 'assert.strictEqual(euler124(), 21417, "<code>euler124()</code> should return 21417.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler124() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler124();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3e91000cf542c50fefc
|
||||
challengeType: 5
|
||||
title: 'Problem 125: Palindromic sums'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El número palindrómico 595 es interesante porque se puede escribir como la suma de cuadrados consecutivos: 62 + 72 + 82 + 92 + 102 + 112 + 122.
|
||||
Hay exactamente once palíndromos por debajo de mil que se pueden escribir como cuadrados consecutivos sumas, y la suma de estos palíndromos es 4164. Tenga en cuenta que 1 = 02 + 12 no se ha incluido ya que este problema se refiere a los cuadrados de los enteros positivos.
|
||||
Encuentre la suma de todos los números menores de 108 que son palindrómicos y se pueden escribir como la suma de cuadrados consecutivos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler125()</code> debe devolver 2906969179.
|
||||
testString: 'assert.strictEqual(euler125(), 2906969179, "<code>euler125()</code> should return 2906969179.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler125() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler125();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3ea1000cf542c50fefd
|
||||
challengeType: 5
|
||||
title: 'Problem 126: Cuboid layers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El número mínimo de cubos para cubrir cada cara visible en un cuboide que mide 3 x 2 x 1 es veintidos.
|
||||
|
||||
|
||||
Si luego agregamos una segunda capa a este sólido, se necesitarían cuarenta y seis cubos para cubrir todas las caras visibles, la tercera capa requeriría setenta y ocho cubos y la cuarta capa requeriría ciento dieciocho cubos para cubrir Cada cara visible.
|
||||
Sin embargo, la primera capa en un cuboide que mide 5 x 1 x 1 también requiere veintidós cubos; de manera similar, la primera capa en los cuboides que miden 5 x 3 x 1, 7 x 2 x 1 y 11 x 1 x 1 contienen cuarenta y seis cubos.
|
||||
Definiremos que C (n) representa el número de cuboides que contienen n cubos en una de sus capas. Así que C (22) = 2, C (46) = 4, C (78) = 5 y C (118) = 8.
|
||||
Resulta que 154 es el menor valor de n para el cual C (n) = 10 .
|
||||
Encuentre el menor valor de n para el cual C (n) = 1000.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler126()</code> debe devolver 18522.
|
||||
testString: 'assert.strictEqual(euler126(), 18522, "<code>euler126()</code> should return 18522.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler126() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler126();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3ec1000cf542c50fefe
|
||||
challengeType: 5
|
||||
title: 'Problem 127: abc-hits'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El radical de n, rad (n), es el producto de distintos factores primos de n. Por ejemplo, 504 = 23 × 32 × 7, entonces rad (504) = 2 × 3 × 7 = 42.
|
||||
Definiremos el triplete de enteros positivos (a, b, c) como un acierto si:
|
||||
GCD (a, b) = GCD (a, c) = GCD (b, c) = 1
|
||||
a <b
|
||||
a + b = c
|
||||
rad (abc) <c
|
||||
Por ejemplo, (5, 27, 32) es un éxito abc, porque:
|
||||
GCD (5, 27) = GCD (5, 32) = GCD (27, 32) = 1
|
||||
5 <27
|
||||
5 + 27 = 32
|
||||
rad (4320) = 30 <32
|
||||
Resulta que los abc-hits son bastante raros y solo hay treinta y uno abc-hits para c <1000, con ∑c = 12523.
|
||||
Encuentra ∑c para c <120000.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler127()</code> debe devolver 18407904.
|
||||
testString: 'assert.strictEqual(euler127(), 18407904, "<code>euler127()</code> should return 18407904.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler127() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler127();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3ec1000cf542c50feff
|
||||
challengeType: 5
|
||||
title: 'Problem 128: Hexagonal tile differences'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una baldosa hexagonal con el número 1 está rodeada por un anillo de seis baldosas hexagonales, comenzando en "12 en punto" y numerando las baldosas 2 a 7 en sentido antihorario.
|
||||
nuevos anillos se agregan de la misma manera, con los siguientes anillos numerados del 8 al 19, del 20 al 37, del 38 al 61, y así sucesivamente. El siguiente diagrama muestra los tres primeros anillos.
|
||||
|
||||
|
||||
Al encontrar la diferencia entre el azulejo n y cada uno de sus seis vecinos, definiremos PD (n) como el número de esas diferencias que son primos.
|
||||
Por ejemplo, trabajando en el sentido de las agujas del reloj alrededor de la baldosa 8, las diferencias son 12, 29, 11, 6, 1 y 13. Entonces, PD (8) = 3.
|
||||
De la misma manera, las diferencias alrededor de la baldosa 17 son 1, 17, 16 , 1, 11 y 10, por lo tanto, PD (17) = 2.
|
||||
Se puede mostrar que el valor máximo de PD (n) es 3.
|
||||
Si todas las fichas para las cuales PD (n) = 3 se enumeran en en orden ascendente para formar una secuencia, la décima casilla sería 271.
|
||||
Encuentre la baldosa 2000 en esta secuencia.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler128()</code> debe devolver 14516824220.
|
||||
testString: 'assert.strictEqual(euler128(), 14516824220, "<code>euler128()</code> should return 14516824220.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler128() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler128();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3ef1000cf542c50ff01
|
||||
challengeType: 5
|
||||
title: 'Problem 129: Repunit divisibility'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un número formado enteramente por unos se llama repunit. Definiremos que R (k) es una repunidad de longitud k; por ejemplo, R (6) = 111111.
|
||||
Dado que n es un entero positivo y GCD (n, 10) = 1, se puede mostrar que siempre existe un valor, k, para el cual R (k) es divisible por n, y sea A (n) el menor valor de k; por ejemplo, A (7) = 6 y A (41) = 5.
|
||||
El valor mínimo de n para el cual A (n) primero excede de diez es 17.
|
||||
Encuentre el valor mínimo de n para el cual A (n) excede primero un millón.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler129()</code> debe devolver 1000023.
|
||||
testString: 'assert.strictEqual(euler129(), 1000023, "<code>euler129()</code> should return 1000023.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler129() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler129();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,296 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f37a1000cf542c50fe8c
|
||||
challengeType: 5
|
||||
title: 'Problem 13: Large sum'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Calcule los primeros diez dígitos de la suma de los siguientes cien números de 50 dígitos.
|
||||
|
||||
37107287533902102798797998220837590246510135740250
|
||||
46376937677490009712648124896970078050417018260538
|
||||
74324986199524741059474233309513058123726617309629
|
||||
91942213363574161572522430563301811072406154908250
|
||||
23067588207539346171171980310421047513778063246676
|
||||
89261670696623633820136378418383684178734361726757
|
||||
28112879812849979408065481931592621691275889832738
|
||||
44274228917432520321923589422876796487670272189318
|
||||
47451445736001306439091167216856844588711603153276
|
||||
70386486105843025439939619828917593665686757934951
|
||||
62176457141856560629502157223196586755079324193331
|
||||
64906352462741904929101432445813822663347944758178
|
||||
92575867718337217661963751590579239728245598838407
|
||||
58203565325359399008402633568948830189458628227828
|
||||
80181199384826282014278194139940567587151170094390
|
||||
35398664372827112653829987240784473053190104293586
|
||||
86515506006295864861532075273371959191420517255829
|
||||
71693888707715466499115593487603532921714970056938
|
||||
543700705768266846246214956500764717872944 38377604
|
||||
53282654108756828443191190634694037855217779295145
|
||||
36123272525000296071075082563815656710885258350721
|
||||
45876576172410976447339110607218265236877223636045
|
||||
17423706905851860660448207621209813287860733969412
|
||||
81142660418086830619328460811191061556940512689692
|
||||
51934325451728388641918047049293215058642563049483
|
||||
62467221648435076201727918039944693004732956340691
|
||||
15732444386908125794514089057706229429197107928209
|
||||
55037687525678773091862540744969844508330393682126
|
||||
18336384825330154686196124348767681297534375946515
|
||||
80386287592878490201521685554828717201219257766954
|
||||
78182833757993103614740356856449095527097864797581
|
||||
16726320100436897842553539920931837441497806860984
|
||||
48403098129077791799088218795327364475675590848030
|
||||
87086987551392711854517078544161852424320693150332
|
||||
59959406895756536782107074926966537676326235447210
|
||||
69793950679652694742597709739166693763042633987085
|
||||
41052684708299085211399427365734116182760315001271
|
||||
65378607361501080857009149939512557 028198746004375
|
||||
35829035317434717326932123578154982629742552737307
|
||||
94953759765105305946966067683156574377167401875275
|
||||
88902802571733229619176668713819931811048770190271
|
||||
25267680276078003013678680992525463401061632866526
|
||||
36270218540497705585629946580636237993140746255962
|
||||
24074486908231174977792365466257246923322810917141
|
||||
91430288197103288597806669760892938638285025333403
|
||||
34413065578016127815921815005561868836468420090470
|
||||
23053081172816430487623791969842487255036638784583
|
||||
11487696932154902810424020138335124462181441773470
|
||||
63783299490636259666498587618221225225512486764533
|
||||
67720186971698544312419572409913959008952310058822
|
||||
95548255300263520781532296796249481641953868218774
|
||||
76085327132285723110424803456124867697064507995236
|
||||
37774242535411291684276865538926205024910326572967
|
||||
23701913275725675285653248258265463092207058596522
|
||||
29798860272258331913126375147341994889534765745501
|
||||
18495701454879288984856827726077713721403798879715
|
||||
3829820378303147352772158034 8144513491373226651381
|
||||
34829543829199918180278916522431027392251122869539
|
||||
40957953066405232632538044100059654939159879593635
|
||||
29746152185502371307642255121183693803580388584903
|
||||
41698116222072977186158236678424689157993532961922
|
||||
62467957194401269043877107275048102390895523597457
|
||||
23189706772547915061505504953922979530901129967519
|
||||
86188088225875314529584099251203829009407770775672
|
||||
11306739708304724483816533873502340845647058077308
|
||||
82959174767140363198008187129011875491310547126581
|
||||
97623331044818386269515456334926366572897563400500
|
||||
42846280183517070527831839425882145521227251250327
|
||||
55121603546981200581762165212827652751691296897789
|
||||
32238195734329339946437501907836945765883352399886
|
||||
75506164965184775180738168837861091527357929701337
|
||||
62177842752192623401942399639168044983993173312731
|
||||
32924185707147349566916674687634660915035914677504
|
||||
99518671430235219628894890102423325116913619626622
|
||||
73267460800591547471830798392868535206946944540724
|
||||
768418225246744171615 14036427982273348055556214818
|
||||
97142617910342598647204516893989422179826088076852
|
||||
87783646182799346313767754307809363333018982642090
|
||||
10848802521674670883215120185883543223812876952786
|
||||
71329612474782464538636993009049310363619763878039
|
||||
62184073572399794223406235393808339651327408011116
|
||||
66627891981488087797941876876144230030984490851411
|
||||
60661826293682836764744779239180335110989069790714
|
||||
85786944089552990653640447425576083659976645795096
|
||||
66024396409905389607120198219976047599490197230297
|
||||
64913982680032973156037120041377903785566085089252
|
||||
16730939319872750275468906903707539413042652315011
|
||||
94809377245048795150954100921645863754710598436791
|
||||
78639167021187492431995700641917969777599028300699
|
||||
15368713711936614952811305876380278410754449733078
|
||||
40789923115535562561142322423255033685442488917353
|
||||
44889911501440648020369068063960672322193204149535
|
||||
41503128880339536053299340368006977710650566631954
|
||||
81234880673210146739058568557934581403627822703280
|
||||
82616570773948 327592232845941706525094512325230608
|
||||
22918802058777319719839450180888072429661980811197
|
||||
77158542502016545090413245809786882778948721859617
|
||||
72107838435069186155435662884062257473692284509516
|
||||
20849603980134001723930671666823555245252804609722
|
||||
53503534226472524250874054075591789781264330331690
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>largeSum(testNums)</code> debe devolver 8348422521.
|
||||
testString: 'assert.strictEqual(largeSum(testNums), 8348422521, "<code>largeSum(testNums)</code> should return 8348422521.");'
|
||||
- text: <code>largeSum(fiftyDigitNums)</code> debe devolver 5537376230.
|
||||
testString: 'assert.strictEqual(largeSum(fiftyDigitNums), 5537376230, "<code>largeSum(fiftyDigitNums)</code> should return 5537376230.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function largeSum(arr) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
// only change code above this line
|
||||
|
||||
const testNums = [
|
||||
'37107287533902102798797998220837590246510135740250',
|
||||
'46376937677490009712648124896970078050417018260538'
|
||||
];
|
||||
|
||||
largeSum(testNums);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
### Before Test
|
||||
<div id='js-setup'>
|
||||
|
||||
```js
|
||||
const fiftyDigitNums = [
|
||||
'37107287533902102798797998220837590246510135740250',
|
||||
'46376937677490009712648124896970078050417018260538',
|
||||
'74324986199524741059474233309513058123726617309629',
|
||||
'91942213363574161572522430563301811072406154908250',
|
||||
'23067588207539346171171980310421047513778063246676',
|
||||
'89261670696623633820136378418383684178734361726757',
|
||||
'28112879812849979408065481931592621691275889832738',
|
||||
'44274228917432520321923589422876796487670272189318',
|
||||
'47451445736001306439091167216856844588711603153276',
|
||||
'70386486105843025439939619828917593665686757934951',
|
||||
'62176457141856560629502157223196586755079324193331',
|
||||
'64906352462741904929101432445813822663347944758178',
|
||||
'92575867718337217661963751590579239728245598838407',
|
||||
'58203565325359399008402633568948830189458628227828',
|
||||
'80181199384826282014278194139940567587151170094390',
|
||||
'35398664372827112653829987240784473053190104293586',
|
||||
'86515506006295864861532075273371959191420517255829',
|
||||
'71693888707715466499115593487603532921714970056938',
|
||||
'54370070576826684624621495650076471787294438377604',
|
||||
'53282654108756828443191190634694037855217779295145',
|
||||
'36123272525000296071075082563815656710885258350721',
|
||||
'45876576172410976447339110607218265236877223636045',
|
||||
'17423706905851860660448207621209813287860733969412',
|
||||
'81142660418086830619328460811191061556940512689692',
|
||||
'51934325451728388641918047049293215058642563049483',
|
||||
'62467221648435076201727918039944693004732956340691',
|
||||
'15732444386908125794514089057706229429197107928209',
|
||||
'55037687525678773091862540744969844508330393682126',
|
||||
'18336384825330154686196124348767681297534375946515',
|
||||
'80386287592878490201521685554828717201219257766954',
|
||||
'78182833757993103614740356856449095527097864797581',
|
||||
'16726320100436897842553539920931837441497806860984',
|
||||
'48403098129077791799088218795327364475675590848030',
|
||||
'87086987551392711854517078544161852424320693150332',
|
||||
'59959406895756536782107074926966537676326235447210',
|
||||
'69793950679652694742597709739166693763042633987085',
|
||||
'41052684708299085211399427365734116182760315001271',
|
||||
'65378607361501080857009149939512557028198746004375',
|
||||
'35829035317434717326932123578154982629742552737307',
|
||||
'94953759765105305946966067683156574377167401875275',
|
||||
'88902802571733229619176668713819931811048770190271',
|
||||
'25267680276078003013678680992525463401061632866526',
|
||||
'36270218540497705585629946580636237993140746255962',
|
||||
'24074486908231174977792365466257246923322810917141',
|
||||
'91430288197103288597806669760892938638285025333403',
|
||||
'34413065578016127815921815005561868836468420090470',
|
||||
'23053081172816430487623791969842487255036638784583',
|
||||
'11487696932154902810424020138335124462181441773470',
|
||||
'63783299490636259666498587618221225225512486764533',
|
||||
'67720186971698544312419572409913959008952310058822',
|
||||
'95548255300263520781532296796249481641953868218774',
|
||||
'76085327132285723110424803456124867697064507995236',
|
||||
'37774242535411291684276865538926205024910326572967',
|
||||
'23701913275725675285653248258265463092207058596522',
|
||||
'29798860272258331913126375147341994889534765745501',
|
||||
'18495701454879288984856827726077713721403798879715',
|
||||
'38298203783031473527721580348144513491373226651381',
|
||||
'34829543829199918180278916522431027392251122869539',
|
||||
'40957953066405232632538044100059654939159879593635',
|
||||
'29746152185502371307642255121183693803580388584903',
|
||||
'41698116222072977186158236678424689157993532961922',
|
||||
'62467957194401269043877107275048102390895523597457',
|
||||
'23189706772547915061505504953922979530901129967519',
|
||||
'86188088225875314529584099251203829009407770775672',
|
||||
'11306739708304724483816533873502340845647058077308',
|
||||
'82959174767140363198008187129011875491310547126581',
|
||||
'97623331044818386269515456334926366572897563400500',
|
||||
'42846280183517070527831839425882145521227251250327',
|
||||
'55121603546981200581762165212827652751691296897789',
|
||||
'32238195734329339946437501907836945765883352399886',
|
||||
'75506164965184775180738168837861091527357929701337',
|
||||
'62177842752192623401942399639168044983993173312731',
|
||||
'32924185707147349566916674687634660915035914677504',
|
||||
'99518671430235219628894890102423325116913619626622',
|
||||
'73267460800591547471830798392868535206946944540724',
|
||||
'76841822524674417161514036427982273348055556214818',
|
||||
'97142617910342598647204516893989422179826088076852',
|
||||
'87783646182799346313767754307809363333018982642090',
|
||||
'10848802521674670883215120185883543223812876952786',
|
||||
'71329612474782464538636993009049310363619763878039',
|
||||
'62184073572399794223406235393808339651327408011116',
|
||||
'66627891981488087797941876876144230030984490851411',
|
||||
'60661826293682836764744779239180335110989069790714',
|
||||
'85786944089552990653640447425576083659976645795096',
|
||||
'66024396409905389607120198219976047599490197230297',
|
||||
'64913982680032973156037120041377903785566085089252',
|
||||
'16730939319872750275468906903707539413042652315011',
|
||||
'94809377245048795150954100921645863754710598436791',
|
||||
'78639167021187492431995700641917969777599028300699',
|
||||
'15368713711936614952811305876380278410754449733078',
|
||||
'40789923115535562561142322423255033685442488917353',
|
||||
'44889911501440648020369068063960672322193204149535',
|
||||
'41503128880339536053299340368006977710650566631954',
|
||||
'81234880673210146739058568557934581403627822703280',
|
||||
'82616570773948327592232845941706525094512325230608',
|
||||
'22918802058777319719839450180888072429661980811197',
|
||||
'77158542502016545090413245809786882778948721859617',
|
||||
'72107838435069186155435662884062257473692284509516',
|
||||
'20849603980134001723930671666823555245252804609722',
|
||||
'53503534226472524250874054075591789781264330331690'
|
||||
];
|
||||
|
||||
const testNums = [
|
||||
'37107287533902102798797998220837590246510135740250',
|
||||
'46376937677490009712648124896970078050417018260538'
|
||||
];
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function largeSum(arr) {
|
||||
|
||||
let sum = 0;
|
||||
|
||||
arr.forEach(function(num) {
|
||||
sum += parseInt(num, 10);
|
||||
});
|
||||
|
||||
sum = sum.toString(10);
|
||||
|
||||
sum = sum.substr(0, 1) + sum.substr(2);
|
||||
|
||||
let firstTen = sum.slice(0, 10);
|
||||
return parseInt(firstTen, 10);
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3ee1000cf542c50ff00
|
||||
challengeType: 5
|
||||
title: 'Problem 130: Composites with prime repunit property'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un número formado enteramente por unos se llama repunit. Definiremos que R (k) es una repunidad de longitud k; por ejemplo, R (6) = 111111.
|
||||
Dado que n es un entero positivo y GCD (n, 10) = 1, se puede mostrar que siempre existe un valor, k, para el cual R (k) es divisible por n, y sea A (n) el menor valor de k; por ejemplo, A (7) = 6 y A (41) = 5.
|
||||
Se le da para todos los primos, p> 5, que p - 1 es divisible por A (p). Por ejemplo, cuando p = 41, A (41) = 5, y 40 es divisible por 5.
|
||||
Sin embargo, hay valores compuestos raros para los cuales esto también es cierto; los primeros cinco ejemplos son 91, 259, 451, 481 y 703.
|
||||
Encuentre la suma de los primeros veinticinco valores compuestos de n para los cuales GCD (n, 10) = 1 y n - 1 es divisible por A (n) .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler130()</code> debe devolver 149253.
|
||||
testString: 'assert.strictEqual(euler130(), 149253, "<code>euler130()</code> should return 149253.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler130() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler130();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3ef1000cf542c50ff02
|
||||
challengeType: 5
|
||||
title: 'Problem 131: Prime cube partnership'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hay algunos valores primarios, p, para los cuales existe un entero positivo, n, de manera que la expresión n3 + n2p es un cubo perfecto.
|
||||
Por ejemplo, cuando p = 19, 83 + 82 × 19 = 123.
|
||||
Lo que quizás sea más sorprendente es que para cada primo con esta propiedad el valor de n es único, y solo hay cuatro primos de este tipo por debajo de cien.
|
||||
¿Cuántos números primos por debajo de un millón tiene esta propiedad notable?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler131()</code> debe devolver 173.
|
||||
testString: 'assert.strictEqual(euler131(), 173, "<code>euler131()</code> should return 173.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler131() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler131();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f11000cf542c50ff03
|
||||
challengeType: 5
|
||||
title: 'Problem 132: Large repunit factors'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un número formado enteramente por unos se llama repunit. Definiremos que R (k) es una repunidad de longitud k.
|
||||
Por ejemplo, R (10) = 1111111111 = 11 × 41 × 271 × 9091, y la suma de estos factores primos es 9414.
|
||||
Encuentre la suma de los primeros cuarenta factores primos de R (109).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler132()</code> debe devolver 843296.
|
||||
testString: 'assert.strictEqual(euler132(), 843296, "<code>euler132()</code> should return 843296.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler132() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler132();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f21000cf542c50ff04
|
||||
challengeType: 5
|
||||
title: 'Problem 133: Repunit nonfactors'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un número formado enteramente por unos se llama repunit. Definiremos que R (k) es una repunidad de longitud k; por ejemplo, R (6) = 111111.
|
||||
Consideremos las repunidades de la forma R (10n).
|
||||
Aunque R (10), R (100) o R (1000) no son divisibles por 17, R (10000) es divisible por 17. Sin embargo, no hay un valor de n para el cual R (10n) se dividirá por 19. De hecho, es notable que 11, 17, 41 y 73 son los únicos cuatro primos por debajo de cien que pueden ser un factor de R (10n).
|
||||
Encuentra la suma de todos los números primos por debajo de cien mil que nunca serán un factor de R (10n).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler133()</code> debe devolver 453647705.
|
||||
testString: 'assert.strictEqual(euler133(), 453647705, "<code>euler133()</code> should return 453647705.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler133() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler133();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f21000cf542c50ff05
|
||||
challengeType: 5
|
||||
title: 'Problem 134: Prime pair connection'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere los primos consecutivos p1 = 19 y p2 = 23. Se puede verificar que 1219 es el número más pequeño, de modo que los últimos dígitos están formados por p1 y también son divisibles por p2.
|
||||
De hecho, con la excepción de p1 = 3 y p2 = 5, para cada par de primos consecutivos, p2> p1, existen valores de n para los cuales los últimos dígitos están formados por p1 yn es divisible por p2. Sea S el más pequeño de estos valores de n.
|
||||
Encuentre ∑ S para cada par de primos consecutivos con 5 ≤ p1 ≤ 1000000.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler134()</code> debe devolver 18613426663617120.
|
||||
testString: 'assert.strictEqual(euler134(), 18613426663617120, "<code>euler134()</code> should return 18613426663617120.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler134() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler134();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f31000cf542c50ff06
|
||||
challengeType: 5
|
||||
title: 'Problem 135: Same differences'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Dado que los enteros positivos, x, y, y z, son términos consecutivos de una progresión aritmética, el menor valor del entero positivo, n, para el cual la ecuación, x2 - y2 - z2 = n, tiene exactamente dos soluciones es n = 27:
|
||||
342 - 272 - 202 = 122 - 92 - 62 = 27
|
||||
Resulta que n = 1155 es el valor mínimo que tiene exactamente diez soluciones.
|
||||
¿Cuántos valores de n menos de un millón tienen exactamente diez soluciones distintas?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler135()</code> debe devolver 4989.
|
||||
testString: 'assert.strictEqual(euler135(), 4989, "<code>euler135()</code> should return 4989.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler135() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler135();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f51000cf542c50ff07
|
||||
challengeType: 5
|
||||
title: 'Problem 136: Singleton difference'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los enteros positivos, x, y, y z, son términos consecutivos de una progresión aritmética. Dado que n es un entero positivo, la ecuación, x2 - y2 - z2 = n, tiene exactamente una solución cuando n = 20:
|
||||
132 - 102 - 72 = 20
|
||||
De hecho, hay veinticinco valores de n por debajo de cien Para lo cual la ecuación tiene una solución única.
|
||||
¿Cuántos valores de n menos de cincuenta millones tienen exactamente una solución?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler136()</code> debe devolver 2544559.
|
||||
testString: 'assert.strictEqual(euler136(), 2544559, "<code>euler136()</code> should return 2544559.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler136() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler136();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,77 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f51000cf542c50ff08
|
||||
challengeType: 5
|
||||
title: 'Problem 137: Fibonacci golden nuggets'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere la serie polinomial infinita AF (x) = xF1 + x2F2 + x3F3 + ..., donde Fk es el término kth en la secuencia de Fibonacci: 1, 1, 2, 3, 5, 8, ...; es decir, Fk = Fk − 1 + Fk − 2, F1 = 1 y F2 = 1.
|
||||
Para este problema, nos interesarán los valores de x para los cuales AF (x) es un entero positivo.
|
||||
Sorprendentemente AF (1/2)
|
||||
=
|
||||
(1/2) .1 + (1/2) 2.1 + (1/2) 3.2 + (1/2) 4.3 + (1/2) 5.5 + ...
|
||||
|
||||
=
|
||||
1/2 + 1/4 + 2/8 + 3/16 + 5/32 + ...
|
||||
|
||||
=
|
||||
2
|
||||
Los valores correspondientes de x para los primeros cinco números naturales se muestran a continuación.
|
||||
|
||||
xAF (x)
|
||||
√2−11
|
||||
1/22
|
||||
(√13−2) / 33
|
||||
(√89−5) / 84
|
||||
(√34−3) / 55
|
||||
|
||||
Llamaremos AF (x ) una pepita de oro si x es racional, porque se vuelven cada vez más raras; por ejemplo, la décima pepita de oro es 74049690.
|
||||
Encuentre la décimo quinta pepita de oro.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler137()</code> debe devolver 1120149658760.
|
||||
testString: 'assert.strictEqual(euler137(), 1120149658760, "<code>euler137()</code> should return 1120149658760.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler137() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler137();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f61000cf542c50ff09
|
||||
challengeType: 5
|
||||
title: 'Problem 138: Special isosceles triangles'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere el triángulo isósceles con la longitud de la base, b = 16, y las piernas, L = 17.
|
||||
|
||||
|
||||
Al usar el teorema de Pitágoras, se puede ver que la altura del triángulo, h = √ (172 - 82) = 15, que es uno menos que la longitud de la base.
|
||||
Con b = 272 y L = 305, obtenemos h = 273, que es uno más que la longitud de la base, y este es el segundo triángulo isósceles más pequeño con la propiedad que h = b ± 1.
|
||||
Encuentra ∑ L para los doce Los triángulos isósceles más pequeños para los cuales h = b ± 1 y b, L son enteros positivos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler138()</code> debe devolver 1118049290473932.
|
||||
testString: 'assert.strictEqual(euler138(), 1118049290473932, "<code>euler138()</code> should return 1118049290473932.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler138() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler138();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f71000cf542c50ff0a
|
||||
challengeType: 5
|
||||
title: 'Problem 139: Pythagorean tiles'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea (a, b, c) los tres lados de un triángulo rectángulo con lados de longitud integral. Es posible colocar cuatro de estos triángulos juntos para formar un cuadrado con una longitud c.
|
||||
Por ejemplo, (3, 4, 5) los triángulos se pueden colocar juntos para formar un cuadrado de 5 por 5 con un orificio de 1 por 1 en el medio y se puede ver que el cuadrado de 5 por 5 se puede colocar en mosaico con veinticinco 1 por 1 cuadrados.
|
||||
|
||||
|
||||
Sin embargo, si se usaran (5, 12, 13) triángulos, entonces el orificio mediría 7 por 7 y estos no podrían usarse para colocar los azulejos por 13 por 13 cuadrados.
|
||||
Dado que el perímetro del triángulo rectángulo es inferior a cien millones, ¿cuántos triángulos pitagóricos permitirían que se formara tal mosaico?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler139()</code> debe devolver 10057761.
|
||||
testString: 'assert.strictEqual(euler139(), 10057761, "<code>euler139()</code> should return 10057761.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler139() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler139();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,101 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f37a1000cf542c50fe8d
|
||||
challengeType: 5
|
||||
title: 'Problem 14: Longest Collatz sequence'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La siguiente secuencia iterativa se define para el conjunto de enteros positivos:
|
||||
<div style='padding-left: 4em;'> <var>n</var> → <var>n</var> / 2 ( <var>n</var> es par) </div>
|
||||
<div style='padding-left: 4em;'> <var>n</var> → 3 <var>n</var> + 1 ( <var>n</var> es impar) </div>
|
||||
Usando la regla anterior y comenzando con 13, generamos la siguiente secuencia:
|
||||
<div style='text-align: center;'> 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1 </div>
|
||||
Se puede ver que esta secuencia (comenzando en 13 y terminando en 1) contiene 10 términos. Aunque aún no se ha probado (Problema de Collatz), se piensa que todos los números iniciales terminan en 1.
|
||||
¿Qué número inicial, debajo del <code>limit</code> dado, produce la cadena más larga?
|
||||
NOTA: Una vez que la cadena comienza, los términos pueden ir por encima de un millón.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>longestCollatzSequence(14)</code> debe devolver 9.
|
||||
testString: 'assert.strictEqual(longestCollatzSequence(14), 9, "<code>longestCollatzSequence(14)</code> should return 9.");'
|
||||
- text: <code>longestCollatzSequence(5847)</code> debe devolver 3711.
|
||||
testString: 'assert.strictEqual(longestCollatzSequence(5847), 3711, "<code>longestCollatzSequence(5847)</code> should return 3711.");'
|
||||
- text: <code>longestCollatzSequence(46500)</code> debe devolver 35655.
|
||||
testString: 'assert.strictEqual(longestCollatzSequence(46500), 35655, "<code>longestCollatzSequence(46500)</code> should return 35655.");'
|
||||
- text: <code>longestCollatzSequence(54512)</code> debe devolver 52527.
|
||||
testString: 'assert.strictEqual(longestCollatzSequence(54512), 52527, "<code>longestCollatzSequence(54512)</code> should return 52527.");'
|
||||
- text: <code>longestCollatzSequence(1000000)</code> debe devolver 837799.
|
||||
testString: 'assert.strictEqual(longestCollatzSequence(1000000), 837799, "<code>longestCollatzSequence(1000000)</code> should return 837799.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function longestCollatzSequence(limit) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
longestCollatzSequence(14);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function longestCollatzSequence(limit) {
|
||||
let longestSequenceLength = 0;
|
||||
let startingNum = 0;
|
||||
|
||||
function sequenceLength(num) {
|
||||
let length = 1;
|
||||
|
||||
while (num >= 1) {
|
||||
if (num === 1) { break;
|
||||
} else if (num % 2 === 0) {
|
||||
num = num / 2;
|
||||
length++;
|
||||
} else {
|
||||
num = num * 3 + 1;
|
||||
length++;
|
||||
}
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
for (let i = 2; i < limit; i++) {
|
||||
let currSequenceLength = sequenceLength(i);
|
||||
if (currSequenceLength > longestSequenceLength) {
|
||||
longestSequenceLength = currSequenceLength;
|
||||
startingNum = i;
|
||||
}
|
||||
}
|
||||
return startingNum;
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3fa1000cf542c50ff0c
|
||||
challengeType: 5
|
||||
title: 'Problem 140: Modified Fibonacci golden nuggets'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere la serie polinomial infinita AG (x) = xG1 + x2G2 + x3G3 + ..., donde Gk es el término kth de la relación de recurrencia de segundo orden Gk = Gk − 1 + Gk − 2, G1 = 1 y G2 = 4 ; es decir, 1, 4, 5, 9, 14, 23, ....
|
||||
Para este problema, nos ocuparemos de los valores de x para los que AG (x) es un entero positivo.
|
||||
Los valores correspondientes de x para los primeros cinco números naturales se muestran a continuación.
|
||||
|
||||
xAG (x)
|
||||
(√5−1) / 41
|
||||
2/52
|
||||
(√22−2) / 63
|
||||
(√137−5) / 144
|
||||
1/25
|
||||
|
||||
Llamaremos a AG (x) una pepita de oro si x es racional, porque se vuelven cada vez más raras; por ejemplo, la vigésima pepita de oro es 211345365.
|
||||
Encuentra la suma de las primeras treinta pepitas de oro.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler140()</code> debe devolver 5673835352990.
|
||||
testString: 'assert.strictEqual(euler140(), 5673835352990, "<code>euler140()</code> should return 5673835352990.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler140() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler140();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3f91000cf542c50ff0b
|
||||
challengeType: 5
|
||||
title: 'Problem 141: Investigating progressive numbers, n, which are also square'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un entero positivo, n, se divide por d y el cociente y el resto son qyr respectivamente. Además, d, q y r son términos enteros positivos consecutivos en una secuencia geométrica, pero no necesariamente en ese orden.
|
||||
Por ejemplo, 58 dividido por 6 tiene el cociente 9 y el resto 4. También se puede ver que 4, 6, 9 son términos consecutivos en una secuencia geométrica (relación común 3/2).
|
||||
Llamaremos tales números, n, progresivo.
|
||||
Algunos números progresivos, como 9 y 10404 = 1022, también son cuadrados perfectos. La suma de todos los cuadrados perfectos progresivos por debajo de cien mil es 124657.
|
||||
Halla la suma de todos los cuadrados perfectos progresivos por debajo de un trillón (1012).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler141()</code> debe devolver 878454337159.
|
||||
testString: 'assert.strictEqual(euler141(), 878454337159, "<code>euler141()</code> should return 878454337159.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler141() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler141();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3fa1000cf542c50ff0d
|
||||
challengeType: 5
|
||||
title: 'Problem 142: Perfect Square Collection'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Encuentre el x + y + z más pequeño con los enteros x> y> z> 0 de manera que x + y, x - y, x + z, x - z, y + z, y - z sean todos cuadrados perfectos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler142()</code> debe devolver 1006193.
|
||||
testString: 'assert.strictEqual(euler142(), 1006193, "<code>euler142()</code> should return 1006193.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler142() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler142();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3fc1000cf542c50ff0e
|
||||
challengeType: 5
|
||||
title: 'Problem 143: Investigating the Torricelli point of a triangle'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Deje que ABC sea un triángulo con todos los ángulos interiores de menos de 120 grados. Sea X un punto dentro del triángulo y sea XA = p, XC = q, y XB = r.
|
||||
Fermat desafió a Torricelli a encontrar la posición de X tal que p + q + r se minimice.
|
||||
Torricelli pudo probar que si los triángulos equiláteros AOB, BNC y AMC se construyen en cada lado del triángulo ABC, los círculos circunscritos de AOB, BNC y AMC se intersectarán en un solo punto, T, dentro del triángulo. Además, demostró que T, llamado el punto Torricelli / Fermat, minimiza p + q + r. Aún más notable, se puede mostrar que cuando la suma se minimiza, AN = BM = CO = p + q + r y que AN, BM y CO también se intersecan en T.
|
||||
|
||||
Si la suma se minimiza y a, b, c, p, qyr son todos enteros positivos que llamaremos triángulo ABC triángulo Torricelli. Por ejemplo, a = 399, b = 455, c = 511 es un ejemplo de un triángulo Torricelli, con p + q + r = 784.
|
||||
Halla la suma de todos los valores distintos de p + q + r ≤ 120000 para triángulos Torricelli .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler143()</code> debe devolver 30758397.
|
||||
testString: 'assert.strictEqual(euler143(), 30758397, "<code>euler143()</code> should return 30758397.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler143() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler143();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3fc1000cf542c50ff0f
|
||||
challengeType: 5
|
||||
title: 'Problem 144: Investigating multiple reflections of a laser beam'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En la física del láser, una "célula blanca" es un sistema de espejo que actúa como una línea de retardo para el rayo láser. El rayo entra en la celda, rebota en los espejos y eventualmente vuelve a salir.
|
||||
La celda blanca específica que consideraremos es una elipse con la ecuación 4x2 + y2 = 100
|
||||
Falta la sección correspondiente a −0.01 ≤ x ≤ +0.01 en la parte superior, lo que permite que la luz entre y salga por el orificio.
|
||||
|
||||
El haz de luz en este problema comienza en el punto (0.0,10.1) justo fuera de la celda blanca, y el haz primero impacta al espejo en (1.4, -9.6).
|
||||
Cada vez que el rayo láser golpea la superficie de la elipse, sigue la ley usual de reflexión: "ángulo de incidencia es igual a ángulo de reflexión". Es decir, tanto el haz incidente como el reflejado forman el mismo ángulo con la línea normal en el punto de incidencia.
|
||||
En la figura de la izquierda, la línea roja muestra los dos primeros puntos de contacto entre el rayo láser y la pared de la célula blanca; la línea azul muestra la línea tangente a la elipse en el punto de incidencia del primer rebote. La pendiente m de la línea tangente en cualquier punto (x, y) de la elipse dada es: m = −4x / y La línea normal es Perpendicular a esta línea tangente en el punto de incidencia.
|
||||
La animación de la derecha muestra las 10 primeras reflexiones de la viga.
|
||||
|
||||
¿Cuántas veces el haz golpea la superficie interna de la célula blanca antes de salir?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler144()</code> debe devolver 354.
|
||||
testString: 'assert.strictEqual(euler144(), 354, "<code>euler144()</code> should return 354.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler144() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler144();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3fd1000cf542c50ff10
|
||||
challengeType: 5
|
||||
title: 'Problem 145: How many reversible numbers are there below one-billion?'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Algunos enteros positivos n tienen la propiedad de que la suma [n + reverse (n)] consta completamente de dígitos impares (decimales). Por ejemplo, 36 + 63 = 99 y 409 + 904 = 1313. Llamaremos a dichos números reversibles; por lo que 36, 63, 409 y 904 son reversibles. Los ceros iniciales no están permitidos ni en n ni en reversa (n).
|
||||
|
||||
Hay 120 números reversibles por debajo de mil.
|
||||
|
||||
¿Cuántos números reversibles hay por debajo de mil millones (109)?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler145()</code> debe devolver 608720.
|
||||
testString: 'assert.strictEqual(euler145(), 608720, "<code>euler145()</code> should return 608720.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler145() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler145();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3fe1000cf542c50ff11
|
||||
challengeType: 5
|
||||
title: 'Problem 146: Investigating a Prime Pattern'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El entero positivo más pequeño n para el cual los números n2 + 1, n2 + 3, n2 + 7, n2 + 9, n2 + 13 y n2 + 27 son primos consecutivos es 10. La suma de todos los enteros de este tipo n debajo de uno es millón es 1242490.
|
||||
|
||||
¿Cuál es la suma de todos estos enteros n por debajo de 150 millones?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler146()</code> debe devolver 676333270.
|
||||
testString: 'assert.strictEqual(euler146(), 676333270, "<code>euler146()</code> should return 676333270.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler146() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler146();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,67 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f3ff1000cf542c50ff12
|
||||
challengeType: 5
|
||||
title: 'Problem 147: Rectangles in cross-hatched grids'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En una cuadrícula sombreada de 3x2, un total de 37 rectángulos diferentes podrían situarse dentro de esa cuadrícula como se indica en el boceto.
|
||||
|
||||
Hay 5 cuadrículas más pequeñas que 3x2, siendo importantes las dimensiones vertical y horizontal, es decir, 1x1, 2x1, 3x1, 1x2 y 2x2. Si cada uno de ellos es sombreado, el siguiente número de rectángulos diferentes podría situarse dentro de esas cuadrículas más pequeñas:
|
||||
1x1: 1
|
||||
2x1: 4
|
||||
3x1: 8
|
||||
1x2: 4
|
||||
2x2: 18
|
||||
|
||||
Agregar estos a la de la cuadrícula de 3x2, un total de 72 rectángulos diferentes podrían situarse dentro de 3x2 y cuadrículas más pequeñas.
|
||||
|
||||
¿Cuántos rectángulos diferentes podrían situarse dentro de 47x43 y cuadrículas más pequeñas?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler147()</code> debe devolver 846910284.
|
||||
testString: 'assert.strictEqual(euler147(), 846910284, "<code>euler147()</code> should return 846910284.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler147() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler147();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,135 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4021000cf542c50ff14
|
||||
challengeType: 5
|
||||
title: 'Problem 148: Exploring Pascal"s triangle'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Podemos verificar fácilmente que ninguna de las entradas en las primeras siete filas del triángulo de Pascal son divisibles entre 7:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1
|
||||
|
||||
|
||||
|
||||
1
|
||||
|
||||
3
|
||||
|
||||
3
|
||||
|
||||
1
|
||||
|
||||
|
||||
1
|
||||
|
||||
4
|
||||
|
||||
6
|
||||
|
||||
4
|
||||
|
||||
1
|
||||
|
||||
1
|
||||
|
||||
5
|
||||
|
||||
10
|
||||
|
||||
10
|
||||
|
||||
5
|
||||
|
||||
1
|
||||
1
|
||||
|
||||
6
|
||||
|
||||
15
|
||||
|
||||
20
|
||||
|
||||
15
|
||||
|
||||
6
|
||||
|
||||
1
|
||||
Sin embargo, si revisamos las primeras cien filas, encontraremos que solo 2361 de las 5050 entradas no son divisibles por 7.
|
||||
|
||||
Encuentre el número de entradas que no son divisibles por 7 en las primeras mil millones (109) filas del triángulo de Pascal.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler148()</code> debe devolver 2129970655314432.
|
||||
testString: 'assert.strictEqual(euler148(), 2129970655314432, "<code>euler148()</code> should return 2129970655314432.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler148() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler148();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,72 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4021000cf542c50ff13
|
||||
challengeType: 5
|
||||
title: 'Problem 149: Searching for a maximum-sum subsequence'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Mirando la tabla de abajo, es fácil verificar que la suma máxima posible de números adyacentes en cualquier dirección (horizontal, vertical, diagonal o anti-diagonal) es 16 (= 8 + 7 + 1).
|
||||
|
||||
|
||||
−25329−6513273−18−4 8
|
||||
|
||||
Ahora, repitamos la búsqueda, pero en una escala mucho mayor:
|
||||
|
||||
Primero, genere cuatro millones de números pseudoaleatorios utilizando una forma específica de lo que se conoce como "Lagged Fibonacci Generator":
|
||||
|
||||
para 1 ≤ k ≤ 55, sk = [100003 - 200003k + 300007k3] (módulo 1000000) - 500000.
|
||||
para 56 ≤ k ≤ 4000000, sk = [sk − 24 + sk − 55 + 1000000] (módulo 1000000) - 500000.
|
||||
|
||||
Por lo tanto, s10 = −393027 y s100 = 86613.
|
||||
|
||||
Los términos de s se ordenan en una tabla de 2000 × 2000, usando los primeros 2000 números para llenar la primera fila (secuencialmente ), los siguientes 2000 números para llenar la segunda fila, y así sucesivamente.
|
||||
|
||||
Finalmente, encuentre la mayor suma de (cualquier número de) entradas adyacentes en cualquier dirección (horizontal, vertical, diagonal o anti-diagonal).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler149()</code> debe devolver 52852124.
|
||||
testString: 'assert.strictEqual(euler149(), 52852124, "<code>euler149()</code> should return 52852124.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler149() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler149();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,74 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f37b1000cf542c50fe8e
|
||||
challengeType: 5
|
||||
title: 'Problem 15: Lattice paths'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Comenzando en la esquina superior izquierda de una cuadrícula de 2 × 2, y solo pudiendo moverse hacia la derecha y hacia abajo, hay exactamente 6 rutas hacia la esquina inferior derecha.
|
||||
|
||||
<img class="img-responsive center-block" alt="un diagrama de 6 cuadrículas de 2 por 2 que muestra todas las rutas hacia la esquina inferior derecha" src="https://i.imgur.com/1Atixoj.gif">
|
||||
|
||||
¿Cuántas de estas rutas hay a través de un <code>gridSize</code> dado?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>latticePaths(4)</code> debe devolver 70.
|
||||
testString: 'assert.strictEqual(latticePaths(4), 70, "<code>latticePaths(4)</code> should return 70.");'
|
||||
- text: <code>latticePaths(9)</code> debe devolver 48620.
|
||||
testString: 'assert.strictEqual(latticePaths(9), 48620, "<code>latticePaths(9)</code> should return 48620.");'
|
||||
- text: <code>latticePaths(20)</code> debe devolver 137846528820.
|
||||
testString: 'assert.strictEqual(latticePaths(20), 137846528820, "<code>latticePaths(20)</code> should return 137846528820.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function latticePaths(gridSize) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
latticePaths(4);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function latticePaths(gridSize) {
|
||||
let paths = 1;
|
||||
|
||||
for (let i = 0; i < gridSize; i++) {
|
||||
paths *= (2 * gridSize) - i;
|
||||
paths /= i + 1;
|
||||
}
|
||||
return paths;
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,81 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4031000cf542c50ff15
|
||||
challengeType: 5
|
||||
title: 'Problem 150: Searching a triangular array for a sub-triangle having minimum-sum'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En una matriz triangular de enteros positivos y negativos, deseamos encontrar un sub-triángulo tal que la suma de los números que contiene sea la más pequeña posible.
|
||||
En el siguiente ejemplo, se puede verificar fácilmente que el triángulo marcado cumple esta condición con una suma de −42.
|
||||
|
||||
|
||||
Queremos hacer una matriz triangular con mil filas, por lo que generamos 500500 números pseudoaleatorios sk en el rango ± 219, utilizando un tipo de generador de números aleatorios (conocido como un generador lineal congruente) como sigue:
|
||||
t: = 0
|
||||
|
||||
para k = 1 hasta k = 500500:
|
||||
|
||||
t: = (615949 * t + 797807) módulo 220
|
||||
sk: = t − 219
|
||||
Por lo tanto: s1 = 273519, s2 = −153582, s3 = 450905, etc.
|
||||
Nuestra matriz triangular se forma entonces utilizando los números pseudoaleatorios:
|
||||
|
||||
s1
|
||||
s2 s3
|
||||
s4 s5 s6
|
||||
|
||||
s7 s8 s9 s10
|
||||
...
|
||||
|
||||
sub-triángulos pueden comenzar en cualquier elemento del Arregle y extienda hacia abajo todo lo que queramos (tomando los dos elementos directamente debajo de la siguiente fila, los tres elementos directamente debajo de la fila después de eso, y así sucesivamente).
|
||||
|
||||
La "suma de un sub-triángulo" se define como la suma de todos los elementos que contiene.
|
||||
|
||||
Encuentra la suma de sub-triángulos más pequeña posible.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler150()</code> debe devolver -271248680.
|
||||
testString: 'assert.strictEqual(euler150(), -271248680, "<code>euler150()</code> should return -271248680.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler150() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler150();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4031000cf542c50ff16
|
||||
challengeType: 5
|
||||
title: 'Problem 151: Paper sheets of standard sizes: an expected-value problem'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un taller de impresión ejecuta 16 lotes (trabajos) cada semana y cada lote requiere una hoja de papel especial a prueba de color de tamaño A5.
|
||||
Cada lunes por la mañana, el capataz abre un sobre nuevo, que contiene una hoja grande de papel especial con tamaño A1.
|
||||
A continuación procede a cortarlo por la mitad, consiguiendo así dos hojas de tamaño A2. Luego corta uno de ellos por la mitad para obtener dos hojas de tamaño A3 y así sucesivamente hasta que obtenga la hoja de tamaño A5 necesaria para el primer lote de la semana.
|
||||
Todas las hojas no utilizadas se colocan de nuevo en el sobre.
|
||||
|
||||
Al comienzo de cada lote posterior, toma del sobre una hoja de papel al azar. Si es de tamaño A5, lo usa. Si es más grande, repite el procedimiento de "cortar por la mitad" hasta que tenga lo que necesita y las hojas restantes se vuelvan a colocar en el sobre.
|
||||
Excluyendo el primer y último lote de la semana, encuentre el número esperado de veces (durante cada semana) en que el capataz encuentra una sola hoja de papel en el sobre.
|
||||
Da tu respuesta redondeada a seis lugares decimales usando el formato x.xxxxxx.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler151()</code> debe devolver 0.464399.
|
||||
testString: 'assert.strictEqual(euler151(), 0.464399, "<code>euler151()</code> should return 0.464399.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler151() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler151();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4041000cf542c50ff17
|
||||
challengeType: 5
|
||||
title: 'Problem 152: Writing one half as a sum of inverse squares'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hay varias formas de escribir el número 1/2 como una suma de cuadrados inversos usando enteros distintos.
|
||||
Por ejemplo, se pueden usar los números {2,3,4,5,7,12,15,20,28,35}:
|
||||
|
||||
De hecho, solo se utilizan números enteros entre 2 y 45 inclusive, hay exactamente tres formas para hacerlo, los dos restantes son: {2,3,4,6,7,9,10,20,28,35,36,45} y {2,3,4,6,7,9,12, 15,28,30,35,36,45}.
|
||||
¿De cuántas maneras hay para escribir el número 1/2 como una suma de cuadrados inversos usando enteros distintos entre 2 y 80 inclusive?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler152()</code> debe devolver 301.
|
||||
testString: 'assert.strictEqual(euler152(), 301, "<code>euler152()</code> should return 301.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler152() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler152();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,100 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4051000cf542c50ff18
|
||||
challengeType: 5
|
||||
title: 'Problem 153: Investigating Gaussian Integers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Como todos sabemos, la ecuación x2 = -1 no tiene soluciones para x real.
|
||||
|
||||
Si, sin embargo, introducimos el número imaginario i, esta ecuación tiene dos soluciones: x = i y x = -i.
|
||||
|
||||
Si vamos un paso más allá, la ecuación (x-3) 2 = -4 tiene dos soluciones complejas: x = 3 + 2i y x = 3-2i.
|
||||
x = 3 + 2i y x = 3-2i se llaman el conjugado complejo de cada uno.
|
||||
|
||||
números de la forma a + bi se denominan números complejos.
|
||||
|
||||
En general, a + bi y a − bi son complejos conjugados entre sí.
|
||||
Un entero gaussiano es un número complejo a + bi tal que a y b son enteros.
|
||||
|
||||
Los enteros regulares también son enteros gaussianos (con b = 0).
|
||||
|
||||
Para distinguirlos de los enteros gaussianos con b ≠ 0 los llamamos "enteros racionales".
|
||||
|
||||
Un entero gaussiano se llama divisor de un entero racional n si el resultado es también un entero gaussiano.
|
||||
|
||||
Si, por ejemplo, dividimos 5 por 1 + 2i, podemos simplificar de la siguiente manera:
|
||||
|
||||
Multiplica el numerador y el denominador por el complejo conjugado de 1 + 2i: 1−2i.
|
||||
|
||||
El resultado es
|
||||
.
|
||||
|
||||
Entonces 1 + 2i es un divisor de 5.
|
||||
|
||||
Ten en cuenta que 1 + i no es un divisor de 5 porque.
|
||||
|
||||
Tenga en cuenta también que si el entero gaussiano (a + bi) es un divisor de un entero racional n, entonces su conjugado complejo (a-bi) también es un divisor de n.
|
||||
De hecho, 5 tiene seis divisores, por lo que la parte real es positiva: {1, 1 + 2i, 1 - 2i, 2 + i, 2 - i, 5}.
|
||||
|
||||
La siguiente es una tabla de todos los divisores para los primeros cinco enteros racionales positivos:
|
||||
|
||||
n divisores enteros gaussianos
|
||||
con partSum real s (n) de estos
|
||||
|
||||
divisores111
|
||||
21, 1 + i, 1-i , 25
|
||||
31, 34
|
||||
41, 1 + i, 1-i, 2, 2 + 2i, 2-2i, 413
|
||||
51, 1 + 2i, 1-2i, 2 + i, 2-i, 512
|
||||
Para Divisores con partes reales positivas, entonces, tenemos:.
|
||||
Para 1 ≤ n ≤ 105, ∑ s (n) = 17924657155.
|
||||
¿Qué es ∑ s (n) para 1 ≤ n ≤ 108?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler153()</code> debe devolver 17971254122360636.
|
||||
testString: 'assert.strictEqual(euler153(), 17971254122360636, "<code>euler153()</code> should return 17971254122360636.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler153() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler153();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4071000cf542c50ff19
|
||||
challengeType: 5
|
||||
title: 'Problem 154: Exploring Pascal"s pyramid'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se construye una pirámide triangular usando bolas esféricas de modo que cada bola reposa exactamente en tres bolas del siguiente nivel inferior.
|
||||
|
||||
Luego, calculamos el número de caminos que van desde el vértice a cada posición:
|
||||
Un camino comienza en el vértice y avanza hacia abajo a cualquiera de las tres esferas directamente debajo de la posición actual.
|
||||
En consecuencia, el número de caminos para alcanzar una determinada posición es la suma de los números inmediatamente superiores (según la posición, hay hasta tres números por encima).
|
||||
El resultado es la pirámide de Pascal y los números en cada nivel n son los coeficientes de la expansión trinomial
|
||||
(x + y + z) n.
|
||||
¿Cuántos coeficientes en la expansión de (x + y + z) 200000 son múltiplos de 1012?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler154()</code> debe devolver 479742450.
|
||||
testString: 'assert.strictEqual(euler154(), 479742450, "<code>euler154()</code> should return 479742450.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler154() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler154();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4081000cf542c50ff1a
|
||||
challengeType: 5
|
||||
title: 'Problem 155: Counting Capacitor Circuits'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un circuito eléctrico utiliza exclusivamente condensadores idénticos del mismo valor C.
|
||||
|
||||
Los condensadores se pueden conectar en serie o en paralelo para formar subunidades, que luego se pueden conectar en serie o en paralelo con otros condensadores u otras subunidades para formar subunidades más grandes, y así sucesivamente hasta un circuito final.
|
||||
Usando este procedimiento simple y hasta n capacitores idénticos, podemos hacer circuitos que tengan un rango de diferentes capacitancias totales. Por ejemplo, usando hasta n = 3 capacitores de 60 F cada uno, podemos obtener los siguientes 7 valores de capacitancia total distintos:
|
||||
|
||||
Si denotamos con D (n) el número de valores de capacitancia total distintos que podemos obtener cuando se usa hasta En los capacitores de igual valor y el procedimiento simple descrito anteriormente, tenemos: D (1) = 1, D (2) = 3, D (3) = 7 ...
|
||||
Encuentre D (18).
|
||||
Recordatorio: cuando se conectan los condensadores C1, C2, etc. en paralelo, la capacitancia total es CT = C1 + C2 + ...,
|
||||
|
||||
mientras que al conectarlos en serie, la capacitancia total viene dada por:
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler155()</code> debe devolver 3857447.
|
||||
testString: 'assert.strictEqual(euler155(), 3857447, "<code>euler155()</code> should return 3857447.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler155() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler155();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,88 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4091000cf542c50ff1b
|
||||
challengeType: 5
|
||||
title: 'Problem 156: Counting Digits'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Comenzando desde cero, los números naturales se escriben en la base 10 de esta manera:
|
||||
|
||||
0 1 2 3 4 5 6 7 8 9 10 11 12 ....
|
||||
|
||||
Considera el dígito d = 1. Después de anotar cada número n, actualizaremos el número de los que se han producido y llamaremos a este número f (n, 1). Los primeros valores para f (n, 1), entonces, son los siguientes:
|
||||
|
||||
nf (n, 1)
|
||||
00
|
||||
11
|
||||
21
|
||||
31
|
||||
41
|
||||
51
|
||||
61
|
||||
71
|
||||
81
|
||||
91
|
||||
102
|
||||
114
|
||||
125
|
||||
|
||||
Tenga en cuenta que f (n, 1) nunca es igual a 3.
|
||||
|
||||
Así que las dos primeras soluciones de la ecuación f (n, 1) = n son n = 0 y n = 1. La siguiente solución es n = 199981.
|
||||
De la misma manera, la función f (n, d) da el número total de dígitos d que se han escrito después de que se haya escrito el número n.
|
||||
|
||||
De hecho, para cada dígito d ≠ 0, 0 es la primera solución de la ecuación f (n, d) = n.
|
||||
Sea s (d) la suma de todas las soluciones para las cuales f (n, d) = n.
|
||||
|
||||
Te dan que s (1) = 22786974071.
|
||||
Encuentre ∑ s (d) para 1 ≤ d ≤ 9.
|
||||
Nota: si, para algunos n, f (n, d) = n
|
||||
para más de un valor de d, este valor de n se cuenta de nuevo para cada valor de d para el cual f (n, d) = n.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler156()</code> debe devolver 21295121502550.
|
||||
testString: 'assert.strictEqual(euler156(), 21295121502550, "<code>euler156()</code> should return 21295121502550.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler156() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler156();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,78 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4091000cf542c50ff1c
|
||||
challengeType: 5
|
||||
title: 'Problem 157: Solving the diophantine equation'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere la ecuación diofantina 1 / a + 1 / b = p / 10n con a, b, p, n enteros positivos y a ≤ b.
|
||||
Para n = 1 esta ecuación tiene 20 soluciones que se enumeran a continuación:
|
||||
1/1 + 1/1 = 20/10
|
||||
1/1 + 1/2 = 15/10
|
||||
1/1 + 1/5 = 12 / 10
|
||||
1/1 + 1/10 = 11/10
|
||||
1/2 + 1/2 = 10/10
|
||||
1/2 + 1/5 = 7/10
|
||||
1/2 + 1/10 = 6/10
|
||||
1/3 + 1/6 = 5/10
|
||||
1/3 + 1/15 = 4/10
|
||||
1/4 + 1/4 = 5/10
|
||||
1/4 + 1/20 = 3/10
|
||||
1 / 5 + 1/5 = 4/10
|
||||
1/5 + 1/10 = 3/10
|
||||
1/6 + 1/30 = 2/10
|
||||
1/10 + 1/10 = 2/10
|
||||
1/11 + 1/110 = 1/10
|
||||
1/12 + 1/60 = 1/10
|
||||
1/14 + 1/35 = 1/10
|
||||
1/15 + 1/30 = 1/10
|
||||
1/20 + 1 / 20 = 1/10
|
||||
¿Cuántas soluciones tiene esta ecuación para 1 ≤ n ≤ 9?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler157()</code> debe devolver 53490.
|
||||
testString: 'assert.strictEqual(euler157(), 53490, "<code>euler157()</code> should return 53490.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler157() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler157();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f40a1000cf542c50ff1d
|
||||
challengeType: 5
|
||||
title: 'Problem 158: Exploring strings for which only one character comes lexicographically after its neighbour to the left'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tomando tres letras diferentes de las 26 letras del alfabeto, se pueden formar cadenas de caracteres de longitud tres.
|
||||
ejemplos son 'abc', 'hat' y 'zyx'.
|
||||
Cuando estudiamos estos tres ejemplos, vemos que para 'abc' dos personajes vienen lexicográficamente después de su vecino a la izquierda.
|
||||
Para 'hat' hay exactamente un personaje que viene lexicográficamente después de su vecino a la izquierda. Para 'zyx' hay cero caracteres que vienen lexicográficamente después de su vecino a la izquierda.
|
||||
En total, hay 10400 cadenas de longitud 3 para las cuales exactamente un personaje viene lexicográficamente después de su vecino a la izquierda.
|
||||
Ahora consideramos cadenas de n ≤ 26 caracteres diferentes del alfabeto.
|
||||
Para cada n, p (n) es el número de cadenas de longitud n para las cuales exactamente un personaje aparece lexicográficamente después de su vecino a la izquierda.
|
||||
¿Cuál es el valor máximo de p (n)?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler158()</code> debe devolver 409511334375.
|
||||
testString: 'assert.strictEqual(euler158(), 409511334375, "<code>euler158()</code> should return 409511334375.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler158() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler158();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,81 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f40c1000cf542c50ff1e
|
||||
challengeType: 5
|
||||
title: 'Problem 159: Digital root sums of factorisations'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un número compuesto puede ser factorizado de muchas maneras diferentes.
|
||||
Por ejemplo, sin incluir la multiplicación por uno, 24 se puede factorizar de 7 formas distintas:
|
||||
|
||||
24 = 2x2x2x3
|
||||
24 = 2x3x4
|
||||
24 = 2x2x6
|
||||
24 = 4x6
|
||||
24 = 3x8
|
||||
24 = 2x12
|
||||
24 = 24
|
||||
|
||||
Recuerde que la raíz digital de un número, en la base 10, se encuentra sumando los dígitos de ese número,
|
||||
y repitiendo ese proceso hasta que se llega a un número que es menor que 10.
|
||||
Por lo tanto, la raíz digital de 467 es 8 .
|
||||
Llamaremos a una Suma de Raíz Digital (DRS) la suma de las raíces digitales de los factores individuales de nuestro número.
|
||||
La siguiente tabla muestra todos los valores de DRS para 24.
|
||||
FactorizaciónDirigital Root Sum2x2x2x3
|
||||
92x3x4
|
||||
92x2x6
|
||||
104x6
|
||||
103x8
|
||||
112x12
|
||||
524
|
||||
6La suma máxima de la raíz digital de 24 es 11.
|
||||
La función mdrs (n) da el máximo Root Digital Suma de n. Entonces mdrs (24) = 11.
|
||||
Encuentra ∑mdrs (n) para 1 <n <1,000,000.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler159()</code> debe devolver 14489159.
|
||||
testString: 'assert.strictEqual(euler159(), 14489159, "<code>euler159()</code> should return 14489159.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler159() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler159();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,90 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f37d1000cf542c50fe8f
|
||||
challengeType: 5
|
||||
title: 'Problem 16: Power digit sum'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
2 <sup>15</sup> = 32768 y la suma de sus dígitos es 3 + 2 + 7 + 6 + 8 = 26.
|
||||
¿Cuál es la suma de los dígitos del <sup><code>exponent</code></sup> número 2?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>powerDigitSum(15)</code> debe devolver 26.
|
||||
testString: 'assert.strictEqual(powerDigitSum(15), 26, "<code>powerDigitSum(15)</code> should return 26.");'
|
||||
- text: <code>powerDigitSum(128)</code> debe devolver 166.
|
||||
testString: 'assert.strictEqual(powerDigitSum(128), 166, "<code>powerDigitSum(128)</code> should return 166.");'
|
||||
- text: <code>powerDigitSum(1000)</code> debe devolver 1366.
|
||||
testString: 'assert.strictEqual(powerDigitSum(1000), 1366, "<code>powerDigitSum(1000)</code> should return 1366.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function powerDigitSum(exponent) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
powerDigitSum(15);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function powerDigitSum(exponent) {
|
||||
const bigNum = [1];
|
||||
let sum = 0;
|
||||
|
||||
for (let i = 1; i <= exponent; i++) {
|
||||
let count = bigNum.length + 1;
|
||||
let overflow = 0;
|
||||
for (let j = 0; j < count; j++) {
|
||||
let digit = bigNum[j] || 0;
|
||||
digit = 2 * digit + overflow;
|
||||
|
||||
if (digit > 9) {
|
||||
digit -= 10;
|
||||
overflow = 1;
|
||||
} else {
|
||||
overflow = 0;
|
||||
}
|
||||
|
||||
bigNum[j] = digit;
|
||||
}
|
||||
}
|
||||
|
||||
bigNum.forEach(function(num) {
|
||||
return sum += num;
|
||||
});
|
||||
|
||||
return sum;
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f40d1000cf542c50ff1f
|
||||
challengeType: 5
|
||||
title: 'Problem 160: Factorial trailing digits'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para cualquier N, sea f (N) los últimos cinco dígitos antes de los ceros finales en N !.
|
||||
Por ejemplo,
|
||||
9! = 362880 entonces f (9) = 36288
|
||||
10! = 3628800 entonces f (10) = 36288
|
||||
20! = 2432902008176640000 entonces f (20) = 17664
|
||||
Encuentre f (1,000,000,000,000)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler160()</code> debe devolver 16576.
|
||||
testString: 'assert.strictEqual(euler160(), 16576, "<code>euler160()</code> should return 16576.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler160() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler160();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,70 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f40d1000cf542c50ff20
|
||||
challengeType: 5
|
||||
title: 'Problem 161: Triominoes'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un triomino es una forma que consiste en tres cuadrados unidos por los bordes.
|
||||
Hay dos formas básicas:
|
||||
|
||||
|
||||
|
||||
Si se tienen en cuenta todas las orientaciones posibles, hay seis:
|
||||
|
||||
|
||||
|
||||
Cualquier cuadrícula n por m para la cual nxm es divisible por 3 se puede combinar con triominoes.
|
||||
Si consideramos las inclinaciones que pueden obtenerse por reflexión o rotación de otro mosaico, hay 41 formas diferentes de cuadrícula de 2 por 9 con triominoes:
|
||||
|
||||
|
||||
|
||||
¿De cuántas maneras se puede combinar una cuadrícula de 9 por 12 De esta manera por los triominos?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler161()</code> debe devolver 20574308184277972.
|
||||
testString: 'assert.strictEqual(euler161(), 20574308184277972, "<code>euler161()</code> should return 20574308184277972.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler161() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler161();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f40e1000cf542c50ff21
|
||||
challengeType: 5
|
||||
title: 'Problem 162: Hexadecimal numbers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En el número hexadecimal, los números del sistema se representan con 16 dígitos diferentes:
|
||||
0,1,2,3,4,5,6,7,8,9, A, B, C, D, E, F
|
||||
El número hexadecimal AF cuando está escrito en el sistema numérico decimal es igual a 10x16 + 15 = 175.
|
||||
En los números hexadecimales de 3 dígitos 10A, 1A0, A10 y A01, todos los dígitos 0,1 y A están presentes.
|
||||
Números similares escritos en base diez, escribimos números hexadecimales sin ceros iniciales.
|
||||
¿Cuántos números hexadecimales que contienen un máximo de dieciséis dígitos hexadecimales existen con todos los dígitos 0,1 y A presente al menos una vez?
|
||||
Da tu respuesta como un número hexadecimal.
|
||||
(A, B, C, D, E y F en mayúsculas, sin ningún código inicial o final que marque el número como hexadecimal y sin ceros iniciales, por ejemplo, 1A3F y no: 1a3f y no 0x1a3f y no $ 1A3F y no # 1A3F y no 0000001A3F)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler162()</code> debe devolver 3D58725572C62302.
|
||||
testString: 'assert.strictEqual(euler162(), 3D58725572C62302, "<code>euler162()</code> should return 3D58725572C62302.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler162() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler162();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f40f1000cf542c50ff22
|
||||
challengeType: 5
|
||||
title: 'Problem 163: Cross-hatched triangles'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere un triángulo equilátero en el que se dibujan líneas rectas desde cada vértice hasta la mitad del lado opuesto, como en el triángulo de tamaño 1 en el boceto a continuación.
|
||||
|
||||
Dieciséis triángulos de diferente forma, tamaño, orientación o ubicación ahora se pueden observar en ese triángulo. Usando triángulos de tamaño 1 como bloques de construcción, se pueden formar triángulos más grandes, como el triángulo de tamaño 2 en el boceto de arriba. Ciento cuatro triángulos de diferente forma o tamaño o orientación o ubicación ahora se pueden observar en ese tamaño 2 triángulo.
|
||||
Se puede observar que el triángulo de tamaño 2 contiene 4 bloques de construcción de triángulo de tamaño 1. Un triángulo de tamaño 3 contendría 9 bloques de construcción de triángulo de tamaño 1 y un triángulo de tamaño n contendría n2 bloques de construcción de triángulo de tamaño 1.
|
||||
Si denotamos T (n) como el número de triángulos presentes en un triángulo de tamaño n, entonces
|
||||
T (1) = 16
|
||||
T (2) = 104
|
||||
Encuentre T (36).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler163()</code> debe devolver 343047.
|
||||
testString: 'assert.strictEqual(euler163(), 343047, "<code>euler163()</code> should return 343047.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler163() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler163();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4111000cf542c50ff23
|
||||
challengeType: 5
|
||||
title: 'Problem 164: Numbers for which no three consecutive digits have a sum greater than a given value'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
¿Cuántos números de 20 dígitos n (sin ningún cero inicial) existen de modo que no haya tres dígitos consecutivos de n que tengan una suma mayor que 9?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler164()</code> debe devolver 378158756814587.
|
||||
testString: 'assert.strictEqual(euler164(), 378158756814587, "<code>euler164()</code> should return 378158756814587.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler164() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler164();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,73 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4111000cf542c50ff24
|
||||
challengeType: 5
|
||||
title: 'Problem 165: Intersections'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un segmento está definido de forma única por sus dos puntos finales. Al considerar dos segmentos de línea en la geometría plana, hay tres posibilidades:
|
||||
los segmentos tienen cero puntos, un punto o infinitos puntos en común.
|
||||
Además, cuando dos segmentos tienen exactamente un punto en común, puede darse el caso de que ese punto común sea un punto final de uno de los segmentos o de ambos. Si un punto común de dos segmentos no es un punto final de cualquiera de los segmentos, es un punto interior de ambos segmentos.
|
||||
Llamaremos a un punto común T de dos segmentos L1 y L2 un verdadero punto de intersección de L1 y L2 si T es el único punto común de L1 y L2 y T es un punto interior de ambos segmentos.
|
||||
|
||||
Considere los tres segmentos L1, L2 y L3:
|
||||
L1: (27, 44) a (12, 32)
|
||||
L2: (46, 53) a (17, 62)
|
||||
L3: (46, 70) a (22, 40)
|
||||
Se puede verificar que los segmentos de línea L2 y L3 tienen un verdadero punto de intersección. Notamos que como uno de los puntos finales de L3: (22,40) se encuentra en L1, esto no se considera un verdadero punto de intersección. L1 y L2 no tienen un punto común. Entonces, entre los tres segmentos de línea, encontramos un verdadero punto de intersección.
|
||||
Ahora hagamos lo mismo para 5000 segmentos de línea. Para este fin, generamos 20000 números utilizando el llamado generador de números pseudoaleatorios llamado "Blum Blum Shub".
|
||||
s0 = 290797
|
||||
sn + 1 = sn × sn (modulo 50515093)
|
||||
tn = sn (modulo 500)
|
||||
Para crear cada segmento de línea, usamos cuatro números consecutivos tn. Es decir, el primer segmento de línea viene dado por:
|
||||
(t1, t2) a (t3, t4)
|
||||
Los primeros cuatro números calculados de acuerdo con el generador anterior deberían ser: 27, 144, 12 y 232. El primer segmento sería, por lo tanto Ser (27,144) a (12,232).
|
||||
¿Cuántos puntos de intersección verdaderos distintos se encuentran entre los 5000 segmentos de línea?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler165()</code> debe devolver 2868868.
|
||||
testString: 'assert.strictEqual(euler165(), 2868868, "<code>euler165()</code> should return 2868868.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler165() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler165();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4131000cf542c50ff25
|
||||
challengeType: 5
|
||||
title: 'Problem 166: Criss Cross'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Una cuadrícula 4x4 se llena con los dígitos d, 0 ≤ d ≤ 9.
|
||||
|
||||
Se puede ver que en la cuadrícula
|
||||
|
||||
|
||||
6 3 3 0
|
||||
5 0 4 3
|
||||
0 7 1 4
|
||||
1 2 4 5
|
||||
|
||||
la suma de cada fila y cada columna tiene el valor 12. Además, la suma de cada diagonal también es 12.
|
||||
|
||||
¿De cuántas maneras puedes llenar una cuadrícula de 4x4 con los dígitos d, 0 ≤ d ≤ 9 para que cada fila, Cada columna, y ambas diagonales tienen la misma suma?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler166()</code> debe devolver 7130034.
|
||||
testString: 'assert.strictEqual(euler166(), 7130034, "<code>euler166()</code> should return 7130034.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler166() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler166();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4141000cf542c50ff26
|
||||
challengeType: 5
|
||||
title: 'Problem 167: Investigating Ulam sequences'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para dos enteros positivos a y b, la secuencia Ulam U (a, b) se define por U (a, b) 1 = a, U (a, b) 2 = by para k> 2,
|
||||
U (a , b) k es el entero más pequeño mayor que U (a, b) (k-1) que puede escribirse exactamente de una manera como la suma de dos miembros anteriores distintos de U (a, b).
|
||||
Por ejemplo, la secuencia U (1,2) comienza con
|
||||
1, 2, 3 = 1 + 2, 4 = 1 + 3, 6 = 2 + 4, 8 = 2 + 6, 11 = 3 + 8;
|
||||
5 no le pertenece porque 5 = 1 + 4 = 2 + 3 tiene dos representaciones como la suma de dos miembros anteriores, del mismo modo 7 = 1 + 6 = 3 + 4.
|
||||
Encuentra ∑U (2,2n + 1) k para 2 ≤ n ≤10, donde k = 1011.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler167()</code> debe devolver 3916160068885.
|
||||
testString: 'assert.strictEqual(euler167(), 3916160068885, "<code>euler167()</code> should return 3916160068885.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler167() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler167();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4151000cf542c50ff27
|
||||
challengeType: 5
|
||||
title: 'Problem 168: Number Rotations'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere el número 142857. Podemos rotar a la derecha este número moviendo el último dígito (7) hacia el frente, dándonos 714285.
|
||||
Se puede verificar que 714285 = 5 × 142857.
|
||||
Esto demuestra una propiedad inusual de 142857: es un divisor de su rotación hacia la derecha.
|
||||
Encuentre los últimos 5 dígitos de la suma de todos los enteros n, 10 <n <10100, que tienen esta propiedad.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler168()</code> debe devolver 59206.
|
||||
testString: 'assert.strictEqual(euler168(), 59206, "<code>euler168()</code> should return 59206.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler168() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler168();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4151000cf542c50ff28
|
||||
challengeType: 5
|
||||
title: 'Problem 169: Exploring the number of different ways a number can be expressed as a sum of powers of 2'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Defina f (0) = 1 y f (n) para que sea el número de formas diferentes en que n puede expresarse como una suma de potencias enteras de 2 utilizando cada potencia no más de dos veces.
|
||||
Por ejemplo, f (10) = 5 ya que hay cinco formas diferentes de expresar 10:
|
||||
1 + 1 + 8
|
||||
1 + 1 + 4 + 41 + 1 + 2 + 2 + 4
|
||||
2 + 4 + 4
|
||||
2 + 8
|
||||
¿Qué es f (1025)?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler169()</code> debe devolver 178653872807.
|
||||
testString: 'assert.strictEqual(euler169(), 178653872807, "<code>euler169()</code> should return 178653872807.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler169() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler169();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,135 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f37d1000cf542c50fe90
|
||||
challengeType: 5
|
||||
title: 'Problem 17: Number letter counts'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Si los números del 1 al 5 están escritos en palabras: uno, dos, tres, cuatro, cinco, entonces hay 3 + 3 + 5 + 4 + 4 = 19 letras usadas en total.
|
||||
Si todos los números desde 1 hasta el <code>limit</code> especificado se escribieran en palabras, ¿cuántas letras se usarían?
|
||||
<b>NOTA:</b> No cuente espacios o guiones. Por ejemplo, 342 (trescientos cuarenta y dos) contiene 23 letras y 115 (ciento quince) contiene 20 letras. El uso de "y" al escribir números cumple con el uso británico.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>numberLetterCounts(5)</code> debe devolver 19.
|
||||
testString: 'assert.strictEqual(numberLetterCounts(5), 19, "<code>numberLetterCounts(5)</code> should return 19.");'
|
||||
- text: <code>numberLetterCounts(150)</code> debe devolver 1903.
|
||||
testString: 'assert.strictEqual(numberLetterCounts(150), 1903, "<code>numberLetterCounts(150)</code> should return 1903.");'
|
||||
- text: <code>numberLetterCounts(1000)</code> debe devolver 21124.
|
||||
testString: 'assert.strictEqual(numberLetterCounts(1000), 21124, "<code>numberLetterCounts(1000)</code> should return 21124.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function numberLetterCounts(limit) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
numberLetterCounts(5);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function numberLetterCounts(limit) {
|
||||
const dictionary = {
|
||||
0: ",
|
||||
1: 'one',
|
||||
2: 'two',
|
||||
3: 'three',
|
||||
4: 'four',
|
||||
5: 'five',
|
||||
6: 'six',
|
||||
7: 'seven',
|
||||
8: 'eight',
|
||||
9: 'nine',
|
||||
10: 'ten',
|
||||
11: 'eleven',
|
||||
12: 'twelve',
|
||||
13: 'thirteen',
|
||||
14: 'fourteen',
|
||||
15: 'fifteen',
|
||||
16: 'sixteen',
|
||||
17: 'seventeen',
|
||||
18: 'eighteen',
|
||||
19: 'nineteen',
|
||||
20: 'twenty',
|
||||
30: 'thirty',
|
||||
40: 'forty',
|
||||
50: 'fifty',
|
||||
60: 'sixty',
|
||||
70: 'seventy',
|
||||
80: 'eighty',
|
||||
90: 'ninety',
|
||||
1000: 'onethousand'
|
||||
};
|
||||
|
||||
let numString = ";
|
||||
|
||||
function convertToString(num) {
|
||||
// check dictionary for number
|
||||
if (dictionary[num]) {
|
||||
return dictionary[num];
|
||||
} else {
|
||||
const hundreds = Math.floor(num / 100);
|
||||
const tens = Math.floor((num / 10) % 10) * 10;
|
||||
const remainder = num % 10;
|
||||
|
||||
let tempStr = ";
|
||||
|
||||
if (hundreds === 0) {
|
||||
tempStr += dictionary[tens] + dictionary[remainder];
|
||||
} else {
|
||||
tempStr += dictionary[hundreds] + 'hundred';
|
||||
|
||||
if (tens !== 0 || remainder !== 0) {
|
||||
tempStr += 'and';
|
||||
}
|
||||
|
||||
if (tens < 20) {
|
||||
const lessThanTwenty = tens + remainder;
|
||||
tempStr += dictionary[lessThanTwenty];
|
||||
} else {
|
||||
tempStr += dictionary[tens] + dictionary[remainder];
|
||||
}
|
||||
}
|
||||
// console.log(num, hundreds, tens, remainder);
|
||||
return tempStr;
|
||||
}
|
||||
}
|
||||
|
||||
for (let i = 1; i <= limit; i++) {
|
||||
numString += convertToString(i);
|
||||
}
|
||||
return numString.length;
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4161000cf542c50ff29
|
||||
challengeType: 5
|
||||
title: 'Problem 170: Find the largest 0 to 9 pandigital that can be formed by concatenating products'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tome el número 6 y multiplíquelo por cada uno de 1273 y 9854:
|
||||
|
||||
6 × 1273 = 7638
|
||||
6 × 9854 = 59124
|
||||
|
||||
Al concatenar estos productos, obtenemos del 1 al 9 pandigital 763859124. Llamaremos 763859124 al "concatenado". Producto de 6 y (1273,9854) ". Observe también que la concatenación de los números de entrada, 612739854, también es de 1 a 9 pandigital.
|
||||
|
||||
Lo mismo se puede hacer para 0 a 9 números pandigitales.
|
||||
|
||||
¿Cuál es el mayor producto concatenado pandigital de 10 a 10 dígitos de un número entero con dos o más enteros más, de modo que la concatenación de los números de entrada es también un número pandigital de 0 a 9 dígitos?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler170()</code> debe devolver 9857164023.
|
||||
testString: 'assert.strictEqual(euler170(), 9857164023, "<code>euler170()</code> should return 9857164023.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler170() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler170();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4181000cf542c50ff2a
|
||||
challengeType: 5
|
||||
title: 'Problem 171: Finding numbers for which the sum of the squares of the digits is a square'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para un entero positivo n, sea f (n) la suma de los cuadrados de los dígitos (en la base 10) de n, por ejemplo,
|
||||
f (3) = 32 = 9,
|
||||
f (25) = 22 + 52 = 4 + 25 = 29,
|
||||
f (442) = 42 + 42 + 22 = 16 + 16 + 4 = 36
|
||||
Encuentre los últimos nueve dígitos de la suma de todos n, 0 <n <1020, de manera que f (n) Es un cuadrado perfecto.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler171()</code> debe devolver 142989277.
|
||||
testString: 'assert.strictEqual(euler171(), 142989277, "<code>euler171()</code> should return 142989277.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler171() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler171();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4181000cf542c50ff2b
|
||||
challengeType: 5
|
||||
title: 'Problem 172: Investigating numbers with few repeated digits'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
¿Cuántos números de 18 dígitos n (sin ceros a la izquierda) hay de tal manera que no aparezca un dígito más de tres veces en n?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler172()</code> debe devolver 227485267000992000.
|
||||
testString: 'assert.strictEqual(euler172(), 227485267000992000, "<code>euler172()</code> should return 227485267000992000.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler172() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler172();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f41a1000cf542c50ff2c
|
||||
challengeType: 5
|
||||
title: 'Problem 173: Using up to one million tiles how many different "hollow" square laminae can be formed?'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Definiremos una lámina cuadrada como un contorno cuadrado con un "orificio" cuadrado de modo que la forma posea simetría vertical y horizontal. Por ejemplo, utilizando exactamente treinta y dos baldosas cuadradas podemos formar dos láminas cuadradas diferentes:
|
||||
|
||||
|
||||
Con cien baldosas, y no necesariamente usando todas las baldosas a la vez, es posible formar cuarenta y una láminas cuadradas diferentes .
|
||||
Usando hasta un millón de baldosas, ¿cuántas láminas cuadradas diferentes se pueden formar?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler173()</code> debe devolver 1572729.
|
||||
testString: 'assert.strictEqual(euler173(), 1572729, "<code>euler173()</code> should return 1572729.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler173() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler173();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f41a1000cf542c50ff2d
|
||||
challengeType: 5
|
||||
title: 'Problem 174: Counting the number of "hollow" square laminae that can form one, two, three, ... distinct arrangements'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Definiremos una lámina cuadrada como un contorno cuadrado con un "orificio" cuadrado de modo que la forma posea simetría vertical y horizontal.
|
||||
Dadas ocho fichas es posible formar una lámina de una sola manera: cuadrado 3x3 con un orificio 1x1 en el medio. Sin embargo, utilizando treinta y dos baldosas es posible formar dos láminas distintas.
|
||||
|
||||
|
||||
Si t representa el número de mosaicos utilizados, diremos que t = 8 es el tipo L (1) y t = 32 es el tipo L (2).
|
||||
Sea N (n) el número de t ≤ 1000000, de manera que t sea tipo L (n); por ejemplo, N (15) = 832.
|
||||
¿Qué es ∑ N (n) para 1 ≤ n ≤ 10?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler174()</code> debe devolver 209566.
|
||||
testString: 'assert.strictEqual(euler174(), 209566, "<code>euler174()</code> should return 209566.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler174() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler174();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f41c1000cf542c50ff2e
|
||||
challengeType: 5
|
||||
title: 'Problem 175: Fractions involving the number of different ways a number can be expressed as a sum of powers of 2'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Defina f (0) = 1 y f (n) como el número de formas de escribir n como una suma de potencias de 2 donde no se produce potencia más de dos veces.
|
||||
|
||||
Por ejemplo, f (10) = 5 ya que hay cinco formas diferentes de expresar 10:10 = 8 + 2 = 8 + 1 + 1 = 4 + 4 + 2 = 4 + 2 + 2 + 1 + 1 = 4 + 4 + 1 + 1
|
||||
|
||||
Se puede mostrar que para cada fracción p / q (p> 0, q> 0) existe al menos un entero n tal que f (n) / f (n-1) = p / q.
|
||||
Por ejemplo, la n más pequeña para la cual f (n) / f (n-1) = 13/17 es 241.
|
||||
La expansión binaria de 241 es 11110001.
|
||||
Leyendo este número binario del bit más significativo al menos significativo Bit hay 4 de uno, 3 ceros y 1 de uno. Llamaremos a la cadena 4,3,1 la Expansión Binaria Acortada de 241.
|
||||
Halla la Expansión Binaria Acortada de la n más pequeña para la cual f (n) / f (n-1) = 123456789/987654321.
|
||||
Da tu respuesta como enteros separados por comas, sin espacios en blanco.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>euler175()</code> debe devolver 1, 13717420, 8.'
|
||||
testString: 'assert.strictEqual(euler175(), 1, 13717420, 8, "<code>euler175()</code> should return 1, 13717420, 8.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler175() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler175();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,57 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f41c1000cf542c50ff2f
|
||||
challengeType: 5
|
||||
title: 'Problem 176: Right-angled triangles that share a cathetus'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los cuatro triángulos en ángulo recto con lados (9,12,15), (12,16,20), (5,12,13) y (12,35,37) tienen uno de los lados más cortos (catheti) igual a 12. Se puede mostrar que no existe ningún otro triángulo de ángulo recto de un entero con uno de los catetos igual a 12.
|
||||
Encuentre el entero más pequeño que puede tener la longitud de un cateto de exactamente 47547 triángulos rectos con ángulo de enteros diferentes diferentes .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler176()</code> debe devolver 96818198400000.
|
||||
testString: 'assert.strictEqual(euler176(), 96818198400000, "<code>euler176()</code> should return 96818198400000.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler176() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler176();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f41e1000cf542c50ff30
|
||||
challengeType: 5
|
||||
title: 'Problem 177: Integer angled Quadrilaterals'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Deje que ABCD sea un cuadrilátero convexo, con diagonales AC y BD. En cada vértice, la diagonal forma un ángulo con cada uno de los dos lados, creando ocho ángulos de esquina.
|
||||
|
||||
Por ejemplo, en el vértice A, los dos ángulos son CAD, CAB.
|
||||
Llamamos a este cuadrilátero para el cual los ocho ángulos de las esquinas tienen valores enteros cuando se miden en grados, un "cuadrilátero en ángulo entero". Un ejemplo de un cuadrilátero en ángulo entero es un cuadrado, donde los ocho ángulos de las esquinas son 45 °. Otro ejemplo está dado por DAC = 20 °, BAC = 60 °, ABD = 50 °, CDB = 30 °, BCA = 40 °, DCA = 30 °, CDB = 80 °, ADB = 50 °.
|
||||
¿Cuál es el número total de cuadriláteros en ángulo enteros no similares?
|
||||
Nota: En sus cálculos, puede suponer que un ángulo calculado es integral si está dentro de una tolerancia de 10-9 de un valor entero.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler177()</code> debe devolver 129325.
|
||||
testString: 'assert.strictEqual(euler177(), 129325, "<code>euler177()</code> should return 129325.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler177() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler177();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f41e1000cf542c50ff31
|
||||
challengeType: 5
|
||||
title: 'Problem 178: Step Numbers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere el número 45656.
|
||||
Se puede ver que cada par de dígitos consecutivos de 45656 tiene una diferencia de uno.
|
||||
Un número para el que cada par de dígitos consecutivos tiene una diferencia de uno se llama un número de paso.
|
||||
Un número pandigital contiene cada dígito decimal de 0 a 9 al menos una vez.
|
||||
|
||||
¿Cuántos números de paso pandigital menores que 1040 hay?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler178()</code> debe devolver 126461847755.
|
||||
testString: 'assert.strictEqual(euler178(), 126461847755, "<code>euler178()</code> should return 126461847755.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler178() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler178();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f41f1000cf542c50ff32
|
||||
challengeType: 5
|
||||
title: 'Problem 179: Consecutive positive divisors'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Encuentre el número de enteros 1 <n <107, para los que n y n + 1 tienen el mismo número de divisores positivos. Por ejemplo, 14 tiene los divisores positivos 1, 2, 7, 14, mientras que 15 tiene 1, 3, 5, 15.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler179()</code> debe devolver 986262.
|
||||
testString: 'assert.strictEqual(euler179(), 986262, "<code>euler179()</code> should return 986262.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler179() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler179();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,97 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f37e1000cf542c50fe91
|
||||
challengeType: 5
|
||||
title: 'Problem 18: Maximum path sum I'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Al comenzar en la parte superior del triángulo de abajo y pasar a los números adyacentes en la fila de abajo, el total máximo de arriba a abajo es 23.
|
||||
<span style='display: block; text-align: center;'><b style='color: red;'>3</b> <br> <b style='color: red;'>7</b> 4 <br> 2 <b style='color: red;'>4</b> 6 <br> 8 5 <b style='color: red;'>9</b> 3</span>
|
||||
Es decir, 3 + 7 + 4 + 9 = 23.
|
||||
Encuentre el total máximo de arriba a abajo del triángulo a continuación:
|
||||
<span style='display: block; text-align: center;'>75 <br> 95 64 <br> 17 47 82 <br> 18 35 87 10 <br> 20 04 82 47 65 <br> 19 01 23 75 03 34 <br> 88 02 77 73 07 63 67 <br> 99 65 04 28 06 16 70 92 <br> 41 41 26 56 83 40 80 70 33 <br> 41 48 72 33 47 32 37 16 94 29 <br> 53 71 44 65 25 43 91 52 97 51 14 <br> 70 11 33 28 77 73 17 78 39 68 17 57 <br> 91 71 52 38 17 14 91 43 58 50 27 29 48 <br> 63 66 04 68 89 53 67 30 73 16 69 87 40 31 <br> 04 62 98 27 23 09 70 98 73 93 38 53 60 04 23</span>
|
||||
<b>NOTA:</b> Como solo hay 16384 rutas, es posible resolver este problema probando cada ruta. Sin embargo, el Problema 67, es el mismo desafío con un triángulo que contiene cien filas; no se puede resolver por fuerza bruta, y requiere un método inteligente! ; o)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>maximumPathSumI(testTriangle)</code> debe devolver 23.
|
||||
testString: 'assert.strictEqual(maximumPathSumI(testTriangle), 23, "<code>maximumPathSumI(testTriangle)</code> should return 23.");'
|
||||
- text: <code>maximumPathSumI(numTriangle)</code> debe devolver 1074.
|
||||
testString: 'assert.strictEqual(maximumPathSumI(numTriangle), 1074, "<code>maximumPathSumI(numTriangle)</code> should return 1074.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function maximumPathSumI(triangle) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
const testTriangle = [[3, 0, 0, 0],
|
||||
[7, 4, 0, 0],
|
||||
[2, 4, 6, 0],
|
||||
[8, 5, 9, 3]];
|
||||
|
||||
maximumPathSumI(testTriangle);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
### Before Test
|
||||
<div id='js-setup'>
|
||||
|
||||
```js
|
||||
const numTriangle = [[75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [95, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [17, 47, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [18, 35, 87, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [20, 4, 82, 47, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [19, 1, 23, 75, 3, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0], [88, 2, 77, 73, 7, 63, 67, 0, 0, 0, 0, 0, 0, 0, 0], [99, 65, 4, 28, 6, 16, 70, 92, 0, 0, 0, 0, 0, 0, 0], [41, 41, 26, 56, 83, 40, 80, 70, 33, 0, 0, 0, 0, 0, 0], [41, 48, 72, 33, 47, 32, 37, 16, 94, 29, 0, 0, 0, 0, 0], [53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14, 0, 0, 0, 0], [70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57, 0, 0, 0], [91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48, 0, 0], [63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31, 0], [4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23]];
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
const testTriangle = [[3, 0, 0, 0],
|
||||
[7, 4, 0, 0],
|
||||
[2, 4, 6, 0],
|
||||
[8, 5, 9, 3]];
|
||||
|
||||
function maximumPathSumI(triangle) {
|
||||
let maxSum = triangle.slice();
|
||||
|
||||
for (let i = triangle.length - 1; i > 0; i--) {
|
||||
let currentRow = maxSum[i];
|
||||
let previousRow = maxSum[i - 1];
|
||||
const temp = [];
|
||||
for (let j = 0; j < i; j++) {
|
||||
temp.push(Math.max((currentRow[j] + previousRow[j]), (currentRow[j + 1] + previousRow[j])));
|
||||
}
|
||||
maxSum[i - 1] = temp;
|
||||
maxSum.pop();
|
||||
}
|
||||
return maxSum[0][0];
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4201000cf542c50ff33
|
||||
challengeType: 5
|
||||
title: 'Problem 180: Rational zeros of a function of three variables'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Para cualquier entero n, considere las tres funciones
|
||||
f1, n (x, y, z) = xn + 1 + yn + 1 - zn + 1f2, n (x, y, z) = (xy + yz + zx) * (xn-1 + yn-1 - zn-1) f3, n (x, y, z) = xyz * (xn-2 + yn-2 - zn-2)
|
||||
y su combinación
|
||||
fn (x, y , z) = f1, n (x, y, z) + f2, n (x, y, z) - f3, n (x, y, z)
|
||||
Llamamos (x, y, z) un triple dorado de orden k si x, y, y z son todos números racionales de la forma a / b con
|
||||
0 <a <b ≤ k y hay (al menos) un entero n, de modo que fn (x, y, z) = 0.
|
||||
Sea s (x, y, z) = x + y + z.
|
||||
Sea t = u / v la suma de todos los s distintos (x, y, z) para todos los triples dorados (x, y, z) de orden 35. Todos los s (x, y, z) yt deben ser En forma reducida.
|
||||
Encuentra u + v.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler180()</code> debe devolver 285196020571078980.
|
||||
testString: 'assert.strictEqual(euler180(), 285196020571078980, "<code>euler180()</code> should return 285196020571078980.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler180() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler180();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4231000cf542c50ff34
|
||||
challengeType: 5
|
||||
title: 'Problem 181: Investigating in how many ways objects of two different colours can be grouped'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Teniendo tres objetos negros B y un objeto blanco W, se pueden agrupar de 7 formas como esta:
|
||||
(BBBW) (B, BBW) (B, B, BW) (B, B, B, W)
|
||||
(B, BB, W) (BBB, W) (BB, BW)
|
||||
¿De cuántas maneras se pueden agrupar sesenta objetos negros B y cuarenta objetos blancos W?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler181()</code> debe devolver 83735848679360670.
|
||||
testString: 'assert.strictEqual(euler181(), 83735848679360670, "<code>euler181()</code> should return 83735848679360670.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler181() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler181();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,71 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4231000cf542c50ff36
|
||||
challengeType: 5
|
||||
title: 'Problem 183: Maximum product of parts'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea N un entero positivo y sea N dividido en k partes iguales, r = N / k, de modo que N = r + r + ... + r.
|
||||
Sea P el producto de estas partes, P = r × r × ... × r = rk.
|
||||
|
||||
Por ejemplo, si 11 se divide en cinco partes iguales, 11 = 2.2 + 2.2 + 2.2 + 2.2 + 2.2, entonces P = 2.25 = 51.53632.
|
||||
|
||||
Sea M (N) = Pmax para un valor dado de N.
|
||||
|
||||
Resulta que el máximo para N = 11 se encuentra dividiendo once en cuatro partes iguales, lo que lleva a Pmax = (11/4) 4; es decir, M (11) = 14641/256 = 57.19140625, que es un decimal de terminación.
|
||||
|
||||
Sin embargo, para N = 8, el máximo se logra dividiéndolo en tres partes iguales, por lo que M (8) = 512/27, que es un decimal sin terminación.
|
||||
|
||||
Deje D (N) = N si M (N) es un decimal no terminado y D (N) = -N si M (N) es un decimal terminal.
|
||||
|
||||
Por ejemplo, ΣD (N) para 5 ≤ N ≤ 100 es 2438.
|
||||
|
||||
Encuentre ΣD (N) para 5 ≤ N ≤ 10000.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler183()</code> debe devolver 48861552.
|
||||
testString: 'assert.strictEqual(euler183(), 48861552, "<code>euler183()</code> should return 48861552.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler183() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler183();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4241000cf542c50ff37
|
||||
challengeType: 5
|
||||
title: 'Problem 184: Triangles containing the origin'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere el conjunto Ir de puntos (x, y) con coordenadas enteras en el interior del círculo con radio r, centrado en el origen, es decir, x2 + y2 <r2.
|
||||
Para un radio de 2, I2 contiene los nueve puntos (0,0), (1,0), (1,1), (0,1), (-1,1), (-1,0), (-1, -1), (0, -1) y (1, -1). Hay ocho triángulos con los tres vértices en I2 que contienen el origen en el interior. Dos de ellos se muestran a continuación, los otros se obtienen de estos por rotación.
|
||||
|
||||
|
||||
Para un radio de 3, hay 360 triángulos que contienen el origen en el interior y tienen todos los vértices en I3 y para I5 el número es 10600.
|
||||
|
||||
¿Cuántos triángulos hay que contienen el origen en el interior y tienen los tres ¿Vértices en I105?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler184()</code> debe devolver 1725323624056.
|
||||
testString: 'assert.strictEqual(euler184(), 1725323624056, "<code>euler184()</code> should return 1725323624056.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler184() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler184();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,93 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4251000cf542c50ff38
|
||||
challengeType: 5
|
||||
title: 'Problem 185: Number Mind'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El juego Number Mind es una variante del conocido juego Master Mind.
|
||||
En lugar de clavijas de colores, debes adivinar una secuencia secreta de dígitos. Después de cada conjetura solo se te dice en cuántos lugares has adivinado el dígito correcto. Entonces, si la secuencia era 1234 y adivinaste 2036, te dirían que tienes un dígito correcto; sin embargo, NO se le dirá que también tiene otro dígito en el lugar equivocado.
|
||||
|
||||
Por ejemplo, dadas las siguientes conjeturas para una secuencia secreta de 5 dígitos,
|
||||
90342; 2 correcta
|
||||
70794; 0 correcta
|
||||
39458; 2 correcta
|
||||
34109; 1 correcta
|
||||
51545; 2 correcta
|
||||
12531; 1 correcta
|
||||
La correcta La secuencia 39542 es única.
|
||||
|
||||
Basado en las siguientes suposiciones,
|
||||
|
||||
5616185650518293; 2 correcta
|
||||
3847439647293047; 1 correcta
|
||||
5855462940810587; 3 correcta
|
||||
9742855507068353; 3 correcta
|
||||
4296849643607543; 3 correcta
|
||||
3174248439465858; 1 correcta
|
||||
4513559094146117; 2 correcta
|
||||
7890971548908067; 3 correcta
|
||||
8157356344118483; 1 correcta
|
||||
2615250744386899; 2 correcta
|
||||
8690095851526254; 3 correcta
|
||||
6375711915077050; 1 correcta
|
||||
6913859173121360; 1 correcta
|
||||
6442889055042768; 2 correcta
|
||||
2321386104303845; 0 correcta
|
||||
2326509471271448; 2 correcta
|
||||
5251583379644322; 2 correcta
|
||||
1748270476758276; 3 correcta
|
||||
4895722652190306; 1 correcto
|
||||
3041631117224635; 3 correcto
|
||||
1841236454324589; 3 correcto
|
||||
2659862637316867; 2 correcto
|
||||
|
||||
Encuentra la secuencia secreta única de 16 dígitos.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler185()</code> debe devolver 4640261571849533.
|
||||
testString: 'assert.strictEqual(euler185(), 4640261571849533, "<code>euler185()</code> should return 4640261571849533.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler185() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler185();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4281000cf542c50ff39
|
||||
challengeType: 5
|
||||
title: 'Problem 186: Connectedness of a network'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Aquí están los registros de un sistema telefónico ocupado con un millón de usuarios:
|
||||
|
||||
RecNrCallerCalled120000710005326001835004393600863701497 .........
|
||||
El número de teléfono de la persona que llama y el número llamado en el registro n son Caller (n) = S2n-1 y Llamado (n) = S2n donde S1,2,3, ... proviene del "Generador de Fibonacci Rezagado":
|
||||
|
||||
Para 1 ≤ k ≤ 55, Sk = [100003 - 200003k + 300007k3] (módulo 1000000)
|
||||
Para 56 ≤ k, Sk = [Sk-24 + Sk-55] (módulo 1000000)
|
||||
|
||||
Si la persona que llama (n) = Called (n), se supone que el usuario ha marcado incorrectamente y la llamada falla; De lo contrario la llamada es exitosa.
|
||||
|
||||
Desde el inicio de los registros, decimos que cualquier par de usuarios X e Y son amigos si X llama a Y o viceversa. De manera similar, X es amigo de un amigo de Z si X es amigo de Y e Y es amigo de Z; y así sucesivamente para cadenas más largas.
|
||||
|
||||
El número de teléfono del Primer Ministro es 524287. ¿Después de cuántas llamadas exitosas, sin contar los errores de marcación, el 99% de los usuarios (incluido el Primer Ministro) será un amigo, o un amigo de un amigo, etc., del Primer Ministro?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler186()</code> debe devolver 2325629.
|
||||
testString: 'assert.strictEqual(euler186(), 2325629, "<code>euler186()</code> should return 2325629.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler186() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler186();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4291000cf542c50ff3a
|
||||
challengeType: 5
|
||||
title: 'Problem 187: Semiprimes'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un compuesto es un número que contiene al menos dos factores primos. Por ejemplo, 15 = 3 × 5; 9 = 3 × 3; 12 = 2 × 2 × 3.
|
||||
|
||||
Hay diez compuestos por debajo de treinta que contienen precisamente dos factores primos, no necesariamente distintos:
|
||||
4, 6, 9, 10, 14, 15, 21, 22, 25, 26.
|
||||
|
||||
¿Cuántos enteros compuestos, n <108, tienen exactamente dos factores primos, no necesariamente distintos?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler187()</code> debe devolver 17427258.
|
||||
testString: 'assert.strictEqual(euler187(), 17427258, "<code>euler187()</code> should return 17427258.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler187() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler187();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4291000cf542c50ff3b
|
||||
challengeType: 5
|
||||
title: 'Problem 188: The hyperexponentiation of a number'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La hipereexposición o tetración de un número a por un entero positivo b, denotado por ↑↑ b o ba, se define recursivamente por:
|
||||
a ↑↑ 1 = a,
|
||||
a ↑↑ (k + 1) = a (a ↑↑ k).
|
||||
|
||||
Así tenemos, por ejemplo, 3 ↑↑ 2 = 33 = 27, por lo tanto, 3 ↑↑ 3 = 327 = 7625597484987 y 3 ↑↑ 4 es aproximadamente 103.6383346400240996 * 10 ^ 12.
|
||||
Encuentra los últimos 8 dígitos de 1777 ↑↑ 1855.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler188()</code> debe devolver 95962097.
|
||||
testString: 'assert.strictEqual(euler188(), 95962097, "<code>euler188()</code> should return 95962097.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler188() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler188();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f4291000cf542c50ff3c
|
||||
challengeType: 5
|
||||
title: 'Problem 189: Tri-colouring a triangular grid'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Considere la siguiente configuración de 64 triángulos:
|
||||
|
||||
|
||||
|
||||
Deseamos colorear el interior de cada triángulo con uno de tres colores: rojo, verde o azul, para que no haya dos triángulos vecinos del mismo color. Tal coloración se llamará válida. Aquí, se dice que dos triángulos son vecinos si comparten un borde.
|
||||
Nota: si solo comparten un vértice, entonces no son vecinos.
|
||||
|
||||
Por ejemplo, aquí hay una coloración válida de la cuadrícula anterior:
|
||||
|
||||
|
||||
Una coloración C 'que se obtiene de una coloración C por rotación o reflexión se considera distinta de C a menos que las dos sean idénticas.
|
||||
|
||||
¿Cuántos colores válidos distintos hay para la configuración anterior?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler189()</code> debe devolver 10834893628237824.
|
||||
testString: 'assert.strictEqual(euler189(), 10834893628237824, "<code>euler189()</code> should return 10834893628237824.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler189() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler189();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f37f1000cf542c50fe92
|
||||
challengeType: 5
|
||||
title: 'Problem 19: Counting Sundays'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se le proporciona la siguiente información, pero es posible que prefiera hacer una investigación por sí mismo.
|
||||
<ul><li> El 1 de enero de 1900 fue un lunes. </li><li> Treinta días tiene septiembre, <br> Abril, junio y noviembre. <br> Todos los demás tienen treinta y uno, <br> Salvando febrero solo, <br> Que tiene veintiocho, llueva o truene. <br> Y en años bisiestos, veintinueve. </li><li> Un año bisiesto ocurre en cualquier año divisible por 4, pero no en un siglo a menos que sea divisible por 400. </li>
|
||||
¿Cuántos domingos cayeron el primer día del mes durante el siglo veinte (1 de enero de 1901 a 31 de diciembre de 2000)?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>countingSundays(1943, 1946)</code> debe devolver 6.'
|
||||
testString: 'assert.strictEqual(countingSundays(1943, 1946), 6, "<code>countingSundays(1943, 1946)</code> should return 6.");'
|
||||
- text: ' <code>countingSundays(1995, 2000)</code> debe devolver 9.'
|
||||
testString: 'assert.strictEqual(countingSundays(1995, 2000), 9, "<code>countingSundays(1995, 2000)</code> should return 9.");'
|
||||
- text: ' <code>countingSundays(1901, 2000)</code> debe devolver 171.'
|
||||
testString: 'assert.strictEqual(countingSundays(1901, 2000), 171, "<code>countingSundays(1901, 2000)</code> should return 171.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function countingSundays(firstYear, lastYear) {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
countingSundays(1943, 1946);
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function countingSundays(firstYear, lastYear) {
|
||||
let sundays = 0;
|
||||
|
||||
for (let year = firstYear; year <= lastYear; year++) {
|
||||
for (let month = 1; month <= 12; month++) {
|
||||
const thisDate = new Date(year, month, 1);
|
||||
if (thisDate.getDay() === 0) {
|
||||
sundays++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return sundays;
|
||||
}
|
||||
```
|
||||
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 5
|
||||
localeTitle: 5900f42b1000cf542c50ff3d
|
||||
challengeType: 5
|
||||
title: 'Problem 190: Maximising a weighted product'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea Sm = (x1, x2, ..., xm) la m-tupla de números reales positivos con x1 + x2 + ... + xm = m para la cual Pm = x1 * x22 * ... * xmm es maximizado
|
||||
|
||||
Por ejemplo, se puede verificar que [P10] = 4112 ([] es la función de la parte entera).
|
||||
|
||||
Encuentra Σ [Pm] para 2 ≤ m ≤ 15.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>euler190()</code> debe devolver 371048281.
|
||||
testString: 'assert.strictEqual(euler190(), 371048281, "<code>euler190()</code> should return 371048281.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function euler190() {
|
||||
// Good luck!
|
||||
return true;
|
||||
}
|
||||
|
||||
euler190();
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user