gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

docs: add Spanish docs

Browse Source
This commit is contained in:
Beau Carnes
2018-10-08 13:34:43 -04:00
parent 46d8d61776
commit fcced4a6c3
912 changed files with 80339 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-119-digit-power-sum.spanish.md Normal file
View File

@ -0,0 +1,59 @@
---
id: 5
localeTitle: 5900f3e41000cf542c50fef6
challengeType: 5
title: 'Problem 119: Digit power sum'
---
## Description
<section id='description'>
El número 512 es interesante porque es igual a la suma de sus dígitos elevados a alguna potencia: 5 + 1 + 2 = 8, y 83 = 512. Otro ejemplo de un número con esta propiedad es 614656 = 284.
define como el enésimo término de esta secuencia e insiste en que un número debe contener al menos dos dígitos para tener una suma.
Te dan que a2 = 512 y a10 = 614656.
Encuentra a30.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler119()</code> debe devolver 248155780267521.
testString: 'assert.strictEqual(euler119(), 248155780267521, "<code>euler119()</code> should return 248155780267521.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler119() {
// Good luck!
return true;
}
euler119();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

68
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-182-rsa-encryption.spanish.md Normal file
View File

@ -0,0 +1,68 @@
---
id: 5
localeTitle: 5900f4231000cf542c50ff35
challengeType: 5
title: 'Problem 182: RSA encryption'
---
## Description
<section id='description'>
El cifrado RSA se basa en el siguiente procedimiento:
Generar dos primos distintos p y q.Compute n = pq y φ = (p-1) (q-1).
Encuentra un entero e, 1 <e<φ, such that gcd(e,φ)=1.<code> 0 Un mensaje en este sistema es un número en el intervalo [0, n-1].
Un texto que se va a cifrar se convierte de alguna manera en mensajes (números en el intervalo [0, n-1]).
Para cifrar el texto, para cada mensaje, m, c = me mod n se calcula.
Para descifrar el texto, se necesita el siguiente procedimiento: calcular d tal que ed = 1 mod φ, luego para cada mensaje cifrado, c, calcular m = cd mod n.
Existen valores de e y m tales que me mod n = m. Llamamos mensajes m para los cuales me mod n = m mensajes no ocultos.
Un problema al elegir e es que no debe haber demasiados mensajes no ocultos. Por ejemplo, vamos a p = 19 y q = 37.
Entonces n = 19 * 37 = 703 y φ = 18 * 36 = 648.
Si elegimos e = 181, entonces, aunque gcd (181,648) = 1 resulta que todos los mensajes posibles m (0≤m≤n-1) no están ocultos al calcularme mod n.
Para cualquier elección válida de e existen algunos mensajes no ocultos.
Es importante que el número de mensajes no ocultos sea mínimo.
Elige p = 1009 y q = 3643.
Encuentra la suma de todos los valores de e, 1 <e<φ(1009,3643) and gcd(e,φ)=1, so that the number of unconcealed messages for this value of e is at a minimum.<code> 0 </section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler182()</code> debe devolver 399788195976.
testString: 'assert.strictEqual(euler182(), 399788195976, "<code>euler182()</code> should return 399788195976.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler182() {
// Good luck!
return true;
}
euler182();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

57
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-248-numbers-for-which-eulers-totient-function-equals-13.spanish.md Normal file
View File

@ -0,0 +1,57 @@
---
id: 5
localeTitle: 5900f4651000cf542c50ff77
challengeType: 5
title: 'Problem 248: Numbers for which Euler’s totient function equals 13!'
---
## Description
<section id='description'>
El primer número n para el cual φ (n) = 13! es 6227180929.
Encuentra la 150,000 de dicho número.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler248()</code> debe devolver 23507044290.
testString: 'assert.strictEqual(euler248(), 23507044290, "<code>euler248()</code> should return 23507044290.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler248() {
// Good luck!
return true;
}
euler248();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

56
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-250-250250.spanish.md Normal file
View File

@ -0,0 +1,56 @@
---
id: 5
localeTitle: 5900f4661000cf542c50ff78
challengeType: 5
title: 'Problem 250: 250250'
---
## Description
<section id='description'>
Encuentre el número de subconjuntos no vacíos de {11, 22, 33, ..., 250250250250}, la suma de cuyos elementos es divisible por 250. Ingrese los 16 dígitos más a la derecha como su respuesta.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler250()</code> debe devolver 1425480602091519.
testString: 'assert.strictEqual(euler250(), 1425480602091519, "<code>euler250()</code> should return 1425480602091519.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler250() {
// Good luck!
return true;
}
euler250();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

65
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-261-pivotal-square-sums.spanish.md Normal file
View File

@ -0,0 +1,65 @@
---
id: 5
localeTitle: 5900f4711000cf542c50ff84
challengeType: 5
title: 'Problem 261: Pivotal Square Sums'
---
## Description
<section id='description'>
Llamemos a un entero positivo ka cuadrado-pivote, si hay un par de enteros m&gt; 0 y n ≥ k, de modo que la suma de los cuadrados consecutivos (m + 1) hasta k sea igual a la suma de m consecutivos cuadrados de (n + 1) en:
(km) 2 + ... + k2 = (n + 1) 2 + ... + (n + m) 2.
Algunos pequeños pivotes cuadrados son
4: 32 + 42
= 52
21: 202 + 212 = 292
24: 212 + 222 + 232 + 242 = 252 + 262 + 272
110: 1082 + 1092 + 1102 = 1332 + 1342Encuentre la suma de todos los distintos pivotes cuadrados ≤ 1010.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler261()</code> debe devolver 238890850232021.
testString: 'assert.strictEqual(euler261(), 238890850232021, "<code>euler261()</code> should return 238890850232021.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler261() {
// Good luck!
return true;
}
euler261();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

81
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-318-2011-nines.spanish.md Normal file
View File

@ -0,0 +1,81 @@
---
id: 5
localeTitle: 5900f4ab1000cf542c50ffbd
challengeType: 5
title: 'Problem 318: 2011 nines'
---
## Description
<section id='description'>
Considera el número real √2 + √3.
Cuando calculamos las potencias pares de √2 + √3
obtenemos:
(√2 + √3) 2 = 9.898979485566356 ...
(√2 + √3) 4 = 97.98979485566356 ...
(√2 + √3) 6 = 969.998969071069263 ...
(√2 + √3) 8 = 9601.99989585502907 ...
(√2 + √3) 10 = 95049.999989479221 ...
(√2 + √3) 12 = 940897.9999989371855 .. .
(√2 + √3) 14 = 9313929.99999989263 ...
(√2 + √3) 16 = 92198401.99999998915 ...
Parece que el número de nueves consecutivas al principio de la parte fraccionaria de estas potencias No está disminuyendo.
De hecho, se puede probar que la parte fraccionaria de (√2 + √3) 2n se acerca a 1 para n grande.
Considere todos los números reales de la forma √p + √q con p y q enteros positivos yp <q, such that the fractional part<code> 0 de (√p + √q) 2n se acerca a 1 para n grande.
Sea C (p, q, n) el número de nueves consecutivas al comienzo de la parte fraccionaria de (√p + √q) 2n.
Sea N (p, q) el valor mínimo de n tal que C (p, q, n) ≥ 2011.
Encuentre ∑N (p, q) para p + q ≤ 2011.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler318()</code> debe devolver 709313889.
testString: 'assert.strictEqual(euler318(), 709313889, "<code>euler318()</code> should return 709313889.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler318() {
// Good luck!
return true;
}
euler318();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

92
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-376-nontransitive-sets-of-dice.spanish.md Normal file
View File

@ -0,0 +1,92 @@
---
id: 5
localeTitle: 5900f4e51000cf542c50fff7
challengeType: 5
title: 'Problem 376: Nontransitive sets of dice'
---
## Description
<section id='description'>
Considera el siguiente juego de dados con puntos no estándar:
Muere A: 1 4 4 4 4 4 4
Muere B: 2 2 2 5 5 5
Muere C: 3 3 3 3 3 6
Un juego es jugado por dos jugadores que recogen un dado por turnos y lo hacen rodar. El jugador que saca el valor más alto gana.
Si el primer jugador elige el dado A y el segundo el jugador muere B, obtenemos
P (el segundo jugador gana) = 7/12&gt; 1/2
Si el primer jugador elige el dado B y el segundo jugador elige die C obtenemos
P (el segundo jugador gana) = 7/12&gt; 1/2
Si el primer jugador elige die C y el segundo jugador elige die A obtenemos
P (el segundo jugador gana) = 25/36&gt; 1/2
Entonces, cualquiera que sea el dado que elija el primer jugador, el segundo jugador puede elegir otro dado y tener una probabilidad de ganar de más del 50%.
Un conjunto de dados que tiene esta propiedad se llama un conjunto de dados no transitivos.
Queremos investigar cuántos conjuntos de dados no transitivos existen. Asumiremos las siguientes condiciones: Hay tres dados de seis caras con cada lado que tiene entre 1 y N pips, inclusive.
dados con el mismo conjunto de puntos son iguales, independientemente del lado en el que se encuentren los puntos.
El mismo valor de pip puede aparecer en múltiples dados; si ambos jugadores lanzan el mismo valor, ninguno de los dos gana.
Los conjuntos de dados {A, B, C}, {B, C, A} y {C, A, B} son el mismo conjunto.
Para N = 7 encontramos que hay 9780 tales conjuntos.
¿Cuántos hay para N = 30?
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler376()</code> debe devolver 973059630185670.
testString: 'assert.strictEqual(euler376(), 973059630185670, "<code>euler376()</code> should return 973059630185670.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler376() {
// Good luck!
return true;
}
euler376();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

67
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-381-prime-k-factorial.spanish.md Normal file
View File

@ -0,0 +1,67 @@
---
id: 5
localeTitle: 5900f4ea1000cf542c50fffc
challengeType: 5
title: 'Problem 381: (prime-k) factorial'
---
## Description
<section id='description'>
Para un primo p, deje que S (p) = (∑ (pk)!) Mod (p) para 1 ≤ k ≤ 5.
Por ejemplo, si p = 7,
(7-1)! + (7-2)! + (7-3)! + (7-4)! + (7-5)! = 6! + 5! + 4! + 3! + 2! = 720 + 120 + 24 + 6 + 2 = 872.
Como 872 mod (7) = 4, S (7) = 4.
Se puede verificar que ∑S (p) = 480 para 5 ≤ p &lt; 100.
Encuentra ∑S (p) para 5 ≤ p &lt;108.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler381()</code> debe devolver 139602943319822.
testString: 'assert.strictEqual(euler381(), 139602943319822, "<code>euler381()</code> should return 139602943319822.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler381() {
// Good luck!
return true;
}
euler381();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

79
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-40-champernownes-constant.spanish.md Normal file
View File

@ -0,0 +1,79 @@
---
id: 5
localeTitle: 5900f3941000cf542c50fea7
challengeType: 5
title: 'Problem 40: Champernowne"s constant'
---
## Description
<section id='description'>
Una fracción decimal irracional se crea mediante la concatenación de los números enteros positivos:
<span style='display: block; text-align: center;'>,12345678910 <b style='color: red;'>1</b> 112131415161718192021 ...</span>
Se puede observar que el 12 <sup>de</sup> dígitos de la parte fraccionaria es de 1.
Si <i>d <sub>n</sub></i> representa el <i><sup>enésimo</sup></i> dígitos de la parte fraccionaria , encuentra el valor de la siguiente expresión.
<span style='display: block; text-align: center;'>d <sub>1</sub> × d <sub>10</sub> × d <sub>100</sub> × d <sub>1000</sub> × d <sub>10000</sub> × d <sub>100000</sub> × d <sub>1000000</sub></span>
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>champernownesConstant(100)</code> debe devolver 5.
testString: 'assert.strictEqual(champernownesConstant(100), 5, "<code>champernownesConstant(100)</code> should return 5.");'
- text: <code>champernownesConstant(1000)</code> debe devolver 15.
testString: 'assert.strictEqual(champernownesConstant(1000), 15, "<code>champernownesConstant(1000)</code> should return 15.");'
- text: <code>champernownesConstant(1000000)</code> debe devolver 210.
testString: 'assert.strictEqual(champernownesConstant(1000000), 210, "<code>champernownesConstant(1000000)</code> should return 210.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function champernownesConstant(n) {
// Good luck!
return true;
}
champernownesConstant(100);
```
</div>
</section>
## Solution
<section id='solution'>
```js
function champernownesConstant(n) {
let fractionalPart = ";
for (let i = 0; fractionalPart.length <= n; i++) {
fractionalPart += i.toString();
}
let product = 1;
for (let i = 0; i < n.toString().length; i++) {
const index = 10 ** i;
product *= parseInt(fractionalPart[index], 10);
}
return product;
}
```
</section>

79
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-406-guessing-game.spanish.md Normal file
View File

@ -0,0 +1,79 @@
---
id: 5
localeTitle: 5900f5021000cf542c510015
challengeType: 5
title: 'Problem 406: Guessing Game'
---
## Description
<section id='description'>
Estamos tratando de encontrar un número oculto seleccionado del conjunto de enteros {1, 2, ..., n} haciendo preguntas.
Cada número (pregunta) que hacemos, obtenemos una de tres respuestas posibles: &quot;Su estimación es menor que el número oculto&quot; (y usted incurre en un costo de a), o
&quot;Su estimación es mayor que el número oculto&quot; ( e incurres en un costo de b), o
&quot;¡Sí, eso es todo!&quot; (Y el juego termina).
Dado el valor de n, a y b, una estrategia óptima minimiza el costo total para el peor de los casos.
Por ejemplo, si n = 5, a = 2 yb = 3, entonces podemos comenzar preguntando &quot;2&quot; como nuestra primera pregunta.
Si nos dicen que 2 es más alto que el número oculto (por un costo de b = 3), estamos seguros de que &quot;1&quot; es el número oculto (por un costo total de 3).
Si nos dicen que 2 es más bajo que el número oculto (por un costo de a = 2), nuestra siguiente pregunta será &quot;4&quot;.
Si nos dicen que 4 es mayor que el número oculto (para un costo de b = 3), estamos seguros de que &quot;3&quot; es el número oculto (para un costo total de 2 + 3 = 5).
Si nos dicen que 4 es menor que el número oculto (por un costo de a = 2), estamos seguros de que &quot;5&quot; es el número oculto (por un costo total de 2 + 2 = 4).
Por lo tanto, el costo en el peor de los casos alcanzado por esta estrategia es 5. También se puede demostrar que este es el costo más bajo en el peor de los casos que se puede lograr.
Entonces, de hecho, acabamos de describir una estrategia óptima para los valores dados de n, a y b.
Sea C (n, a, b) el costo más desfavorable alcanzado por una estrategia óptima para los valores dados de n, a y b.
Aquí hay algunos ejemplos:
C (5, 2, 3) = 5
C (500, √2, √3) = 13.22073197 ...
C (20000, 5, 7) = 82
C (2000000 , √5, √7) = 49.63755955 ...
Sean Fk los números de Fibonacci: Fk = Fk-1 + Fk-2 con casos base F1 = F2 = 1.Find ∑1≤k≤30 C (1012, √k, √Fk), y dé su respuesta redondeada a 8 lugares decimales detrás del punto decimal.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler406()</code> debe devolver 36813.12757207.
testString: 'assert.strictEqual(euler406(), 36813.12757207, "<code>euler406()</code> should return 36813.12757207.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler406() {
// Good luck!
return true;
}
euler406();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>

59
curriculum/challenges/spanish/08-coding-interview-prep/project-euler/problem-71-ordered-fractions.spanish.md Normal file
View File

@ -0,0 +1,59 @@
---
id: 5
localeTitle: 5900f3b31000cf542c50fec6
challengeType: 5
title: 'Problem 71: Ordered fractions'
---
## Description
<section id='description'>
Considera la fracción, n / d, donde n y d son enteros positivos. Si n <d and HCF(n,d)=1, it is called a reduced proper fraction.<code> 0 Si enumeramos el conjunto de fracciones adecuadas reducidas para d ≤ 8 en orden ascendente de tamaño, obtenemos:
1/8, 1/7, 1/6, 1/5, 1/4, 2/7, 1 / 3, 3/8, 2/5, 3/7, 1/2, 4/7, 3/5, 5/8, 2/3, 5/7, 3/4, 4/5, 5/6, 6/7, 7/8
Se puede ver que 2/5 es la fracción inmediatamente a la izquierda de 3/7.
Al enumerar el conjunto de fracciones apropiadas reducidas para d ≤ 1,000,000 en orden ascendente de tamaño, encuentre el numerador de la fracción inmediatamente a la izquierda de 3/7.
</section>
## Instructions
<section id='instructions'>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler71()</code> debe devolver 428570.
testString: 'assert.strictEqual(euler71(), 428570, "<code>euler71()</code> should return 428570.");'
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
function euler71() {
// Good luck!
return true;
}
euler71();
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
```
</section>