chore(learn): Applied MDX format to Chinese curriculum files (#40462)

This commit is contained in:
Randell Dawson
2020-12-16 00:37:30 -07:00
committed by GitHub
parent 873fce02a2
commit 9ce4a02a41
1665 changed files with 58741 additions and 88042 deletions

View File

@ -1,64 +1,41 @@
---
id: 5900f36e1000cf542c50fe80
title: 问题13和5的倍数
challengeType: 5
videoUrl: ''
title: 问题13和5的倍数
---
## Description
<section id="description">
如果我们列出所有10以下是3或5的倍数的自然数我们会得到356和9。这些倍数的总和是23。
求出所有在<code>number</code>以下的3或5的倍数的总和。
</section>
# --description--
## Instructions
<section id="instructions">
</section>
如果我们列出所有10以下是3或5的倍数的自然数我们会得到356和9。这些倍数的总和是23。
## Tests
<section id='tests'>
求出所有在`number`以下的3或5的倍数的总和。
```yml
tests:
- text: <code>multiplesOf3and5(1000)</code>应该返回233168。
testString: assert.strictEqual(multiplesOf3and5(1000), 233168);
- text: <code>multiplesOf3and5(49)</code>应该返回543。
testString: assert.strictEqual(multiplesOf3and5(49), 543);
- text: <code>multiplesOf3and5(19564)</code>应该返回89301183。
testString: assert.strictEqual(multiplesOf3and5(19564), 89301183);
- text: 您的函数未使用我们的测试值返回正确的结果。
testString: assert.strictEqual(multiplesOf3and5(8456), 16687353);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`multiplesOf3and5(1000)`应该返回233168。
```js
function multiplesOf3and5(number) {
// Good luck!
return true;
}
multiplesOf3and5(1000);
assert.strictEqual(multiplesOf3and5(1000), 233168);
```
</div>
</section>
## Solution
<section id='solution'>
`multiplesOf3and5(49)`应该返回543。
```js
// solution required
assert.strictEqual(multiplesOf3and5(49), 543);
```
/section>
`multiplesOf3and5(19564)`应该返回89301183。
```js
assert.strictEqual(multiplesOf3and5(19564), 89301183);
```
您的函数未使用我们的测试值返回正确的结果。
```js
assert.strictEqual(multiplesOf3and5(8456), 16687353);
```
# --solutions--

View File

@ -1,61 +1,39 @@
---
id: 5900f3761000cf542c50fe89
title: 问题10素数的总和
challengeType: 5
videoUrl: ''
title: 问题10素数的总和
---
## Description
<section id="description">低于10的素数之和为2 + 3 + 5 + 7 = 17.求出n以下所有素数的总和。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
低于10的素数之和为2 + 3 + 5 + 7 = 17.求出n以下所有素数的总和。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>primeSummation(17)</code>应该返回41。
testString: assert.strictEqual(primeSummation(17), 41);
- text: <code>primeSummation(2001)</code>应该返回277050。
testString: assert.strictEqual(primeSummation(2001), 277050);
- text: <code>primeSummation(140759)</code>应该返回873608362。
testString: assert.strictEqual(primeSummation(140759), 873608362);
- text: <code>primeSummation(2000000)</code>应返回142913828922。
testString: assert.strictEqual(primeSummation(2000000), 142913828922);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`primeSummation(17)`应该返回41。
```js
function primeSummation(n) {
// Good luck!
return true;
}
primeSummation(2000000);
assert.strictEqual(primeSummation(17), 41);
```
</div>
</section>
## Solution
<section id='solution'>
`primeSummation(2001)`应该返回277050。
```js
// solution required
assert.strictEqual(primeSummation(2001), 277050);
```
/section>
`primeSummation(140759)`应该返回873608362。
```js
assert.strictEqual(primeSummation(140759), 873608362);
```
`primeSummation(2000000)`应返回142913828922。
```js
assert.strictEqual(primeSummation(2000000), 142913828922);
```
# --solutions--

View File

@ -1,55 +1,21 @@
---
id: 5900f3d01000cf542c50fee3
title: 问题100安排概率
challengeType: 5
videoUrl: ''
title: 问题100安排概率
---
## Description
<section id="description">如果一个盒子包含21个彩色光盘由15个蓝色光盘和6个红色光盘组成随机拍摄两张光盘可以看出拍摄两张蓝色光盘的概率PBB=15/21 ×14/20= 1/2。下一个这样的安排其中有50的机会随机拍摄两张蓝色光盘是一个包含八十五个蓝色光盘和三十五个红色光盘的盒子。通过找到第一个包含总共超过1012 = 1,000,000,000,000个光盘的布置确定该盒子将包含的蓝色光盘的数量。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
如果一个盒子包含21个彩色光盘由15个蓝色光盘和6个红色光盘组成随机拍摄两张光盘可以看出拍摄两张蓝色光盘的概率PBB=15/21 ×14/20= 1/2。下一个这样的安排其中有50的机会随机拍摄两张蓝色光盘是一个包含八十五个蓝色光盘和三十五个红色光盘的盒子。通过找到第一个包含总共超过1012 = 1,000,000,000,000个光盘的布置确定该盒子将包含的蓝色光盘的数量。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler100()</code>应该返回756872327473。
testString: assert.strictEqual(euler100(), 756872327473);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler100()`应该返回756872327473。
```js
function euler100() {
// Good luck!
return true;
}
euler100();
assert.strictEqual(euler100(), 756872327473);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f3d21000cf542c50fee4
title: 问题101最佳多项式
challengeType: 5
videoUrl: ''
title: 问题101最佳多项式
---
## Description
<section id="description">如果我们被给出序列的前k个项则不可能肯定地说下一个项的值因为存在无限多个可以对序列建模的多项式函数。举个例子让我们考虑一下立方体数字的顺序。这由生成函数定义un = n31,8,27,64,125,216 ......假设我们只给出了该序列的前两个项。根据“简单就是最好”的原则我们应该假设一个线性关系并预测下一个项为15公共差异7。即使我们被提出前三个术语按照相同的简单原则也应假设二次关系。我们将OPkn定义为序列的前k个项的最佳多项式生成函数的第n项。应该清楚的是OPkn将准确地生成n≤k的序列项并且可能第一个不正确的项FIT将是OPkk + 1;在这种情况下我们将其称为坏OPBOP。作为一个基础如果我们只给出第一个序列项那么假设恒定是最明智的;也就是说对于n≥2OP1n= u1。因此我们获得了立方序列的以下OP <p> OP1n= 11 1,1,1,1 ...... OP2n= 7n-6 1,8,15...... OP3n= 6n2-11n + 6 1,8,27,58... OP4n= n3 1,8,27,64,125...... </p><p>显然对于k≥4不存在BOP。通过考虑BOP产生的FIT之和以红色表示我们得到1 + 15 + 58 = 74.考虑下面的十度多项式生成函数un = 1 - n + n2 - n3 + n4 - n5 + n6 - n7 + n8 - n9 + n10求BOP的FIT之和。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
如果我们被给出序列的前k个项则不可能肯定地说下一个项的值因为存在无限多个可以对序列建模的多项式函数。举个例子让我们考虑一下立方体数字的顺序。这由生成函数定义un = n31,8,27,64,125,216 ......假设我们只给出了该序列的前两个项。根据“简单就是最好”的原则我们应该假设一个线性关系并预测下一个项为15公共差异7。即使我们被提出前三个术语按照相同的简单原则也应假设二次关系。我们将OPkn定义为序列的前k个项的最佳多项式生成函数的第n项。应该清楚的是OPkn将准确地生成n≤k的序列项并且可能第一个不正确的项FIT将是OPkk + 1;在这种情况下我们将其称为坏OPBOP。作为一个基础如果我们只给出第一个序列项那么假设恒定是最明智的;也就是说对于n≥2OP1n= u1。因此我们获得了立方序列的以下OP
## Tests
<section id='tests'>
OP1n= 11 1,1,1,1 ...... OP2n= 7n-6 1,8,15...... OP3n= 6n2-11n + 6 1,8,27,58... OP4n= n3 1,8,27,64,125......
```yml
tests:
- text: <code>euler101()</code>应该返回37076114526。
testString: assert.strictEqual(euler101(), 37076114526);
显然对于k≥4不存在BOP。通过考虑BOP产生的FIT之和以红色表示我们得到1 + 15 + 58 = 74.考虑下面的十度多项式生成函数un = 1 - n + n2 - n3 + n4 - n5 + n6 - n7 + n8 - n9 + n10求BOP的FIT之和。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler101()`应该返回37076114526。
```js
function euler101() {
// Good luck!
return true;
}
euler101();
assert.strictEqual(euler101(), 37076114526);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3d21000cf542c50fee5
title: 问题102三角形遏制
challengeType: 5
videoUrl: ''
title: 问题102三角形遏制
---
## Description
<section id="description">在笛卡尔平面上随机绘制三个不同的点,其中-1000≤xy≤1000从而形成三角形。考虑以下两个三角形A-340,495B-153-910C835-947X-175,41Y-421-714Z574 - 645可以验证三角形ABC包含原点而三角形XYZ不包含原点。使用triangles.txt右键单击并将“Save Link / Target As ...”保存包含一千个“随机”三角形坐标的27K文本文件找到内部包含原点的三角形数。注意文件中的前两个示例表示上面给出的示例中的三角形。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
在笛卡尔平面上随机绘制三个不同的点,其中-1000≤xy≤1000从而形成三角形。考虑以下两个三角形A-340,495B-153-910C835-947X-175,41Y-421-714Z574 - 645可以验证三角形ABC包含原点而三角形XYZ不包含原点。使用triangles.txt右键单击并将“Save Link / Target As ...”保存包含一千个“随机”三角形坐标的27K文本文件找到内部包含原点的三角形数。注意文件中的前两个示例表示上面给出的示例中的三角形。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler102()</code>应该返回228。
testString: assert.strictEqual(euler102(), 228);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler102()`应该返回228。
```js
function euler102() {
// Good luck!
return true;
}
euler102();
assert.strictEqual(euler102(), 228);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3d61000cf542c50fee7
title: 问题103特殊子集和最佳
challengeType: 5
videoUrl: ''
title: 问题103特殊子集和最佳
---
## Description
<section id="description">设SA表示大小为n的集合A中的元素之和。如果对于任何两个非空的不相交子集B和C我们将其称为特殊和集合以下属性为真SB≠SC;也就是说子集的总和不能相等。如果B包含的元素多于C则SB&gt; SC。如果对于给定的nSA被最小化我们将其称为最优的特殊和集。下面给出前五个最佳特殊和集。 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}似乎对于给定的最优集合A = {a1a2...an}下一个最优集合的形式为B = {ba1 + ba2 + b... ..an + b}其中b是前一行的“中间”元素。通过应用这个“规则”我们期望n = 6的最优集合为A = {11,17,20,22,23,24}其中SA= 117.但是,这不是最佳集合因为我们仅应用算法来提供接近最优的集合。 n = 6的最佳集合是A = {11,18,19,20,22,25}其中SA= 115并且对应的集合字符串111819202225。假设A是n =的最优特殊和集合7找到它的设置字符串。注意此问题与问题105和问题106有关。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
设SA表示大小为n的集合A中的元素之和。如果对于任何两个非空的不相交子集B和C我们将其称为特殊和集合以下属性为真SB≠SC;也就是说子集的总和不能相等。如果B包含的元素多于C则SB> SC。如果对于给定的nSA被最小化我们将其称为最优的特殊和集。下面给出前五个最佳特殊和集。 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}似乎对于给定的最优集合A = {a1a2...an}下一个最优集合的形式为B = {ba1 + ba2 + b... ..an + b}其中b是前一行的“中间”元素。通过应用这个“规则”我们期望n = 6的最优集合为A = {11,17,20,22,23,24}其中SA= 117.但是,这不是最佳集合因为我们仅应用算法来提供接近最优的集合。 n = 6的最佳集合是A = {11,18,19,20,22,25}其中SA= 115并且对应的集合字符串111819202225。假设A是n =的最优特殊和集合7找到它的设置字符串。注意此问题与问题105和问题106有关。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler103()</code>应该返回20313839404245。
testString: assert.strictEqual(euler103(), 20313839404245);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler103()`应该返回20313839404245。
```js
function euler103() {
// Good luck!
return true;
}
euler103();
assert.strictEqual(euler103(), 20313839404245);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3d51000cf542c50fee6
title: 问题104Pandigital Fibonacci结束
challengeType: 5
videoUrl: ''
title: 问题104Pandigital Fibonacci结束
---
## Description
<section id="description"> Fibonacci序列由递归关系定义Fn = Fn-1 + Fn-2其中F1 = 1且F2 = 1.事实证明包含113位数字的F541是第一个斐波那契数字其中最后九个数字是1-9 pandigital包含所有数字1到9但不一定按顺序。 F2749包含575个数字是第一个斐波那契数字前九个数字是1-9 pandigital。鉴于Fk是第一个斐波纳契数前九个数字和后九个数字是1-9 pandigital找到k。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
Fibonacci序列由递归关系定义Fn = Fn-1 + Fn-2其中F1 = 1且F2 = 1.事实证明包含113位数字的F541是第一个斐波那契数字其中最后九个数字是1-9 pandigital包含所有数字1到9但不一定按顺序。 F2749包含575个数字是第一个斐波那契数字前九个数字是1-9 pandigital。鉴于Fk是第一个斐波纳契数前九个数字和后九个数字是1-9 pandigital找到k。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler104()</code>应返回329468。
testString: assert.strictEqual(euler104(), 329468);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler104()`应返回329468。
```js
function euler104() {
// Good luck!
return true;
}
euler104();
assert.strictEqual(euler104(), 329468);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3d61000cf542c50fee8
title: 问题105特殊子集总和测试
challengeType: 5
videoUrl: ''
title: 问题105特殊子集总和测试
---
## Description
<section id="description">设SA表示大小为n的集合A中的元素之和。如果对于任何两个非空的不相交子集B和C我们将其称为特殊和集合以下属性为真SB≠SC;也就是说子集的总和不能相等。如果B包含的元素多于C则SB&gt; SC。例如{81,88,75,42,87,84,86,65}不是一个特殊的和集因为65 + 87 + 88 = 75 + 81 + 84而{157,150,164,119,79 159,161,139,158}满足所有可能的子集对组合的规则并且SA= 1286.使用sets.txt右键单击并“将链接/目标另存为...”4K文本文件包含七到十二个元素的一百个集合上面给出的两个例子是文件中的前两个集合识别所有特殊的和集A1A2...Ak并找到S的值 A1+ SA2+ ... + SAk。注意此问题与问题103和问题106有关。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
设SA表示大小为n的集合A中的元素之和。如果对于任何两个非空的不相交子集B和C我们将其称为特殊和集合以下属性为真SB≠SC;也就是说子集的总和不能相等。如果B包含的元素多于C则SB> SC。例如{81,88,75,42,87,84,86,65}不是一个特殊的和集因为65 + 87 + 88 = 75 + 81 + 84而{157,150,164,119,79 159,161,139,158}满足所有可能的子集对组合的规则并且SA= 1286.使用sets.txt右键单击并“将链接/目标另存为...”4K文本文件包含七到十二个元素的一百个集合上面给出的两个例子是文件中的前两个集合识别所有特殊的和集A1A2...Ak并找到S的值 A1+ SA2+ ... + SAk。注意此问题与问题103和问题106有关。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler105()</code>应返回73702。
testString: assert.strictEqual(euler105(), 73702);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler105()`应返回73702。
```js
function euler105() {
// Good luck!
return true;
}
euler105();
assert.strictEqual(euler105(), 73702);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3d71000cf542c50fee9
title: 问题106特殊子集和元测试
challengeType: 5
videoUrl: ''
title: 问题106特殊子集和元测试
---
## Description
<section id="description">设SA表示大小为n的集合A中的元素之和。如果对于任何两个非空的不相交子集B和C我们将其称为特殊和集合以下属性为真SB≠SC;也就是说子集的总和不能相等。如果B包含的元素多于C则SB&gt; SC。对于这个问题我们假设给定的集合包含n个严格增加的元素并且它已经满足第二个规则。令人惊讶的是在可以从n = 4的集合中获得的25个可能的子集对中仅需要对这些对中的1个进行相等性测试第一规则。类似地当n = 7时仅需要测试966个子集对中的70个。对于n = 12可以获得多少261625个子集对需要进行相等性测试注意此问题与问题103和问题105有关。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
设SA表示大小为n的集合A中的元素之和。如果对于任何两个非空的不相交子集B和C我们将其称为特殊和集合以下属性为真SB≠SC;也就是说子集的总和不能相等。如果B包含的元素多于C则SB> SC。对于这个问题我们假设给定的集合包含n个严格增加的元素并且它已经满足第二个规则。令人惊讶的是在可以从n = 4的集合中获得的25个可能的子集对中仅需要对这些对中的1个进行相等性测试第一规则。类似地当n = 7时仅需要测试966个子集对中的70个。对于n = 12可以获得多少261625个子集对需要进行相等性测试注意此问题与问题103和问题105有关。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler106()</code>应返回21384。
testString: assert.strictEqual(euler106(), 21384);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler106()`应返回21384。
```js
function euler106() {
// Good luck!
return true;
}
euler106();
assert.strictEqual(euler106(), 21384);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f3d91000cf542c50feea
title: 问题107最小网络
challengeType: 5
videoUrl: ''
title: 问题107最小网络
---
## Description
<section id="description">以下无向网络由七个顶点和十二个边组成总权重为243。 <p>相同的网络可以由下面的矩阵表示。 ABCDEFG A-161221 --- B16--1720-- C12--28-31- D211728-181923 E-20-18--11 F-3119--27 G --- 231127-但是有可能通过删除一些边缘来优化网络并仍然确保网络上的所有点保持连接。实现最大节省的网络如下所示。它的权重为93比原始网络节省了243 - 93 = 150。 </p><p>使用network.txt右键单击并“保存链接/目标为...”一个6K文本文件包含一个具有四十个顶点的网络并以矩阵形式给出找到通过删除冗余边缘可以实现的最大节省确保网络保持连接。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
以下无向网络由七个顶点和十二个边组成总权重为243。
## Tests
<section id='tests'>
相同的网络可以由下面的矩阵表示。 ABCDEFG A-161221 --- B16--1720-- C12--28-31- D211728-181923 E-20-18--11 F-3119--27 G --- 231127-但是有可能通过删除一些边缘来优化网络并仍然确保网络上的所有点保持连接。实现最大节省的网络如下所示。它的权重为93比原始网络节省了243 - 93 = 150。
```yml
tests:
- text: <code>euler107()</code>应该返回259679。
testString: assert.strictEqual(euler107(), 259679);
使用network.txt右键单击并“保存链接/目标为...”一个6K文本文件包含一个具有四十个顶点的网络并以矩阵形式给出找到通过删除冗余边缘可以实现的最大节省确保网络保持连接。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler107()`应该返回259679。
```js
function euler107() {
// Good luck!
return true;
}
euler107();
assert.strictEqual(euler107(), 259679);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3d91000cf542c50feeb
title: 问题108丢番图互惠I
challengeType: 5
videoUrl: ''
title: 问题108丢番图互惠I
---
## Description
<section id="description">在下面的等式中xy和n是正整数。 1 / <var>x</var> + 1 / <var>y</var> = 1 / <var>n</var>对于<var>n</var> = 4恰好有三种不同的解1/5 + 1/20 = 1/4 <br> 1/6 + 1/12 = 1/4 <br> 1/8 + 1/8 = 1/4不同解的数量超过一千的<var>n的</var>最小值是多少? </section>
# --description--
## Instructions
<section id="instructions">
</section>
在下面的等式中xy和n是正整数。 1 / `x` + 1 / `y` = 1 / `n`对于`n` = 4恰好有三种不同的解1/5 + 1/20 = 1/4
1/6 + 1/12 = 1/4
1/8 + 1/8 = 1/4不同解的数量超过一千的`n的`最小值是多少?
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: diophantineOne <code>diophantineOne()</code>应返回180180。
testString: assert.strictEqual(diophantineOne(), 180180);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
diophantineOne `diophantineOne()`应返回180180。
```js
function diophantineOne() {
// Good luck!
return true;
}
diophantineOne();
assert.strictEqual(diophantineOne(), 180180);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,37 @@
---
id: 5900f3db1000cf542c50feec
title: 问题109飞镖
challengeType: 5
videoUrl: ''
title: 问题109飞镖
---
## Description
<section id="description">在飞镖游戏中,玩家在目标板上投掷三个飞镖,该目标板被分成二十个相等大小的部分,编号为一到二十。 <p>飞镖的得分由飞镖着陆区域的数量决定。红色/绿色外圈外的飞镖着陆得分为零。该戒指内的黑色和奶油色区域代表单个分数。然而,红色/绿色外圈和中圈分别得分为双倍和高音。在董事会的中心是两个同心圆称为公牛区或公牛眼。外面的公牛价值25点内部公牛是双倍价值50点。规则有很多变化但在最流行的游戏中玩家将以301或501的分数开始并且第一个将他们的总跑动总数减少到零的玩家是胜利者。然而玩“双打”系统是正常的这意味着玩家必须在他们的最终飞镖上获得双倍包括在棋盘中央的双靶心才能获胜;任何其他飞镖都会将他们的跑动总数减少到一个或更低意味着这组三个飞镖的得分是“半身像”。当玩家能够完成他们当前的分数时它被称为“结账”最高结账时间是170T20 T20 D25两个高音20和双牛。有6种截然不同的结账方式分数为6 </p><p> D3 </p><p> D1 D2 </p><p> S2 D2 </p><p> D2 D1 </p><p> S4 D1 </p><p> S1 S1 D2 S1 T1 D1 S1 S3 D1 D1 D1 D1 D1 S2 D1 S2 S2 D1 </p><p>请注意D1 D2被认为与D2 D1不同因为它们在不同的双打上完成。但是组合S1 T1 D1被认为与T1 S1 D1相同。此外我们不会在考虑组合时包含未命中数;例如D3与0 D3和0 0 D3相同。令人难以置信的是共有42336种不同的检查方式。玩家以低于100的分数结账有多少种不同的方式 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
在飞镖游戏中,玩家在目标板上投掷三个飞镖,该目标板被分成二十个相等大小的部分,编号为一到二十。
## Tests
<section id='tests'>
飞镖的得分由飞镖着陆区域的数量决定。红色/绿色外圈外的飞镖着陆得分为零。该戒指内的黑色和奶油色区域代表单个分数。然而,红色/绿色外圈和中圈分别得分为双倍和高音。在董事会的中心是两个同心圆称为公牛区或公牛眼。外面的公牛价值25点内部公牛是双倍价值50点。规则有很多变化但在最流行的游戏中玩家将以301或501的分数开始并且第一个将他们的总跑动总数减少到零的玩家是胜利者。然而玩“双打”系统是正常的这意味着玩家必须在他们的最终飞镖上获得双倍包括在棋盘中央的双靶心才能获胜;任何其他飞镖都会将他们的跑动总数减少到一个或更低意味着这组三个飞镖的得分是“半身像”。当玩家能够完成他们当前的分数时它被称为“结账”最高结账时间是170T20 T20 D25两个高音20和双牛。有6种截然不同的结账方式分数为6
```yml
tests:
- text: <code>euler109()</code>应返回38182。
testString: assert.strictEqual(euler109(), 38182);
D3
```
D1 D2
</section>
S2 D2
## Challenge Seed
<section id='challengeSeed'>
D2 D1
<div id='js-seed'>
S4 D1
S1 S1 D2 S1 T1 D1 S1 S3 D1 D1 D1 D1 D1 S2 D1 S2 S2 D1
请注意D1 D2被认为与D2 D1不同因为它们在不同的双打上完成。但是组合S1 T1 D1被认为与T1 S1 D1相同。此外我们不会在考虑组合时包含未命中数;例如D3与0 D3和0 0 D3相同。令人难以置信的是共有42336种不同的检查方式。玩家以低于100的分数结账有多少种不同的方式
# --hints--
`euler109()`应返回38182。
```js
function euler109() {
// Good luck!
return true;
}
euler109();
assert.strictEqual(euler109(), 38182);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,89 +1,69 @@
---
id: 5900f3781000cf542c50fe8a
title: 问题11网格中最大的产品
challengeType: 5
videoUrl: ''
title: 问题11网格中最大的产品
---
## Description
<section id="description">在下面的20×20网格中沿对角线的四个数字标记为红色。 <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><p>这些数字的乘积是26×63×78×14 = 1788696.在给定的<code>arr</code>网格中,相同方向(上,下,左,右或对角)的四个相邻数字的最大乘积是多少? </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
在下面的20×20网格中沿对角线的四个数字标记为红色。
## Tests
<section id='tests'>
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
```yml
tests:
- text: <code>largestGridProduct(grid)</code>应该返回70600674。
testString: assert.strictEqual(largestGridProduct(grid), 70600674);
- text: <code>largestGridProduct(testGrid)</code>应该返回14169081。
testString: assert.strictEqual(largestGridProduct(testGrid), 14169081);
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
```
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
</section>
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
## Challenge Seed
<section id='challengeSeed'>
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
<div id='js-seed'>
24 47 32 60 99 03 45 02 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 02 62 12 20 95 **63** 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 **78** 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 **14** 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
这些数字的乘积是26×63×78×14 = 1788696.在给定的`arr`网格中,相同方向(上,下,左,右或对角)的四个相邻数字的最大乘积是多少?
# --hints--
`largestGridProduct(grid)`应该返回70600674。
```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);
assert.strictEqual(largestGridProduct(grid), 70600674);
```
</div>
</section>
## Solution
<section id='solution'>
`largestGridProduct(testGrid)`应该返回14169081。
```js
// solution required
assert.strictEqual(largestGridProduct(testGrid), 14169081);
```
/section>
# --solutions--

View File

@ -1,55 +1,21 @@
---
id: 5900f3db1000cf542c50feed
title: 问题110丢番图互惠II
challengeType: 5
videoUrl: ''
title: 问题110丢番图互惠II
---
## Description
<section id="description">在下面的等式中xy和n是正整数。 1 / <var>x</var> + 1 / <var>y</var> = 1 / <var>n</var>可以证实,当<var>n</var> = 1260时存在113个不同的解并且这是<var>n的</var>最小值其中不同解的总数超过100。 <var>n的</var>最小值是多少,不同解决方案的数量超过四百万? </section>
# --description--
## Instructions
<section id="instructions">
</section>
在下面的等式中xy和n是正整数。 1 / `x` + 1 / `y` = 1 / `n`可以证实,当`n` = 1260时存在113个不同的解并且这是`n的`最小值其中不同解的总数超过100。 `n的`最小值是多少,不同解决方案的数量超过四百万?
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>diophantineTwo</code>应该返回9350130049860600。
testString: assert.strictEqual(diophantineTwo(), 9350130049860600);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`diophantineTwo`应该返回9350130049860600。
```js
function diophantineTwo() {
// Good luck!
return true;
}
diophantineTwo();
assert.strictEqual(diophantineTwo(), 9350130049860600);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f3db1000cf542c50feee
title: 问题111运行的Primes
challengeType: 5
videoUrl: ''
title: 问题111运行的Primes
---
## Description
<section id="description">考虑到包含重复数字的4位数素数很明显它们不能全部相同1111可被11整除2222可被22整除依此类推。但是有九个4位数的素数包含三个素数1117,1151,1171,1181,1511,1811,2111,4111,8111我们将说Mnd表示n-的最大重复数位数。数字素数其中d是重复数字Nnd表示这些素数的数量Snd表示这些素数的总和。所以M4,1= 3是4位数的素数的最大重复位数其中一个是重复的数字有N4,1= 9个这样的素数这些素数的总和是S 4,1= 22275.事实证明对于d = 0只能使M4,0= 2个重复数字但是存在N4,0= 13个这样的情况。同样地我们获得了4位素数的以下结果。 <p>数字d M4dN4dS4d0 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 </p><p>对于d = 0到9所有S4d的总和是273700.求所有S10d的总和。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑到包含重复数字的4位数素数很明显它们不能全部相同1111可被11整除2222可被22整除依此类推。但是有九个4位数的素数包含三个素数1117,1151,1171,1181,1511,1811,2111,4111,8111我们将说Mnd表示n-的最大重复数位数。数字素数其中d是重复数字Nnd表示这些素数的数量Snd表示这些素数的总和。所以M4,1= 3是4位数的素数的最大重复位数其中一个是重复的数字有N4,1= 9个这样的素数这些素数的总和是S 4,1= 22275.事实证明对于d = 0只能使M4,0= 2个重复数字但是存在N4,0= 13个这样的情况。同样地我们获得了4位素数的以下结果。
## Tests
<section id='tests'>
数字d M4dN4dS4d0 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
```yml
tests:
- text: <code>euler111()</code>应返回612407567715。
testString: assert.strictEqual(euler111(), 612407567715);
对于d = 0到9所有S4d的总和是273700.求所有S10d的总和。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler111()`应返回612407567715。
```js
function euler111() {
// Good luck!
return true;
}
euler111();
assert.strictEqual(euler111(), 612407567715);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3dd1000cf542c50feef
title: 问题112有弹性的数字
challengeType: 5
videoUrl: ''
title: 问题112有弹性的数字
---
## Description
<section id="description">如果左边的数字没有超过数字,则从左到右工作,称为递增数字;例如134468。同样如果右边的数字没有超过数字则称为递减数字;例如66420。我们将调用一个既不增加也不减少“有弹性”数的正整数;例如155349。显然不会有任何低于一百的弹性数字但只有超过一千525的数字超过一半是有弹性的。事实上有弹性数字首次达到50的最小数量是538.令人惊讶的是有弹性的数字变得越来越普遍当我们达到21780时有弹性数字的比例等于90。找出有弹性数字的比例正好为99的最小数字。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
如果左边的数字没有超过数字,则从左到右工作,称为递增数字;例如134468。同样如果右边的数字没有超过数字则称为递减数字;例如66420。我们将调用一个既不增加也不减少“有弹性”数的正整数;例如155349。显然不会有任何低于一百的弹性数字但只有超过一千525的数字超过一半是有弹性的。事实上有弹性数字首次达到50的最小数量是538.令人惊讶的是有弹性的数字变得越来越普遍当我们达到21780时有弹性数字的比例等于90。找出有弹性数字的比例正好为99的最小数字。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler112()</code>应返回1587000。
testString: assert.strictEqual(euler112(), 1587000);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler112()`应返回1587000。
```js
function euler112() {
// Good luck!
return true;
}
euler112();
assert.strictEqual(euler112(), 1587000);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3dd1000cf542c50fef0
title: 问题113非弹性数字
challengeType: 5
videoUrl: ''
title: 问题113非弹性数字
---
## Description
<section id="description">如果左边的数字没有超过数字,则从左到右工作,称为递增数字;例如134468。同样如果右边的数字没有超过数字则称为递减数字;例如66420。我们将调用一个既不增加也不减少“有弹性”数的正整数;例如随着n的增加低于n的弹性数的比例增加使得只有12951个数字低于一百万个而不是有弹性而只有277032个非有弹性的数字低于1010.一个数量低于一个googol10100 )是不是有弹性? </section>
# --description--
## Instructions
<section id="instructions">
</section>
如果左边的数字没有超过数字,则从左到右工作,称为递增数字;例如134468。同样如果右边的数字没有超过数字则称为递减数字;例如66420。我们将调用一个既不增加也不减少“有弹性”数的正整数;例如随着n的增加低于n的弹性数的比例增加使得只有12951个数字低于一百万个而不是有弹性而只有277032个非有弹性的数字低于1010.一个数量低于一个googol10100 )是不是有弹性?
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler113()</code>应该返回51161058134250。
testString: assert.strictEqual(euler113(), 51161058134250);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler113()`应该返回51161058134250。
```js
function euler113() {
// Good luck!
return true;
}
euler113();
assert.strictEqual(euler113(), 51161058134250);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3e01000cf542c50fef2
title: 问题114计数块组合I
challengeType: 5
videoUrl: ''
title: 问题114计数块组合I
---
## Description
<section id="description">测量七个单元长度的行具有红色块,其上放置有最小长度为三个单元,使得任何两个红色块(允许为不同长度)由至少一个黑色方块隔开。有七种方法可以做到这一点。 <p>一行可以测量多达50个长度的行数注意虽然上面的示例不适合这种可能性但通常允许混合块大小。例如在一个长度为8个单位的行上您可以使用红色3黑色1和红色4</p></section>
# --description--
## Instructions
<section id="instructions">
</section>
测量七个单元长度的行具有红色块,其上放置有最小长度为三个单元,使得任何两个红色块(允许为不同长度)由至少一个黑色方块隔开。有七种方法可以做到这一点。
## Tests
<section id='tests'>
一行可以测量多达50个长度的行数注意虽然上面的示例不适合这种可能性但通常允许混合块大小。例如在一个长度为8个单位的行上您可以使用红色3黑色1和红色4
```yml
tests:
- text: <code>euler114()</code>应该返回16475640049。
testString: assert.strictEqual(euler114(), 16475640049);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler114()`应该返回16475640049。
```js
function euler114() {
// Good luck!
return true;
}
euler114();
assert.strictEqual(euler114(), 16475640049);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3df1000cf542c50fef1
title: 问题115计数块组合II
challengeType: 5
videoUrl: ''
title: 问题115计数块组合II
---
## Description
<section id="description">注意这是问题114的更难的版本。测量n个单位长度的行具有红色块其上放置最小长度为m个单位使得任何两个红色块允许不同长度被分开至少有一个黑色方块。让fill-count函数Fmn表示可以填充行的方式的数量。例如F3,29= 673135和F3,30= 1089155.也就是说对于m = 3可以看出n = 30是填充计数函数首次超过的最小值一百万。同样对于m = 10可以验证F10,56= 880711和F10,57= 1148904因此n = 57是填充计数函数首次超过的最小值一百万。对于m = 50找到填充计数函数首先超过一百万的n的最小值。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
注意这是问题114的更难的版本。测量n个单位长度的行具有红色块其上放置最小长度为m个单位使得任何两个红色块允许不同长度被分开至少有一个黑色方块。让fill-count函数Fmn表示可以填充行的方式的数量。例如F3,29= 673135和F3,30= 1089155.也就是说对于m = 3可以看出n = 30是填充计数函数首次超过的最小值一百万。同样对于m = 10可以验证F10,56= 880711和F10,57= 1148904因此n = 57是填充计数函数首次超过的最小值一百万。对于m = 50找到填充计数函数首先超过一百万的n的最小值。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler115()</code>应返回168。
testString: assert.strictEqual(euler115(), 168);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler115()`应返回168。
```js
function euler115() {
// Good luck!
return true;
}
euler115();
assert.strictEqual(euler115(), 168);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,27 @@
---
id: 5900f3e01000cf542c50fef3
title: 问题116红色绿色或蓝色瓷砖
challengeType: 5
videoUrl: ''
title: 问题116红色绿色或蓝色瓷砖
---
## Description
<section id="description">一排五个黑色正方形瓷砖是用彩色椭圆形瓷砖代替的其中红色长度为2绿色长度为3或蓝色长度为4。如果选择红色瓷砖则可以通过七种方式完成此操作。 <p>如果选择绿色瓷砖,有三种方法。 </p><p>如果选择蓝色瓷砖,有两种方法。 </p><p>假设颜色不能混合则有7 + 3 + 2 = 12种方式替换长度为五个单位的行中的黑色瓷砖。如果不能混合颜色并且必须使用至少一个彩色瓷砖那么连续测量五十个单位的黑色瓷砖有多少种不同的方式可以替换注意这与问题117有关。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
一排五个黑色正方形瓷砖是用彩色椭圆形瓷砖代替的其中红色长度为2绿色长度为3或蓝色长度为4。如果选择红色瓷砖则可以通过七种方式完成此操作。
## Tests
<section id='tests'>
如果选择绿色瓷砖,有三种方法。
```yml
tests:
- text: <code>euler116()</code>应该返回20492570929。
testString: assert.strictEqual(euler116(), 20492570929);
如果选择蓝色瓷砖,有两种方法。
```
假设颜色不能混合则有7 + 3 + 2 = 12种方式替换长度为五个单位的行中的黑色瓷砖。如果不能混合颜色并且必须使用至少一个彩色瓷砖那么连续测量五十个单位的黑色瓷砖有多少种不同的方式可以替换注意这与问题117有关。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler116()`应该返回20492570929。
```js
function euler116() {
// Good luck!
return true;
}
euler116();
assert.strictEqual(euler116(), 20492570929);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3e21000cf542c50fef4
title: 问题117红色绿色和蓝色瓷砖
challengeType: 5
videoUrl: ''
title: 问题117红色绿色和蓝色瓷砖
---
## Description
<section id="description">使用黑色正方形瓷砖和椭圆形瓷砖的组合,选自:测量两个单位的红色瓷砖,测量三个单位的绿色瓷砖和测量四个单位的蓝色瓷砖,可以以十五种不同的方式平铺一个长度为五个单位的行。 <p>一行测量五十个单位长度的平铺方式有多少注意这与问题116有关。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
使用黑色正方形瓷砖和椭圆形瓷砖的组合,选自:测量两个单位的红色瓷砖,测量三个单位的绿色瓷砖和测量四个单位的蓝色瓷砖,可以以十五种不同的方式平铺一个长度为五个单位的行。
## Tests
<section id='tests'>
一行测量五十个单位长度的平铺方式有多少注意这与问题116有关。
```yml
tests:
- text: <code>euler117()</code>应该返回100808458960497。
testString: assert.strictEqual(euler117(), 100808458960497);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler117()`应该返回100808458960497。
```js
function euler117() {
// Good luck!
return true;
}
euler117();
assert.strictEqual(euler117(), 100808458960497);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3e21000cf542c50fef5
title: 问题118Pandigital prime set
challengeType: 5
videoUrl: ''
title: 问题118Pandigital prime set
---
## Description
<section id="description">使用所有数字1到9并自由地连接它们以形成十进制整数可以形成不同的集合。有趣的是集合{2,5,47,89,631}属于它的所有元素都是素数。包含每个数字1到9的多少个不同的集合只包含主要元素 </section>
# --description--
## Instructions
<section id="instructions">
</section>
使用所有数字1到9并自由地连接它们以形成十进制整数可以形成不同的集合。有趣的是集合{2,5,47,89,631}属于它的所有元素都是素数。包含每个数字1到9的多少个不同的集合只包含主要元素
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler118()</code>应返回44680。
testString: assert.strictEqual(euler118(), 44680);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler118()`应返回44680。
```js
function euler118() {
// Good luck!
return true;
}
euler118();
assert.strictEqual(euler118(), 44680);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3e41000cf542c50fef6
title: 问题119数字功率总和
challengeType: 5
videoUrl: ''
title: 问题119数字功率总和
---
## Description
<section id="description">数字512很有意思因为它等于它的数字加到某个幂的总和5 + 1 + 2 = 8而83 = 512.具有这个属性的数字的另一个例子是614656 = 284.我们将定义一个成为这个序列的第n个术语并坚持一个数字必须包含至少两个数字才能得到一个总和。给出a2 = 512和a10 = 614656。找到a30。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
数字512很有意思因为它等于它的数字加到某个幂的总和5 + 1 + 2 = 8而83 = 512.具有这个属性的数字的另一个例子是614656 = 284.我们将定义一个成为这个序列的第n个术语并坚持一个数字必须包含至少两个数字才能得到一个总和。给出a2 = 512和a10 = 614656。找到a30。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler119()</code>应该返回248155780267521。
testString: assert.strictEqual(euler119(), 248155780267521);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler119()`应该返回248155780267521。
```js
function euler119() {
// Good luck!
return true;
}
euler119();
assert.strictEqual(euler119(), 248155780267521);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,63 +1,65 @@
---
id: 5900f3781000cf542c50fe8b
title: 问题12高度可分的三角数
challengeType: 5
videoUrl: ''
title: 问题12高度可分的三角数
---
## Description
<section id="description">通过添加自然数生成三角数的序列。所以第7个三角形数字是1 + 2 + 3 + 4 + 5 + 6 + 7 = 28.前十个术语是: <div style="text-align: center;"> 1,3,6,10,15,21,28,36,45,55 ...... </div>让我们列出前七个三角形数字的因子: <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>我们可以看到28是第一个超过五个除数的三角形数。超过<code>n</code>除数的第一个三角形数的值是多少? </section>
# --description--
## Instructions
<section id="instructions">
</section>
通过添加自然数生成三角数的序列。所以第7个三角形数字是1 + 2 + 3 + 4 + 5 + 6 + 7 = 28.前十个术语是:
## Tests
<section id='tests'>
1,3,6,10,15,21,28,36,45,55 ......
```yml
tests:
- text: <code>divisibleTriangleNumber(5)</code>应该返回28。
testString: assert.strictEqual(divisibleTriangleNumber(5), 28);
- text: <code>divisibleTriangleNumber(23)</code>应该返回630。
testString: assert.strictEqual(divisibleTriangleNumber(23), 630);
- text: divisibleTriangleNumber <code>divisibleTriangleNumber(167)</code>应该返回1385280。
testString: assert.strictEqual(divisibleTriangleNumber(167), 1385280);
- text: divisibleTriangleNumber <code>divisibleTriangleNumber(374)</code>应该返回17907120。
testString: assert.strictEqual(divisibleTriangleNumber(374), 17907120);
- text: divisibleTriangleNumber <code>divisibleTriangleNumber(500)</code>应该返回76576500。
testString: assert.strictEqual(divisibleTriangleNumber(500), 76576500);
让我们列出前七个三角形数字的因子:
```
**1** 1
</section>
**3** 1,3
## Challenge Seed
<section id='challengeSeed'>
**6** 1,2,3,6
<div id='js-seed'>
**10** 1,2,5,10
**15** 1,3,5,15
**21** 1,3,7,21
**28** 1,2,4,7,14,28
我们可以看到28是第一个超过五个除数的三角形数。超过`n`除数的第一个三角形数的值是多少?
# --hints--
`divisibleTriangleNumber(5)`应该返回28。
```js
function divisibleTriangleNumber(n) {
// Good luck!
return true;
}
divisibleTriangleNumber(500);
assert.strictEqual(divisibleTriangleNumber(5), 28);
```
</div>
</section>
## Solution
<section id='solution'>
`divisibleTriangleNumber(23)`应该返回630。
```js
// solution required
assert.strictEqual(divisibleTriangleNumber(23), 630);
```
/section>
divisibleTriangleNumber `divisibleTriangleNumber(167)`应该返回1385280。
```js
assert.strictEqual(divisibleTriangleNumber(167), 1385280);
```
divisibleTriangleNumber `divisibleTriangleNumber(374)`应该返回17907120。
```js
assert.strictEqual(divisibleTriangleNumber(374), 17907120);
```
divisibleTriangleNumber `divisibleTriangleNumber(500)`应该返回76576500。
```js
assert.strictEqual(divisibleTriangleNumber(500), 76576500);
```
# --solutions--

View File

@ -1,55 +1,21 @@
---
id: 5900f3e41000cf542c50fef7
title: 问题120方形剩余部分
challengeType: 5
videoUrl: ''
title: 问题120方形剩余部分
---
## Description
<section id="description">设r是a-1n +a + 1n除以a2时的余数。例如如果a = 7且n = 3则r = 4263 + 83 =728≡42mod 49.并且当n变化时r也将变化但是对于a = 7结果是rmax = 42。对于3≤a≤1000找到Σrmax。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
设r是a-1n +a + 1n除以a2时的余数。例如如果a = 7且n = 3则r = 4263 + 83 =728≡42mod 49.并且当n变化时r也将变化但是对于a = 7结果是rmax = 42。对于3≤a≤1000找到Σrmax。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler120()</code>应返回333082500。
testString: assert.strictEqual(euler120(), 333082500);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler120()`应返回333082500。
```js
function euler120() {
// Good luck!
return true;
}
euler120();
assert.strictEqual(euler120(), 333082500);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3e51000cf542c50fef8
title: 问题121光盘游戏奖金
challengeType: 5
videoUrl: ''
title: 问题121光盘游戏奖金
---
## Description
<section id="description">一个包包含一个红色圆盘和一个蓝色圆盘。在有机会的游戏中玩家随机拍摄光盘并记录其颜色。每次转动后光盘返回到包中添加一个额外的红色光盘随机拍摄另一张光盘。如果玩家在游戏结束时拍摄的红色光盘多于红色光盘则玩家可以支付1英镑玩游戏并获胜。如果游戏进行了四轮比赛那么玩家获胜的概率恰好是11/120因此银行家在这场比赛中应该分配的最高奖金将是10英镑然后才会产生损失。请注意任何支付都将是一个整数磅并且还包括为玩游戏而支付的原始£1因此在给出的示例中玩家实际上赢得了9英镑。找到应该分配给单个游戏的最大奖金其中玩15个回合。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
一个包包含一个红色圆盘和一个蓝色圆盘。在有机会的游戏中玩家随机拍摄光盘并记录其颜色。每次转动后光盘返回到包中添加一个额外的红色光盘随机拍摄另一张光盘。如果玩家在游戏结束时拍摄的红色光盘多于红色光盘则玩家可以支付1英镑玩游戏并获胜。如果游戏进行了四轮比赛那么玩家获胜的概率恰好是11/120因此银行家在这场比赛中应该分配的最高奖金将是10英镑然后才会产生损失。请注意任何支付都将是一个整数磅并且还包括为玩游戏而支付的原始£1因此在给出的示例中玩家实际上赢得了9英镑。找到应该分配给单个游戏的最大奖金其中玩15个回合。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler121()</code>应返回2269。
testString: assert.strictEqual(euler121(), 2269);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler121()`应返回2269。
```js
function euler121() {
// Good luck!
return true;
}
euler121();
assert.strictEqual(euler121(), 2269);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3e61000cf542c50fef9
title: 问题122有效取幂
challengeType: 5
videoUrl: ''
title: 问题122有效取幂
---
## Description
<section id="description">最简单的计算n15的方法需要十四次乘法n×n×...×n = n15但是使用“二进制”方法可以在六次乘法中计算它n×n = n2n2×n2 = n4n4×n4 = n8n8 ×n4 = n12n12×n2 = n14n14×n = n15然而只能在五次乘法中计算它n×n = n2n2×n = n3n3×n3 = n6n6×n6 = n12n12×n3 = n15我们将定义m k是计算nk的最小乘法数;例如m15= 5.对于1≤k≤200找到Σmk</section>
# --description--
## Instructions
<section id="instructions">
</section>
最简单的计算n15的方法需要十四次乘法n×n×...×n = n15但是使用“二进制”方法可以在六次乘法中计算它n×n = n2n2×n2 = n4n4×n4 = n8n8 ×n4 = n12n12×n2 = n14n14×n = n15然而只能在五次乘法中计算它n×n = n2n2×n = n3n3×n3 = n6n6×n6 = n12n12×n3 = n15我们将定义m k是计算nk的最小乘法数;例如m15= 5.对于1≤k≤200找到Σmk
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler122()</code>应返回1582。
testString: assert.strictEqual(euler122(), 1582);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler122()`应返回1582。
```js
function euler122() {
// Good luck!
return true;
}
euler122();
assert.strictEqual(euler122(), 1582);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3e71000cf542c50fefa
title: 问题123素数正方形余数
challengeType: 5
videoUrl: ''
title: 问题123素数正方形余数
---
## Description
<section id="description">令pn为第n个素数2,3,5,7,11 ......并且当rpn-1n +pn + 1n除以pn2时令r为余数。例如当n = 3时p3 = 5并且43 + 63 =280≡5mod 25.余数首先超过109的n的最小值是7037.求出余数首次超过的n的最小值1010。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
令pn为第n个素数2,3,5,7,11 ......并且当rpn-1n +pn + 1n除以pn2时令r为余数。例如当n = 3时p3 = 5并且43 + 63 =280≡5mod 25.余数首先超过109的n的最小值是7037.求出余数首次超过的n的最小值1010。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler123()</code>应该返回21035。
testString: assert.strictEqual(euler123(), 21035);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler123()`应该返回21035。
```js
function euler123() {
// Good luck!
return true;
}
euler123();
assert.strictEqual(euler123(), 21035);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,45 @@
---
id: 5900f3e81000cf542c50fefb
title: 问题124有序的激进分子
challengeType: 5
videoUrl: ''
title: 问题124有序的激进分子
---
## Description
<section id="description"> nradn的基数是n的不同素因子的乘积。例如504 = 23×32×7因此rad504= 2×3×7 = 42.如果我们计算1≤n≤10的radn则在radn上对它们进行排序并进行排序如果激进值相等我们得到未分类<p>排序n radn </p><p> n radnk 11 </p><p> 111 22 </p><p> 222 33 </p><p> 423 42 </p><p> 824 55 </p><p> 335 66 </p><p> 936 77 </p><p> 557 82 </p><p> 668 93 </p><p> 779 1010 </p><p> 101010令Ek为有序n列中的第k个元素;例如E4= 8且E6= 9.如果radn按1≤n≤100000排序则找到E10000</p></section>
# --description--
## Instructions
<section id="instructions">
</section>
nradn的基数是n的不同素因子的乘积。例如504 = 23×32×7因此rad504= 2×3×7 = 42.如果我们计算1≤n≤10的radn则在radn上对它们进行排序并进行排序如果激进值相等我们得到未分类
## Tests
<section id='tests'>
排序n radn
```yml
tests:
- text: <code>euler124()</code>应返回21417。
testString: assert.strictEqual(euler124(), 21417);
n radnk 11
```
111 22
</section>
222 33
## Challenge Seed
<section id='challengeSeed'>
423 42
<div id='js-seed'>
824 55
335 66
936 77
557 82
668 93
779 1010
101010令Ek为有序n列中的第k个元素;例如E4= 8且E6= 9.如果radn按1≤n≤100000排序则找到E10000
# --hints--
`euler124()`应返回21417。
```js
function euler124() {
// Good luck!
return true;
}
euler124();
assert.strictEqual(euler124(), 21417);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3e91000cf542c50fefc
title: 问题125回文总和
challengeType: 5
videoUrl: ''
title: 问题125回文总和
---
## Description
<section id="description">回文数595很有意思因为它可以写成连续正方形的总和62 + 72 + 82 + 92 + 102 + 112 + 122.正好有11个以下的回文可以写成连续的平方和并且这些回文的总和是4164.注意没有包括1 = 02 + 12因为该问题涉及正整数的平方。找到小于108的所有数字的总和这些数字都是回文并且可以写为连续正方形的总和。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
回文数595很有意思因为它可以写成连续正方形的总和62 + 72 + 82 + 92 + 102 + 112 + 122.正好有11个以下的回文可以写成连续的平方和并且这些回文的总和是4164.注意没有包括1 = 02 + 12因为该问题涉及正整数的平方。找到小于108的所有数字的总和这些数字都是回文并且可以写为连续正方形的总和。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler125()</code>应该返回2906969179。
testString: assert.strictEqual(euler125(), 2906969179);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler125()`应该返回2906969179。
```js
function euler125() {
// Good luck!
return true;
}
euler125();
assert.strictEqual(euler125(), 2906969179);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3ea1000cf542c50fefd
title: 问题126长方体层
challengeType: 5
videoUrl: ''
title: 问题126长方体层
---
## Description
<section id="description">覆盖尺寸为3 x 2 x 1的长方体上每个可见面的最小立方体数量为22。 <p>如果我们在这个固体上添加第二层则需要四十六个立方体来覆盖每个可见面第三层需要七十八个立方体第四层需要一百一十八个立方体来覆盖每个可见面。然而尺寸为5 x 1 x 1的长方体上的第一层也需要22个立方体;类似地尺寸为5 x 3 x 1,7 x 2 x 1和11 x 1 x 1的长方体上的第一层都包含四十六个立方体。我们将定义Cn来表示在其一个层中包含n个立方体的长方体的数量。因此C22= 2C46= 4C78= 5并且C118= 8.结果154是n的最小值其中Cn= 10。找到n的最小值其中Cn= 1000。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
覆盖尺寸为3 x 2 x 1的长方体上每个可见面的最小立方体数量为22。
## Tests
<section id='tests'>
如果我们在这个固体上添加第二层则需要四十六个立方体来覆盖每个可见面第三层需要七十八个立方体第四层需要一百一十八个立方体来覆盖每个可见面。然而尺寸为5 x 1 x 1的长方体上的第一层也需要22个立方体;类似地尺寸为5 x 3 x 1,7 x 2 x 1和11 x 1 x 1的长方体上的第一层都包含四十六个立方体。我们将定义Cn来表示在其一个层中包含n个立方体的长方体的数量。因此C22= 2C46= 4C78= 5并且C118= 8.结果154是n的最小值其中Cn= 10。找到n的最小值其中Cn= 1000。
```yml
tests:
- text: <code>euler126()</code>应返回18522。
testString: assert.strictEqual(euler126(), 18522);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler126()`应返回18522。
```js
function euler126() {
// Good luck!
return true;
}
euler126();
assert.strictEqual(euler126(), 18522);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3ec1000cf542c50fefe
title: 问题127abc-hits
challengeType: 5
videoUrl: ''
title: 问题127abc-hits
---
## Description
<section id="description"> nradn的基数是n的不同素因子的乘积。例如504 = 23×32×7因此rad504= 2×3×7 = 42.如果出现以下情况我们将正整数abc的三元组定义为abc-hitGCD ab= GCDac= GCDbc= 1 a &lt;ba + b = c radabc&lt;c例如5,27,32是abc-hit因为GCD5,27= GCD5,32= GCD27,32= 1 5 &lt;27 5 + 27 = 32 rad4320= 30 &lt;32事实证明abc-hits是非常罕见的c &lt;1000只有31次abc命中Σc= 12523。查找Σc表示c &lt;120000。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
nradn的基数是n的不同素因子的乘积。例如504 = 23×32×7因此rad504= 2×3×7 = 42.如果出现以下情况我们将正整数abc的三元组定义为abc-hitGCD ab= GCDac= GCDbc= 1 a &lt;ba + b = c radabc&lt;c例如5,27,32是abc-hit因为GCD5,27= GCD5,32= GCD27,32= 1 5 &lt;27 5 + 27 = 32 rad4320= 30 &lt;32事实证明abc-hits是非常罕见的c &lt;1000只有31次abc命中Σc= 12523。查找Σc表示c &lt;120000。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler127()</code>应该返回18407904。
testString: assert.strictEqual(euler127(), 18407904);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler127()`应该返回18407904。
```js
function euler127() {
// Good luck!
return true;
}
euler127();
assert.strictEqual(euler127(), 18407904);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3ec1000cf542c50feff
title: 问题128六边形瓷砖差异
challengeType: 5
videoUrl: ''
title: 问题128六边形瓷砖差异
---
## Description
<section id="description">编号为1的六边形瓷砖由六个六边形瓷砖环围绕从“12点钟”开始并以逆时针方向对瓷砖2至7进行编号。新环以相同的方式添加下一个环编号为8至19,20至37,38至61依此类推。下图显示了前三个环。 <p>通过找到tile n与其六个邻居中的每一个之间的差异我们将PDn定义为那些作为素数的差异的数量。例如在瓦片8周围顺时针工作差异是12,29,11,6,1和13.因此PD8= 3.以相同的方式瓦片17周围的差异是1,17,16,1 11和10因此PD17= 2.可以证明PDn的最大值是3.如果PDn= 3的所有瓦片按升序列出以形成一个序列第10个瓦片将是271.按此顺序找到第2000个瓦片。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
编号为1的六边形瓷砖由六个六边形瓷砖环围绕从“12点钟”开始并以逆时针方向对瓷砖2至7进行编号。新环以相同的方式添加下一个环编号为8至19,20至37,38至61依此类推。下图显示了前三个环。
## Tests
<section id='tests'>
通过找到tile n与其六个邻居中的每一个之间的差异我们将PDn定义为那些作为素数的差异的数量。例如在瓦片8周围顺时针工作差异是12,29,11,6,1和13.因此PD8= 3.以相同的方式瓦片17周围的差异是1,17,16,1 11和10因此PD17= 2.可以证明PDn的最大值是3.如果PDn= 3的所有瓦片按升序列出以形成一个序列第10个瓦片将是271.按此顺序找到第2000个瓦片。
```yml
tests:
- text: <code>euler128()</code>应该返回14516824220。
testString: assert.strictEqual(euler128(), 14516824220);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler128()`应该返回14516824220。
```js
function euler128() {
// Good luck!
return true;
}
euler128();
assert.strictEqual(euler128(), 14516824220);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3ef1000cf542c50ff01
title: 问题129重新划分可分性
challengeType: 5
videoUrl: ''
title: 问题129重新划分可分性
---
## Description
<section id="description">完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位;例如R6= 111111.假设n是正整数且GCDn10= 1则可以证明总是存在一个值k其中Rk可被n整除让An成为k的最小值;例如A7= 6且A41= 5.An首先超过10的n的最小值是17.求出An首先超过1的n的最小值 - 百万。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位;例如R6= 111111.假设n是正整数且GCDn10= 1则可以证明总是存在一个值k其中Rk可被n整除让An成为k的最小值;例如A7= 6且A41= 5.An首先超过10的n的最小值是17.求出An首先超过1的n的最小值 - 百万。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler129()</code>应该返回1000023。
testString: assert.strictEqual(euler129(), 1000023);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler129()`应该返回1000023。
```js
function euler129() {
// Good luck!
return true;
}
euler129();
assert.strictEqual(euler129(), 1000023);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3ee1000cf542c50ff00
title: 问题130具有主要repunit属性的复合材料
challengeType: 5
videoUrl: ''
title: 问题130具有主要repunit属性的复合材料
---
## Description
<section id="description">完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位;例如R6= 111111.假设n是正整数且GCDn10= 1则可以证明总是存在一个值k其中Rk可被n整除让An成为k的最小值;例如A7= 6和A41= 5.对于所有素数p&gt; 5p-1可以被Ap整除。例如当p = 41时A41= 5并且40可被5整除。但是也有罕见的复合值这也是正确的;前五个例子是91,259,451,481和703.找到n的前25个复合值之和其中GCDn10= 1n-1可被An整除。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位;例如R6= 111111.假设n是正整数且GCDn10= 1则可以证明总是存在一个值k其中Rk可被n整除让An成为k的最小值;例如A7= 6和A41= 5.对于所有素数p> 5p-1可以被Ap整除。例如当p = 41时A41= 5并且40可被5整除。但是也有罕见的复合值这也是正确的;前五个例子是91,259,451,481和703.找到n的前25个复合值之和其中GCDn10= 1n-1可被An整除。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler130()</code>应返回149253。
testString: assert.strictEqual(euler130(), 149253);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler130()`应返回149253。
```js
function euler130() {
// Good luck!
return true;
}
euler130();
assert.strictEqual(euler130(), 149253);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3ef1000cf542c50ff02
title: 问题131Prime立方体伙伴关系
challengeType: 5
videoUrl: ''
title: 问题131Prime立方体伙伴关系
---
## Description
<section id="description">存在一些素数值p其中存在正整数n使得表达式n3 + n2p是完美的立方体。例如当p = 19时83 + 82×19 = 123.最令人惊讶的是对于具有此属性的每个素数n的值是唯一的并且在100之下只有四个这样的素数。一百万以下的素数有多少这个非凡的财产 </section>
# --description--
## Instructions
<section id="instructions">
</section>
存在一些素数值p其中存在正整数n使得表达式n3 + n2p是完美的立方体。例如当p = 19时83 + 82×19 = 123.最令人惊讶的是对于具有此属性的每个素数n的值是唯一的并且在100之下只有四个这样的素数。一百万以下的素数有多少这个非凡的财产
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler131()</code>应该返回173。
testString: assert.strictEqual(euler131(), 173);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler131()`应该返回173。
```js
function euler131() {
// Good luck!
return true;
}
euler131();
assert.strictEqual(euler131(), 173);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3f11000cf542c50ff03
title: 问题132大的重新安置因素
challengeType: 5
videoUrl: ''
title: 问题132大的重新安置因素
---
## Description
<section id="description">完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位。例如R10= 1111111111 = 11×41×271×9091并且这些素因子的总和是9414.求出R109的前40个素因子的总和。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位。例如R10= 1111111111 = 11×41×271×9091并且这些素因子的总和是9414.求出R109的前40个素因子的总和。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler132()</code>应返回843296。
testString: assert.strictEqual(euler132(), 843296);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler132()`应返回843296。
```js
function euler132() {
// Good luck!
return true;
}
euler132();
assert.strictEqual(euler132(), 843296);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3f21000cf542c50ff04
title: 问题133重新计算非因素
challengeType: 5
videoUrl: ''
title: 问题133重新计算非因素
---
## Description
<section id="description">完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位;例如R6= 111111.让我们考虑R10n形式的重新组合。虽然R10R100或R1000不能被17整除但R10000可被17整除。但是没有n的值R10n将除以19。事实上值得注意的是11,17,41和73是低于100的唯一四个素数可以是R10n的因子。求出十万以下所有素数的总和这些素数永远不会是R10n的因子。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
完全由1组成的数字称为repunit。我们将Rk定义为长度k的重新定位;例如R6= 111111.让我们考虑R10n形式的重新组合。虽然R10R100或R1000不能被17整除但R10000可被17整除。但是没有n的值R10n将除以19。事实上值得注意的是11,17,41和73是低于100的唯一四个素数可以是R10n的因子。求出十万以下所有素数的总和这些素数永远不会是R10n的因子。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler133()</code>应返回453647705。
testString: assert.strictEqual(euler133(), 453647705);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler133()`应返回453647705。
```js
function euler133() {
// Good luck!
return true;
}
euler133();
assert.strictEqual(euler133(), 453647705);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3f21000cf542c50ff05
title: 问题134素对对连接
challengeType: 5
videoUrl: ''
title: 问题134素对对连接
---
## Description
<section id="description">考虑连续的素数p1 = 19和p2 = 23.可以证实1219是最小的数字使得最后的数字由p1形成同时也可以被p2整除。实际上除了p1 = 3和p2 = 5之外对于每对连续质数p2&gt; p1存在n的值其中最后的数字由p1形成n可以被p2整除。设S是n的这些值中最小的。找到每对连续质数的ΣS其中5≤p1≤1000000。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑连续的素数p1 = 19和p2 = 23.可以证实1219是最小的数字使得最后的数字由p1形成同时也可以被p2整除。实际上除了p1 = 3和p2 = 5之外对于每对连续质数p2> p1存在n的值其中最后的数字由p1形成n可以被p2整除。设S是n的这些值中最小的。找到每对连续质数的ΣS其中5≤p1≤1000000。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler134()</code>应该返回18613426663617120。
testString: assert.strictEqual(euler134(), 18613426663617120);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler134()`应该返回18613426663617120。
```js
function euler134() {
// Good luck!
return true;
}
euler134();
assert.strictEqual(euler134(), 18613426663617120);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3f31000cf542c50ff06
title: 问题135同样的差异
challengeType: 5
videoUrl: ''
title: 问题135同样的差异
---
## Description
<section id="description">给定正整数xy和z是算术级数的连续项正整数n的最小值其中等式x2-y2-z2 = n恰好有两个解是n = 27342 - 272 - 202 = 122 - 92 - 62 = 27事实证明n = 1155是具有正好十个解的最小值。 n不到一百万的多少个值有十个不同的解 </section>
# --description--
## Instructions
<section id="instructions">
</section>
给定正整数xy和z是算术级数的连续项正整数n的最小值其中等式x2-y2-z2 = n恰好有两个解是n = 27342 - 272 - 202 = 122 - 92 - 62 = 27事实证明n = 1155是具有正好十个解的最小值。 n不到一百万的多少个值有十个不同的解
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler135()</code>应该返回4989。
testString: assert.strictEqual(euler135(), 4989);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler135()`应该返回4989。
```js
function euler135() {
// Good luck!
return true;
}
euler135();
assert.strictEqual(euler135(), 4989);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3f51000cf542c50ff07
title: 问题136单身人士差异
challengeType: 5
videoUrl: ''
title: 问题136单身人士差异
---
## Description
<section id="description">正整数xy和z是算术级数的连续项。假设n是一个正整数当n = 20时方程x2 - y2 - z2 = n恰好有一个解132 - 102 - 72 = 20实际上有二十五个n低于一百的值其中方程有一个独特的解决方案。 n小于五千万的有多少个值只有一个解 </section>
# --description--
## Instructions
<section id="instructions">
</section>
正整数xy和z是算术级数的连续项。假设n是一个正整数当n = 20时方程x2 - y2 - z2 = n恰好有一个解132 - 102 - 72 = 20实际上有二十五个n低于一百的值其中方程有一个独特的解决方案。 n小于五千万的有多少个值只有一个解
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler136()</code>应返回2544559。
testString: assert.strictEqual(euler136(), 2544559);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler136()`应返回2544559。
```js
function euler136() {
// Good luck!
return true;
}
euler136();
assert.strictEqual(euler136(), 2544559);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,29 @@
---
id: 5900f3f51000cf542c50ff08
title: 问题137斐波那契金块
challengeType: 5
videoUrl: ''
title: 问题137斐波那契金块
---
## Description
<section id="description">考虑无穷多项式系列AFx= xF1 + x2F2 + x3F3 + ...其中Fk是斐波纳契数列中的第k项1,1,2,3,5,8...;也就是说Fk = Fk-1 + Fk-2F1 = 1且F2 = 1.对于这个问题我们将对x的值感兴趣其中AFx是正整数。令人惊讶的是AF1/2=1/2.1 +1/22.1 +1/23.2 +1/24.3 +1/25.5 + ...... <p> = 1/2 + 1/4 + 2/8 + 3/16 + 5/32 + ...... </p><p> = 2前五个自然数的x的相应值如下所示。 </p><p> xAFx√2-111/ 22√13-2/ 33√89-5/ 84√34-3/ 55 </p><p>如果x是理性的我们将AFx称为金块因为它们变得越来越稀少;例如第10个金块是74049690.找到第15个金块。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑无穷多项式系列AFx= xF1 + x2F2 + x3F3 + ...其中Fk是斐波纳契数列中的第k项1,1,2,3,5,8...;也就是说Fk = Fk-1 + Fk-2F1 = 1且F2 = 1.对于这个问题我们将对x的值感兴趣其中AFx是正整数。令人惊讶的是AF1/2=1/2.1 +1/22.1 +1/23.2 +1/24.3 +1/25.5 + ......
## Tests
<section id='tests'>
= 1/2 + 1/4 + 2/8 + 3/16 + 5/32 + ......
```yml
tests:
- text: <code>euler137()</code>应该返回1120149658760。
testString: assert.strictEqual(euler137(), 1120149658760);
= 2前五个自然数的x的相应值如下所示。
```
xAFx√2-111/ 22√13-2/ 33√89-5/ 84√34-3/ 55
</section>
如果x是理性的我们将AFx称为金块因为它们变得越来越稀少;例如第10个金块是74049690.找到第15个金块。
## Challenge Seed
<section id='challengeSeed'>
# --hints--
<div id='js-seed'>
`euler137()`应该返回1120149658760。
```js
function euler137() {
// Good luck!
return true;
}
euler137();
assert.strictEqual(euler137(), 1120149658760);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3f61000cf542c50ff09
title: 问题138特殊的等腰三角形
challengeType: 5
videoUrl: ''
title: 问题138特殊的等腰三角形
---
## Description
<section id="description">考虑具有基本长度b = 16和腿L = 17的等腰三角形。 <p>通过使用毕达哥拉斯定理可以看出三角形的高度h =√172-82= 15比基本长度小1。当b = 272且L = 305时我们得到h = 273这比基本长度多一个这是第二个最小的等腰三角形具有h = b±1的性质。找到12个最小等腰的ΣL h = b±1且bL为正整数的三角形。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑具有基本长度b = 16和腿L = 17的等腰三角形。
## Tests
<section id='tests'>
通过使用毕达哥拉斯定理可以看出三角形的高度h =√172-82= 15比基本长度小1。当b = 272且L = 305时我们得到h = 273这比基本长度多一个这是第二个最小的等腰三角形具有h = b±1的性质。找到12个最小等腰的ΣL h = b±1且bL为正整数的三角形。
```yml
tests:
- text: <code>euler138()</code>应该返回1118049290473932。
testString: assert.strictEqual(euler138(), 1118049290473932);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler138()`应该返回1118049290473932。
```js
function euler138() {
// Good luck!
return true;
}
euler138();
assert.strictEqual(euler138(), 1118049290473932);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3f71000cf542c50ff0a
title: 问题139毕达哥拉斯瓷砖
challengeType: 5
videoUrl: ''
title: 问题139毕达哥拉斯瓷砖
---
## Description
<section id="description">abc表示具有整数长边的直角三角形的三个边。可以将四个这样的三角形放在一起以形成长度为c的正方形。例如3,4,5三角形可以放在一起形成一个5乘5的正方形中间有一个1个洞可以看到5乘5的正方形可以用二十五个平铺1个方格。 <p>但是如果使用5,12,13三角形则孔将按7乘7测量并且这些不能用于平铺13乘13平方。鉴于直角三角形的周长小于一亿有多少毕达哥拉斯三角形允许这样的平铺 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
abc表示具有整数长边的直角三角形的三个边。可以将四个这样的三角形放在一起以形成长度为c的正方形。例如3,4,5三角形可以放在一起形成一个5乘5的正方形中间有一个1个洞可以看到5乘5的正方形可以用二十五个平铺1个方格。
## Tests
<section id='tests'>
但是如果使用5,12,13三角形则孔将按7乘7测量并且这些不能用于平铺13乘13平方。鉴于直角三角形的周长小于一亿有多少毕达哥拉斯三角形允许这样的平铺
```yml
tests:
- text: <code>euler139()</code>应该返回10057761。
testString: assert.strictEqual(euler139(), 10057761);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler139()`应该返回10057761。
```js
function euler139() {
// Good luck!
return true;
}
euler139();
assert.strictEqual(euler139(), 10057761);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,63 +1,55 @@
---
id: 5900f37a1000cf542c50fe8d
title: 问题14最长的Collatz序列
challengeType: 5
videoUrl: ''
title: 问题14最长的Collatz序列
---
## Description
<section id="description">为正整数集定义以下迭代序列: <div style="padding-left: 4em;"> <var>n</var><var>n</var> / 2 <var>n</var>是偶数) </div><div style="padding-left: 4em;"> <var>n</var> →3 <var>n</var> + 1 <var>n</var>为奇数) </div>使用上面的规则并从13开始我们生成以下序列 <div style="text-align: center;"> 13→40→20→10→5→16→8→4→2→1 </div>可以看出该序列从13开始并在1结束包含10个项。虽然尚未证实Collatz问题但是认为所有起始数字都在1处结束。在给定<code>limit</code>下,哪个起始数产生最长链?注意:一旦链条启动,条款允许超过一百万。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
为正整数集定义以下迭代序列:
## Tests
<section id='tests'>
`n``n` / 2 `n`是偶数)
```yml
tests:
- text: <code>longestCollatzSequence(14)</code>应该返回9。
testString: assert.strictEqual(longestCollatzSequence(14), 9);
- text: <code>longestCollatzSequence(5847)</code>应返回3711。
testString: assert.strictEqual(longestCollatzSequence(5847), 3711);
- text: <code>longestCollatzSequence(46500)</code>应返回35655。
testString: assert.strictEqual(longestCollatzSequence(46500), 35655);
- text: <code>longestCollatzSequence(54512)</code>应返回52527。
testString: assert.strictEqual(longestCollatzSequence(54512), 52527);
- text: <code>longestCollatzSequence(1000000)</code>应返回837799。
testString: assert.strictEqual(longestCollatzSequence(100000), 77031);
`n` →3 `n` + 1 `n`为奇数)
```
使用上面的规则并从13开始我们生成以下序列
</section>
13→40→20→10→5→16→8→4→2→1
## Challenge Seed
<section id='challengeSeed'>
可以看出该序列从13开始并在1结束包含10个项。虽然尚未证实Collatz问题但是认为所有起始数字都在1处结束。在给定`limit`下,哪个起始数产生最长链?注意:一旦链条启动,条款允许超过一百万。
<div id='js-seed'>
# --hints--
`longestCollatzSequence(14)`应该返回9。
```js
function longestCollatzSequence(limit) {
// Good luck!
return true;
}
longestCollatzSequence(14);
assert.strictEqual(longestCollatzSequence(14), 9);
```
</div>
</section>
## Solution
<section id='solution'>
`longestCollatzSequence(5847)`应返回3711。
```js
// solution required
assert.strictEqual(longestCollatzSequence(5847), 3711);
```
/section>
`longestCollatzSequence(46500)`应返回35655。
```js
assert.strictEqual(longestCollatzSequence(46500), 35655);
```
`longestCollatzSequence(54512)`应返回52527。
```js
assert.strictEqual(longestCollatzSequence(54512), 52527);
```
`longestCollatzSequence(1000000)`应返回837799。
```js
assert.strictEqual(longestCollatzSequence(100000), 77031);
```
# --solutions--

View File

@ -1,55 +1,25 @@
---
id: 5900f3fa1000cf542c50ff0c
title: 问题140改进的斐波那契金块
challengeType: 5
videoUrl: ''
title: 问题140改进的斐波那契金块
---
## Description
<section id="description">考虑无穷多项式系列AGx= xG1 + x2G2 + x3G3 + ...其中Gk是二阶递归关系的第k项Gk = Gk-1 + Gk-2G1 = 1G2 = 4;也就是说1,4,5,9,14,23 ......对于这个问题我们将关注x的值其中AGx是正整数。前五个自然数的x的相应值如下所示。 <p> xAGx√5-1/ 41 2/52√22-2/ 63√137-5/ 144 1/25 </p><p>如果x是理性的我们将称AGx为金块因为它们变得越来越稀少;例如第20个金块是211345365.找到前30个金块的总和。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑无穷多项式系列AGx= xG1 + x2G2 + x3G3 + ...其中Gk是二阶递归关系的第k项Gk = Gk-1 + Gk-2G1 = 1G2 = 4;也就是说1,4,5,9,14,23 ......对于这个问题我们将关注x的值其中AGx是正整数。前五个自然数的x的相应值如下所示。
## Tests
<section id='tests'>
xAGx√5-1/ 41 2/52√22-2/ 63√137-5/ 144 1/25
```yml
tests:
- text: <code>euler140()</code>应该返回5673835352990。
testString: assert.strictEqual(euler140(), 5673835352990);
如果x是理性的我们将称AGx为金块因为它们变得越来越稀少;例如第20个金块是211345365.找到前30个金块的总和。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler140()`应该返回5673835352990。
```js
function euler140() {
// Good luck!
return true;
}
euler140();
assert.strictEqual(euler140(), 5673835352990);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3f91000cf542c50ff0b
title: 问题141调查渐进数n它们也是正方形
challengeType: 5
videoUrl: ''
title: 问题141调查渐进数n它们也是正方形
---
## Description
<section id="description">正整数n除以d商和余数分别为q和r。另外dq和r是几何序列中的连续正整数项但不一定是该顺序。例如58除以6具有商9和余数4.还可以看出4,6,9是几何序列中的连续项公共比率3/2。我们将这样的数字称为n进步。一些渐进的数字例如9和10404 = 1022恰好也是完美的正方形。所有渐进完美正方形的总和低于十万是124657.找到所有渐进完美正方形的总和低于一万亿1012</section>
# --description--
## Instructions
<section id="instructions">
</section>
正整数n除以d商和余数分别为q和r。另外dq和r是几何序列中的连续正整数项但不一定是该顺序。例如58除以6具有商9和余数4.还可以看出4,6,9是几何序列中的连续项公共比率3/2。我们将这样的数字称为n进步。一些渐进的数字例如9和10404 = 1022恰好也是完美的正方形。所有渐进完美正方形的总和低于十万是124657.找到所有渐进完美正方形的总和低于一万亿1012
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler141()</code>应该返回878454337159。
testString: assert.strictEqual(euler141(), 878454337159);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler141()`应该返回878454337159。
```js
function euler141() {
// Good luck!
return true;
}
euler141();
assert.strictEqual(euler141(), 878454337159);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f3fa1000cf542c50ff0d
title: 问题142完美的方形集合
challengeType: 5
videoUrl: ''
title: 问题142完美的方形集合
---
## Description
<section id="description">找到具有整数x&gt; y&gt; z&gt; 0的最小x + y + z使得x + yx-yx + zx-zy + zy-z都是完美正方形。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
找到具有整数x> y> z> 0的最小x + y + z使得x + yx-yx + zx-zy + zy-z都是完美正方形。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler142()</code>应返回1006193。
testString: assert.strictEqual(euler142(), 1006193);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler142()`应返回1006193。
```js
function euler142() {
// Good luck!
return true;
}
euler142();
assert.strictEqual(euler142(), 1006193);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f3fc1000cf542c50ff0e
title: 问题143研究三角形的Torricelli点
challengeType: 5
videoUrl: ''
title: 问题143研究三角形的Torricelli点
---
## Description
<section id="description">设ABC为三角形所有内角均小于120度。设X为三角形内的任意点并使XA = pXC = qXB = r。 Fermat挑战Torricelli找到X的位置使p + q + r最小化。 Torricelli能够证明如果在三角形ABC的每一侧构造等边三角形AOBBNC和AMC则AOBBNC和AMC的外接圆将在三角形内的单个点T处相交。此外他证明了T称为Torricelli / Fermat点最小化p + q + r。更值得注意的是可以证明当总和最小化时AN = BM = CO = p + q + r并且ANBM和CO也在T处相交。 <p>如果总和最小化并且abcpq和r都是正整数我们将称三角形ABC为Torricelli三角形。例如a = 399b = 455c = 511是Torricelli三角形的示例其中p + q + r = 784.找到Torricelli三角形的p + q +r≤120000的所有不同值的总和。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
设ABC为三角形所有内角均小于120度。设X为三角形内的任意点并使XA = pXC = qXB = r。 Fermat挑战Torricelli找到X的位置使p + q + r最小化。 Torricelli能够证明如果在三角形ABC的每一侧构造等边三角形AOBBNC和AMC则AOBBNC和AMC的外接圆将在三角形内的单个点T处相交。此外他证明了T称为Torricelli / Fermat点最小化p + q + r。更值得注意的是可以证明当总和最小化时AN = BM = CO = p + q + r并且ANBM和CO也在T处相交。
## Tests
<section id='tests'>
如果总和最小化并且abcpq和r都是正整数我们将称三角形ABC为Torricelli三角形。例如a = 399b = 455c = 511是Torricelli三角形的示例其中p + q + r = 784.找到Torricelli三角形的p + q +r≤120000的所有不同值的总和。
```yml
tests:
- text: <code>euler143()</code>应返回30758397。
testString: assert.strictEqual(euler143(), 30758397);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler143()`应返回30758397。
```js
function euler143() {
// Good luck!
return true;
}
euler143();
assert.strictEqual(euler143(), 30758397);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f3fc1000cf542c50ff0f
title: 问题144研究激光束的多次反射
challengeType: 5
videoUrl: ''
title: 问题144研究激光束的多次反射
---
## Description
<section id="description">在激光物理学中“白色单元”是镜像系统其充当激光束的延迟线。光束进入细胞在镜子上反弹最终恢复原状。我们将考虑的特定白色单元是椭圆形其等式为4x2 + y2 = 100。顶部对应于-0.01≤x≤+ 0.01的部分缺失,允许光线通过孔进入和退出。 <p>此问题中的光束从白色单元外部的点0.0,10.1开始光束首先在1.4-9.6)处撞击镜子。每次激光束撞击椭圆的表面时,它遵循通常的反射定律“入射角等于反射角”。也就是说,入射光束和反射光束都与入射点处的法线形成相同的角度。在左图中,红线表示激光束与白色单元壁之间的前两个接触点;蓝线表示在第一次反弹入射点处与椭圆相切的直线。给定椭圆的任意点xy处的切线的斜率m为m = -4x / y法线为垂直于入射点处的该切线。右侧的动画显示了光束的前10个反射。 </p><p>在离开之前,光束到达白细胞内表面的次数是多少? </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
在激光物理学中“白色单元”是镜像系统其充当激光束的延迟线。光束进入细胞在镜子上反弹最终恢复原状。我们将考虑的特定白色单元是椭圆形其等式为4x2 + y2 = 100。顶部对应于-0.01≤x≤+ 0.01的部分缺失,允许光线通过孔进入和退出。
## Tests
<section id='tests'>
此问题中的光束从白色单元外部的点0.0,10.1开始光束首先在1.4-9.6)处撞击镜子。每次激光束撞击椭圆的表面时,它遵循通常的反射定律“入射角等于反射角”。也就是说,入射光束和反射光束都与入射点处的法线形成相同的角度。在左图中,红线表示激光束与白色单元壁之间的前两个接触点;蓝线表示在第一次反弹入射点处与椭圆相切的直线。给定椭圆的任意点xy处的切线的斜率m为m = -4x / y法线为垂直于入射点处的该切线。右侧的动画显示了光束的前10个反射。
```yml
tests:
- text: <code>euler144()</code>应返回354。
testString: assert.strictEqual(euler144(), 354);
在离开之前,光束到达白细胞内表面的次数是多少?
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler144()`应返回354。
```js
function euler144() {
// Good luck!
return true;
}
euler144();
assert.strictEqual(euler144(), 354);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f3fd1000cf542c50ff10
title: 问题145有多少可逆数字低于十亿
challengeType: 5
videoUrl: ''
title: 问题145有多少可逆数字低于十亿
---
## Description
<section id="description">一些正整数n具有sum [n + reversen]完全由奇数十进制数字组成的属性。例如36 + 63 = 99和409 + 904 = 1313.我们将这些数字称为可逆的;所以36,63,409和904是可逆的。 n或反向n中不允许前导零。 <p>有一千个可逆数字低于一千。 </p><p>有多少可逆数字低于十亿109 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
一些正整数n具有sum \[n + reversen]完全由奇数十进制数字组成的属性。例如36 + 63 = 99和409 + 904 = 1313.我们将这些数字称为可逆的;所以36,63,409和904是可逆的。 n或反向n中不允许前导零。
## Tests
<section id='tests'>
有一千个可逆数字低于一千。
```yml
tests:
- text: <code>euler145()</code>应该返回608720。
testString: assert.strictEqual(euler145(), 608720);
有多少可逆数字低于十亿109
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler145()`应该返回608720。
```js
function euler145() {
// Good luck!
return true;
}
euler145();
assert.strictEqual(euler145(), 608720);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,59 +1,23 @@
---
id: 5900f3fe1000cf542c50ff11
title: 问题146调查素数模式
challengeType: 5
videoUrl: ''
title: 问题146调查素数模式
---
## Description
<section id="description">
# --description--
整数n2 + 1n2 + 3n2 + 7n2 + 9n2 + 13和n2 + 27为其连续质数的最小正整数n为10。所有小于100万的整数n的总和 是1242490。
所有小于1.5亿的整数n的总和是多少
</section>
## Instructions
<section id="instructions">
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler146()</code>应该返回676333270。
testString: assert.strictEqual(euler146(), 676333270);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler146()`应该返回676333270。
```js
function euler146() {
// Good luck!
return true;
}
euler146();
assert.strictEqual(euler146(), 676333270);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,27 @@
---
id: 5900f3ff1000cf542c50ff12
title: 问题147交叉阴影网格中的矩形
challengeType: 5
videoUrl: ''
title: 问题147交叉阴影网格中的矩形
---
## Description
<section id="description">在3x2交叉阴影网格中如图所示总共37个不同的矩形可以位于该网格内。 <p>有5个小于3x2的网格垂直和水平尺寸很重要即1x1,2x1,3x1,1x2和2x2。如果它们中的每一个都是交叉阴影线则可以在这些较小的网格中放置以下数量的不同矩形1x11 2x14 3x18 1x24 2x218 </p><p>将它们添加到3x2网格中的37个总共72个不同的矩形可以位于3x2和更小的网格中。 </p><p>在47x43和更小的网格中可以放置多少个不同的矩形 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
在3x2交叉阴影网格中如图所示总共37个不同的矩形可以位于该网格内。
## Tests
<section id='tests'>
有5个小于3x2的网格垂直和水平尺寸很重要即1x1,2x1,3x1,1x2和2x2。如果它们中的每一个都是交叉阴影线则可以在这些较小的网格中放置以下数量的不同矩形1x11 2x14 3x18 1x24 2x218
```yml
tests:
- text: <code>euler147()</code>应该返回846910284。
testString: assert.strictEqual(euler147(), 846910284);
将它们添加到3x2网格中的37个总共72个不同的矩形可以位于3x2和更小的网格中。
```
在47x43和更小的网格中可以放置多少个不同的矩形
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler147()`应该返回846910284。
```js
function euler147() {
// Good luck!
return true;
}
euler147();
assert.strictEqual(euler147(), 846910284);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,77 @@
---
id: 5900f4021000cf542c50ff14
title: 问题148探索帕斯卡的三角形
challengeType: 5
videoUrl: ''
title: 问题148探索帕斯卡的三角形
---
## Description
<section id="description">我们可以很容易地验证Pascal三角形的前七行中的所有条目都不能被7整除 <p> 1 </p><p> 1 </p><p> 1 </p><p> 1 </p><p> 2 </p><p> 1 </p><p> 1 </p><p> 3 </p><p> 3 </p><p> 1 </p><p> 1 </p><p> 4 </p><p> 6 </p><p> 4 </p><p> 1 </p><p> 1 </p><p></p><p> 10 </p><p> 10 </p><p></p><p> 1 1 </p><p> 6 </p><p> 15 </p><p> 20 </p><p> 15 </p><p> 6 </p><p> 1然而如果我们检查前100行我们会发现5050个条目中只有2361个不能被7整除。 </p><p>找到Pascal三角形的前十亿109行中不能被7整除的条目数。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
我们可以很容易地验证Pascal三角形的前七行中的所有条目都不能被7整除
## Tests
<section id='tests'>
1
```yml
tests:
- text: <code>euler148()</code>应该返回2129970655314432。
testString: assert.strictEqual(euler148(), 2129970655314432);
1
```
1
</section>
1
## Challenge Seed
<section id='challengeSeed'>
2
<div id='js-seed'>
1
1
3
3
1
1
4
6
4
1
1
10
10
1 1
6
15
20
15
6
1然而如果我们检查前100行我们会发现5050个条目中只有2361个不能被7整除。
找到Pascal三角形的前十亿109行中不能被7整除的条目数。
# --hints--
`euler148()`应该返回2129970655314432。
```js
function euler148() {
// Good luck!
return true;
}
euler148();
assert.strictEqual(euler148(), 2129970655314432);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,14 +1,13 @@
---
id: 5900f4021000cf542c50ff13
title: 问题149搜索最大和子序列
challengeType: 5
videoUrl: ''
title: 问题149搜索最大和子序列
---
## Description
<section id="description">
查看下表可以很容易地验证任意方向水平垂直对角或反对角上相邻数字的最大和为16= 8 + 7 + 1
# --description--
查看下表可以很容易地验证任意方向水平垂直对角或反对角上相邻数字的最大和为16= 8 + 7 + 1
253296513273184 8
@ -16,58 +15,21 @@ title: 问题149搜索最大和子序列
首先,使用称为“滞后斐波那契生成器”的特定形式生成四百万个伪随机数:
对于1≤k≤55sk = [100003 200003k + 300007k3]模1000000 500000。
对于56≤k≤4000000sk = [sk-24 + sk-55 + 1000000]模1000000 500000。
对于1≤k≤55sk = \[100003 200003k + 300007k3]模1000000 500000。 对于56≤k≤4000000sk = \[sk-24 + sk-55 + 1000000]模1000000 500000。
因此s10 = -393027s100 = 86613。
然后将s的项排列在2000×2000表中使用前2000个数字顺序填充第一行使用后2000个数字填充第二行依此类推。
最后,在任何方向(水平,垂直,对角线或反对角线)上找到(任意数量)相邻项的最大和。
</section>
## Instructions
<section id="instructions">
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler149()</code>应该返回52852124。
testString: assert.strictEqual(euler149(), 52852124);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler149()`应该返回52852124。
```js
function euler149() {
// Good luck!
return true;
}
euler149();
assert.strictEqual(euler149(), 52852124);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,59 +1,35 @@
---
id: 5900f37b1000cf542c50fe8e
title: 问题15格子路径
challengeType: 5
videoUrl: ''
title: 问题15格子路径
---
## Description
<section id="description">从2×2网格的左上角开始只能向右和向下移动右下角有6条路线。 <img class="img-responsive center-block" alt="6 2乘2网格的图表显示了右下角的所有路线" src="https://cdn-media-1.freecodecamp.org/imgr/1Atixoj.gif"><p>通过给定的<code>gridSize</code>有多少这样的路由? </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
从2×2网格的左上角开始只能向右和向下移动右下角有6条路线。 ![6 2乘2网格的图表显示了右下角的所有路线](https://cdn-media-1.freecodecamp.org/imgr/1Atixoj.gif)
## Tests
<section id='tests'>
通过给定的`gridSize`有多少这样的路由?
```yml
tests:
- text: <code>latticePaths(4)</code>应该返回70。
testString: assert.strictEqual(latticePaths(4), 70);
- text: <code>latticePaths(9)</code>应该返回48620。
testString: assert.strictEqual(latticePaths(9), 48620);
- text: <code>latticePaths(20)</code>应该返回137846528820。
testString: assert.strictEqual(latticePaths(20), 137846528820);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`latticePaths(4)`应该返回70。
```js
function latticePaths(gridSize) {
// Good luck!
return true;
}
latticePaths(4);
assert.strictEqual(latticePaths(4), 70);
```
</div>
</section>
## Solution
<section id='solution'>
`latticePaths(9)`应该返回48620。
```js
// solution required
assert.strictEqual(latticePaths(9), 48620);
```
/section>
`latticePaths(20)`应该返回137846528820。
```js
assert.strictEqual(latticePaths(20), 137846528820);
```
# --solutions--

View File

@ -1,55 +1,37 @@
---
id: 5900f4031000cf542c50ff15
title: 问题150在三角形阵列中搜索具有最小和的子三角形
challengeType: 5
videoUrl: ''
title: 问题150在三角形阵列中搜索具有最小和的子三角形
---
## Description
<section id="description">在正整数和负整数的三角形阵列中,我们希望找到一个子三角形,使得它包含的数字之和尽可能小。在下面的示例中,可以很容易地验证标记的三角形满足具有-42的总和的条件。 <p>我们希望制作一个包含一千行的三角形数组因此我们使用一种随机数生成器称为线性同余生成器生成5009个伪随机数sk范围为±219如下所示t= 0 </p><p>对于k = 1到k = 500500 </p><p> t=615949 * t + 797807modulo 220 sk= t-219因此s1 = 273519s2 = -153582s3 = 450905等我们的三角形数组然后使用伪随机数形成 </p><p> s1 s2 s3 s4 s5 s6 </p><p> s7 s8 s9 s10 ...... </p><p>子三角形可以从数组的任何元素开始,并在我们喜欢的范围内向下延伸(从下一行直接接收它下面的两个元素,之后直接从该行下面的三个元素,依此类推)。 </p><p> “三角形的总和”定义为它包含的所有元素的总和。 </p><p>找到可能的最小子三角形和。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
在正整数和负整数的三角形阵列中,我们希望找到一个子三角形,使得它包含的数字之和尽可能小。在下面的示例中,可以很容易地验证标记的三角形满足具有-42的总和的条件。
## Tests
<section id='tests'>
我们希望制作一个包含一千行的三角形数组因此我们使用一种随机数生成器称为线性同余生成器生成5009个伪随机数sk范围为±219如下所示t= 0
```yml
tests:
- text: <code>euler150()</code>应返回-271248680。
testString: assert.strictEqual(euler150(), -271248680);
对于k = 1到k = 500500
```
t=615949 \* t + 797807modulo 220 sk= t-219因此s1 = 273519s2 = -153582s3 = 450905等我们的三角形数组然后使用伪随机数形成
</section>
s1 s2 s3 s4 s5 s6
## Challenge Seed
<section id='challengeSeed'>
s7 s8 s9 s10 ......
<div id='js-seed'>
子三角形可以从数组的任何元素开始,并在我们喜欢的范围内向下延伸(从下一行直接接收它下面的两个元素,之后直接从该行下面的三个元素,依此类推)。
“三角形的总和”定义为它包含的所有元素的总和。
找到可能的最小子三角形和。
# --hints--
`euler150()`应返回-271248680。
```js
function euler150() {
// Good luck!
return true;
}
euler150();
assert.strictEqual(euler150(), -271248680);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f4031000cf542c50ff16
title: 问题151标准尺寸的纸张期望值问题
challengeType: 5
videoUrl: ''
title: 问题151标准尺寸的纸张期望值问题
---
## Description
<section id="description">印刷车间每周运行16批工作每批需要一张A5尺寸的特殊颜色纸。每个星期一早上工头打开一个新信封里面装着一张大小为A1的特殊纸张。他继续把它切成两半从而得到两张A2尺寸的纸。然后他将其中一个切成两半得到两张A3尺寸依此类推直到他获得了本周第一批所需的A5尺寸纸张。所有未使用的纸张都放回信封中。 <p>在每个后续批次开始时他随机从信封中取出一张纸。如果它的大小为A5他会使用它。如果它更大他会重复“切成两半”的程序直到他有他需要的东西任何剩余的床单总是放回信封里。排除本周的第一批和最后一批找到工头在信封中找到一张纸的预期次数每周。使用格式x.xxxxxx将您的答案四舍五入到小数点后六位。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
印刷车间每周运行16批工作每批需要一张A5尺寸的特殊颜色纸。每个星期一早上工头打开一个新信封里面装着一张大小为A1的特殊纸张。他继续把它切成两半从而得到两张A2尺寸的纸。然后他将其中一个切成两半得到两张A3尺寸依此类推直到他获得了本周第一批所需的A5尺寸纸张。所有未使用的纸张都放回信封中。
## Tests
<section id='tests'>
在每个后续批次开始时他随机从信封中取出一张纸。如果它的大小为A5他会使用它。如果它更大他会重复“切成两半”的程序直到他有他需要的东西任何剩余的床单总是放回信封里。排除本周的第一批和最后一批找到工头在信封中找到一张纸的预期次数每周。使用格式x.xxxxxx将您的答案四舍五入到小数点后六位。
```yml
tests:
- text: '<code>euler151()</ code>应该返回0.464399。'
testString: assert.strictEqual(euler151(), 0.464399);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
<code>euler151()&lt;/ code>应该返回0.464399。
```js
function euler151() {
// Good luck!
return true;
}
euler151();
assert.strictEqual(euler151(), 0.464399);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,61 +1,25 @@
---
id: 5900f4041000cf542c50ff17
title: 问题152将一半写为倒数平方和
challengeType: 5
videoUrl: ''
title: 问题152将一半写为倒数平方和
---
## Description
<section id="description">
# --description--
有几种方法可以使用不同的整数将数字1/2写成反平方和。
例如,可以使用数字{2,3,4,5,7,12,15,20,28,35}
实际上仅使用2到45之间的整数包括2和45完全可以通过三种方式来实现其余两种方式是{2,3,4,6,7,9,10,20,28,35,36,45 }和{2,3,4,6,7,9,12,15,28,30,35,36,45}。
使用2到80之间含2和80的不同整数有多少种方法可以将数字1/2写成反平方和
</section>
实际上仅使用2到45之间的整数包括2和45完全可以通过三种方式来实现其余两种方式是{2,3,4,6,7,9,10,20,28,35,36,45 }和{2,3,4,6,7,9,12,15,28,30,35,36,45}。 使用2到80之间含2和80的不同整数有多少种方法可以将数字1/2写成反平方和
## Instructions
<section id="instructions">
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>euler152()</ code>应该返回301。'
testString: assert.strictEqual(euler152(), 301);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
<code>euler152()&lt;/ code>应该返回301。
```js
function euler152() {
// Good luck!
return true;
}
euler152();
assert.strictEqual(euler152(), 301);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,53 @@
---
id: 5900f4051000cf542c50ff18
title: 问题153调查高斯整数
challengeType: 5
videoUrl: ''
title: 问题153调查高斯整数
---
## Description
<section id="description">众所周知方程x2 = -1没有实数x的解。 <p>然而如果我们引入虚数i则该等式具有两个解x = i且x = -i。 </p><p>如果我们更进一步等式x-32 = -4有两个复数解x = 3 + 2i和x = 3-2i。 x = 3 + 2i和x = 3-2i被称为彼此的复共轭。 </p><p>形式a + bi的数字称为复数。 </p><p>通常,+ bi和a-bi是彼此的复共轭。高斯整数是复数a + bi使得a和b都是整数。 </p><p>常规整数也是高斯整数b = 0</p><p>为了将它们与b≠0的高斯整数区分开来我们称这样的整数为“有理整数”。 </p><p>如果结果也是高斯整数则高斯整数称为有理整数n的除数。 </p><p>例如如果我们将5除以1 + 2i我们可以通过以下方式简化 </p><p>通过1 + 2i的复共轭乘以分子和分母1-2i。 </p><p>结果是。 </p><p>所以1 + 2i是5的除数。 </p><p>请注意1 + i不是5的除数因为。 </p><p>还要注意如果高斯整数a + bi是有理整数n的除数则其复共轭a-bi也是n的除数。实际上5有六个除数使得实部是正的{1,1 + 2i1 - 2i2 + i2 - i5}。 </p><p>以下是前五个正整数的所有除数的表: </p><p> n高斯整数除数具有正实数partSum sn </p><p> divisors111 21,1 + i1-i25 31,34 41,1 + i1-i2,2 + 2i2-2i413 51,1 + 2i1-2i2 + i 2-i512对于具有正实部的除数那么我们有。对于1≤n≤105Σsn= 17924657155。什么是Σsn1≤n≤108 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
众所周知方程x2 = -1没有实数x的解。
## Tests
<section id='tests'>
然而如果我们引入虚数i则该等式具有两个解x = i且x = -i。
```yml
tests:
- text: <code>euler153()</code>应该返回17971254122360636。
testString: assert.strictEqual(euler153(), 17971254122360636);
如果我们更进一步等式x-32 = -4有两个复数解x = 3 + 2i和x = 3-2i。 x = 3 + 2i和x = 3-2i被称为彼此的复共轭。
```
形式a + bi的数字称为复数。
</section>
通常,+ bi和a-bi是彼此的复共轭。高斯整数是复数a + bi使得a和b都是整数。
## Challenge Seed
<section id='challengeSeed'>
常规整数也是高斯整数b = 0
<div id='js-seed'>
为了将它们与b≠0的高斯整数区分开来我们称这样的整数为“有理整数”。
如果结果也是高斯整数则高斯整数称为有理整数n的除数。
例如如果我们将5除以1 + 2i我们可以通过以下方式简化
通过1 + 2i的复共轭乘以分子和分母1-2i。
结果是。
所以1 + 2i是5的除数。
请注意1 + i不是5的除数因为。
还要注意如果高斯整数a + bi是有理整数n的除数则其复共轭a-bi也是n的除数。实际上5有六个除数使得实部是正的{1,1 + 2i1 - 2i2 + i2 - i5}。
以下是前五个正整数的所有除数的表:
n高斯整数除数具有正实数partSum sn
divisors111 21,1 + i1-i25 31,34 41,1 + i1-i2,2 + 2i2-2i413 51,1 + 2i1-2i2 + i 2-i512对于具有正实部的除数那么我们有。对于1≤n≤105Σsn= 17924657155。什么是Σsn1≤n≤108
# --hints--
`euler153()`应该返回17971254122360636。
```js
function euler153() {
// Good luck!
return true;
}
euler153();
assert.strictEqual(euler153(), 17971254122360636);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f4071000cf542c50ff19
title: 问题154探索帕斯卡的金字塔
challengeType: 5
videoUrl: ''
title: 问题154探索帕斯卡的金字塔
---
## Description
<section id="description">使用球形球构造三角形金字塔,使得每个球恰好位于下一个较低水平的三个球上。 <p>然后我们计算从顶点到每个位置的路径数量路径从顶点开始并向下前进到当前位置正下方的三个球体中的任何一个。因此到达某个位置的路径数是紧接在其上方的数字的总和取决于位置在其上方最多有三个数字。结果是Pascal的金字塔每个级别n的数字是三项式展开x + y + zn的系数。 x + y + z200000的扩展中有多少个系数是1012的倍数 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
使用球形球构造三角形金字塔,使得每个球恰好位于下一个较低水平的三个球上。
## Tests
<section id='tests'>
然后我们计算从顶点到每个位置的路径数量路径从顶点开始并向下前进到当前位置正下方的三个球体中的任何一个。因此到达某个位置的路径数是紧接在其上方的数字的总和取决于位置在其上方最多有三个数字。结果是Pascal的金字塔每个级别n的数字是三项式展开x + y + zn的系数。 x + y + z200000的扩展中有多少个系数是1012的倍数
```yml
tests:
- text: <code>euler154()</code>应该返回479742450。
testString: assert.strictEqual(euler154(), 479742450);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler154()`应该返回479742450。
```js
function euler154() {
// Good luck!
return true;
}
euler154();
assert.strictEqual(euler154(), 479742450);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,27 @@
---
id: 5900f4081000cf542c50ff1a
title: 问题155计算电容器电路
challengeType: 5
videoUrl: ''
title: 问题155计算电容器电路
---
## Description
<section id="description">电路仅使用相同值C的相同电容器。 <p>电容器可以串联或并联连接以形成子单元子单元然后可以与其他电容器或其他子单元串联或并联连接以形成更大的子单元以此类推直到最终电路。使用这个简单的程序和多达n个相同的电容器我们可以制造具有一系列不同总电容的电路。例如使用最多n = 3个电容器每个电容器为60 F我们可以获得以下7个不同的总电容值 </p><p>如果我们用Dn表示当使用多达n个等值电容器时我们可以获得的不同总电容值的数量和上述简单程序我们得到D1= 1D2= 3 D3= 7 ...求D18。提醒当并联电容器C1C2等时总电容为CT = C1 + C2 + ...... </p><p>而当它们串联连接时,总电容由下式给出: </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
电路仅使用相同值C的相同电容器。
## Tests
<section id='tests'>
电容器可以串联或并联连接以形成子单元子单元然后可以与其他电容器或其他子单元串联或并联连接以形成更大的子单元以此类推直到最终电路。使用这个简单的程序和多达n个相同的电容器我们可以制造具有一系列不同总电容的电路。例如使用最多n = 3个电容器每个电容器为60 F我们可以获得以下7个不同的总电容值
```yml
tests:
- text: <code>euler155()</code>应返回3857447。
testString: assert.strictEqual(euler155(), 3857447);
如果我们用Dn表示当使用多达n个等值电容器时我们可以获得的不同总电容值的数量和上述简单程序我们得到D1= 1D2= 3 D3= 7 ...求D18。提醒当并联电容器C1C2等时总电容为CT = C1 + C2 + ......
```
而当它们串联连接时,总电容由下式给出:
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler155()`应返回3857447。
```js
function euler155() {
// Good luck!
return true;
}
euler155();
assert.strictEqual(euler155(), 3857447);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,35 @@
---
id: 5900f4091000cf542c50ff1b
title: 问题156计数数字
challengeType: 5
videoUrl: ''
title: 问题156计数数字
---
## Description
<section id="description">从零开始自然数字在基数10中写下如下所示 <p> 0 1 2 3 4 5 6 7 8 9 10 11 12 .... </p><p>考虑数字d = 1。在我们写下每个数字n后我们将更新已发生的数字并将此数字称为fn1。那么fn1的第一个值如下 </p><p> nfn100 11 21 31 41 51 61 71 81 91 102 114 125 </p><p>请注意fn1永远不等于3。 </p><p>因此等式fn1= n的前两个解是n = 0并且n = 1。下一个解决方案是n = 199981。以相同的方式函数fnd给出在写入数字n之后已经写下的总位数d。 </p><p>实际上对于每个数字d≠0,0是方程fnd= n的第一个解。设sd是fnd= n的所有解的总和。 </p><p>你得到s1= 22786974071。找到Σsd的1≤d≤9。注意如果对于某些n对于多于一个d的值fnd= n对于d的每个值再次计算n的这个值。 FNd= N。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
从零开始自然数字在基数10中写下如下所示
## Tests
<section id='tests'>
0 1 2 3 4 5 6 7 8 9 10 11 12 ....
```yml
tests:
- text: <code>euler156</code>应该返回21295121502550。
testString: assert.strictEqual(euler156(), 21295121502550);
考虑数字d = 1。在我们写下每个数字n后我们将更新已发生的数字并将此数字称为fn1。那么fn1的第一个值如下
```
nfn100 11 21 31 41 51 61 71 81 91 102 114 125
</section>
请注意fn1永远不等于3。
## Challenge Seed
<section id='challengeSeed'>
因此等式fn1= n的前两个解是n = 0并且n = 1。下一个解决方案是n = 199981。以相同的方式函数fnd给出在写入数字n之后已经写下的总位数d。
<div id='js-seed'>
实际上对于每个数字d≠0,0是方程fnd= n的第一个解。设sd是fnd= n的所有解的总和。
你得到s1= 22786974071。找到Σsd的1≤d≤9。注意如果对于某些n对于多于一个d的值fnd= n对于d的每个值再次计算n的这个值。 FNd= N。
# --hints--
`euler156`应该返回21295121502550。
```js
function euler156() {
// Good luck!
return true;
}
euler156();
assert.strictEqual(euler156(), 21295121502550);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,80 +1,67 @@
---
id: 5900f4091000cf542c50ff1c
title: 问题157解决丢番图方程
challengeType: 5
videoUrl: ''
title: 问题157解决丢番图方程
---
## Description
<section id="description">
# --description--
491/5000
考虑具有abpn个正整数且a≤b的双色子方程1 / a + 1 / b = p / 10n。
对于n = 1此等式有20个解决方案如下所示
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
对于1≤n≤9该方程有多少个解
</section>
## Instructions
<section id="instructions">
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: <code>euler157()</code>应返回53490。
testString: assert.strictEqual(euler157(), 53490);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler157()`应返回53490。
```js
function euler157() {
// Good luck!
return true;
}
euler157();
assert.strictEqual(euler157(), 53490);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f40a1000cf542c50ff1d
title: 问题158探索在其邻居之后只有一个字符按字典顺序出现的字符串
challengeType: 5
videoUrl: ''
title: 问题158探索在其邻居之后只有一个字符按字典顺序出现的字符串
---
## Description
<section id="description">从字母表的26个字母中取三个不同的字母可以形成长度为3的字符串。例如&#39;abc&#39;&#39;hat&#39;&#39;zyx&#39;。当我们研究这三个例子时,我们看到对于&#39;abc&#39;,两个字符在其左边的邻居之后以字典方式出现。对于“帽子”,只有一个字符在其左边的邻居之后按字典顺序排列。对于&#39;zyx&#39;在左边的邻居之后字典上有零个字符。总共有10400个长度为3的字符串其中一个字符在其左边的邻居之后按字典顺序排列。我们现在考虑字母表中n≤26个不同字符的字符串。对于每个npn是长度为n的字符串的数量正好一个字符在其左边的邻居之后按字典顺序排列。 pn的最大值是多少 </section>
# --description--
## Instructions
<section id="instructions">
</section>
从字母表的26个字母中取三个不同的字母可以形成长度为3的字符串。例如'abc''hat'和'zyx'。当我们研究这三个例子时,我们看到对于'abc',两个字符在其左边的邻居之后以字典方式出现。对于“帽子”,只有一个字符在其左边的邻居之后按字典顺序排列。对于'zyx'在左边的邻居之后字典上有零个字符。总共有10400个长度为3的字符串其中一个字符在其左边的邻居之后按字典顺序排列。我们现在考虑字母表中n≤26个不同字符的字符串。对于每个npn是长度为n的字符串的数量正好一个字符在其左边的邻居之后按字典顺序排列。 pn的最大值是多少
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler158()</code>应该返回409511334375。
testString: assert.strictEqual(euler158(), 409511334375);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler158()`应该返回409511334375。
```js
function euler158() {
// Good luck!
return true;
}
euler158();
assert.strictEqual(euler158(), 409511334375);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f40c1000cf542c50ff1e
title: 问题159因子的数字根和
challengeType: 5
videoUrl: ''
title: 问题159因子的数字根和
---
## Description
<section id="description">复合数可以通过许多不同的方式考虑。例如不包括乘以一24可以用7种不同的方式考虑 <p> 24 = 2x2x2x3 24 = 2x3x4 24 = 2x2x6 24 = 4x6 24 = 3x8 24 = 2x12 24 = 24 </p><p>回想一下基数为10的数字的数字根是通过将该数字的数字加在一起而得到的并重复该过程直到到达的数字小于10.因此467的数字根是8。应将数字根和DRS称为我们数字的各个因子的数字根的总和。下图显示了所有DRS值24.因子分解数字根Sum2x2x2x3 92x3x4 92x2x6 104x6 103x8 112x12 524 6 24的最大数字根和为11.函数mdrsn给出n的最大数字根和。所以mdrs24= 11。找到Σmdrsn为1 &lt;n &lt;1,000,000。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
复合数可以通过许多不同的方式考虑。例如不包括乘以一24可以用7种不同的方式考虑
## Tests
<section id='tests'>
24 = 2x2x2x3 24 = 2x3x4 24 = 2x2x6 24 = 4x6 24 = 3x8 24 = 2x12 24 = 24
```yml
tests:
- text: <code>euler159()</code>应返回14489159。
testString: assert.strictEqual(euler159(), 14489159);
回想一下基数为10的数字的数字根是通过将该数字的数字加在一起而得到的并重复该过程直到到达的数字小于10.因此467的数字根是8。应将数字根和DRS称为我们数字的各个因子的数字根的总和。下图显示了所有DRS值24.因子分解数字根Sum2x2x2x3 92x3x4 92x2x6 104x6 103x8 112x12 524 6 24的最大数字根和为11.函数mdrsn给出n的最大数字根和。所以mdrs24= 11。找到Σmdrsn为1 &lt;n &lt;1,000,000。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler159()`应返回14489159。
```js
function euler159() {
// Good luck!
return true;
}
euler159();
assert.strictEqual(euler159(), 14489159);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,62 +1,33 @@
---
id: 5900f37d1000cf542c50fe8f
title: 问题16电源数字总和
challengeType: 5
videoUrl: ''
title: 问题16电源数字总和
---
## Description
<section id="description">
2 <sup> 15 </ sup> = 32768其位数之和为3 + 2 + 7 + 6 + 8 = 26。
2 <sup> <code>指数</ code> </ sup>的数字总和是多少?
</section>
# --description--
## Instructions
<section id="instructions">
</section>
2 <sup>15<!-- sup-->= 32768其位数之和为3 + 2 + 7 + 6 + 8 = 26。 2 <sup><code>指数<!-- code--><!-- sup-->的数字总和是多少?</code></sup></sup>
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>powerDigitSum(15)</code>应该返回26。
testString: assert.strictEqual(powerDigitSum(15), 26);
- text: <code>powerDigitSum(128)</code>应该返回166。
testString: assert.strictEqual(powerDigitSum(128), 166);
- text: <code>powerDigitSum(1000)</code>应返回1366。
testString: assert.strictEqual(powerDigitSum(1000), 1366);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`powerDigitSum(15)`应该返回26。
```js
function powerDigitSum(exponent) {
// Good luck!
return true;
}
powerDigitSum(15);
assert.strictEqual(powerDigitSum(15), 26);
```
</div>
</section>
## Solution
<section id='solution'>
`powerDigitSum(128)`应该返回166。
```js
// solution required
assert.strictEqual(powerDigitSum(128), 166);
```
/section>
`powerDigitSum(1000)`应返回1366。
```js
assert.strictEqual(powerDigitSum(1000), 1366);
```
# --solutions--

View File

@ -1,55 +1,21 @@
---
id: 5900f40d1000cf542c50ff1f
title: 问题160因子尾随数字
challengeType: 5
videoUrl: ''
title: 问题160因子尾随数字
---
## Description
<section id="description">对于任何N让fN为N中尾随零之前的最后五位数。例如9 = 362880所以f9= 36288 10 = 3628800所以f10= 36288 20 = 2432902008176640000所以f20= 17664查找f1,000,000,000,000 </section>
# --description--
## Instructions
<section id="instructions">
</section>
对于任何N让fN为N中尾随零之前的最后五位数。例如9 = 362880所以f9= 36288 10 = 3628800所以f10= 36288 20 = 2432902008176640000所以f20= 17664查找f1,000,000,000,000
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler160()</code>应返回16576。
testString: assert.strictEqual(euler160(), 16576);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler160()`应返回16576。
```js
function euler160() {
// Good luck!
return true;
}
euler160();
assert.strictEqual(euler160(), 16576);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,27 @@
---
id: 5900f40d1000cf542c50ff20
title: 问题161Triominoes
challengeType: 5
videoUrl: ''
title: 问题161Triominoes
---
## Description
<section id="description">三角形是由三个通过边缘连接的正方形组成的形状。有两种基本形式: <p>如果考虑所有可能的方向,则有六个: </p><p>任何n×m网格的nxm可以被3整除可以用三角形平铺。如果我们考虑通过反射或从另一个平铺旋转获得的倾斜不同有41种方式可以使用三角形平铺2乘9的网格 </p><p>有多少种方式可以通过三角形以这种方式平铺9乘12的网格 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
三角形是由三个通过边缘连接的正方形组成的形状。有两种基本形式:
## Tests
<section id='tests'>
如果考虑所有可能的方向,则有六个:
```yml
tests:
- text: <code>euler161()</code>应该返回20574308184277972。
testString: assert.strictEqual(euler161(), 20574308184277972);
任何n×m网格的nxm可以被3整除可以用三角形平铺。如果我们考虑通过反射或从另一个平铺旋转获得的倾斜不同有41种方式可以使用三角形平铺2乘9的网格
```
有多少种方式可以通过三角形以这种方式平铺9乘12的网格
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler161()`应该返回20574308184277972。
```js
function euler161() {
// Good luck!
return true;
}
euler161();
assert.strictEqual(euler161(), 20574308184277972);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f40e1000cf542c50ff21
title: 问题162十六进制数
challengeType: 5
videoUrl: ''
title: 问题162十六进制数
---
## Description
<section id="description">在十六进制数中系统使用16个不同的数字表示数字0,1,2,3,4,5,6,7,8,9ABCDEF写入时的十六进制数AF在十进制数系统中等于10x16 + 15 = 175。在3位十六进制数10A1A0A10和A01中数字0,1和A都存在。就像用十进制数写的数字一样我们写十六进制数而不带前导零。包含最多十六个十六进制数字的十六进制数是多少所有数字0,1和A至少出现一次将答案作为十六进制数字给出。 ABCDE和F大写没有任何前导或尾随代码将数字标记为十六进制且没有前导零例如1A3F而不是1a3f而不是0x1a3f而不是$ 1A3F而不是1A3F而不是0000001A3F </section>
# --description--
## Instructions
<section id="instructions">
</section>
在十六进制数中系统使用16个不同的数字表示数字0,1,2,3,4,5,6,7,8,9ABCDEF写入时的十六进制数AF在十进制数系统中等于10x16 + 15 = 175。在3位十六进制数10A1A0A10和A01中数字0,1和A都存在。就像用十进制数写的数字一样我们写十六进制数而不带前导零。包含最多十六个十六进制数字的十六进制数是多少所有数字0,1和A至少出现一次将答案作为十六进制数字给出。 ABCDE和F大写没有任何前导或尾随代码将数字标记为十六进制且没有前导零例如1A3F而不是1a3f而不是0x1a3f而不是$ 1A3F而不是1A3F而不是0000001A3F
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler162()</code> 应该返回3D58725572C62302。
testString: assert.strictEqual(euler162(), '3D58725572C62302');
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler162()` 应该返回3D58725572C62302。
```js
function euler162() {
// Good luck!
return true;
}
euler162();
assert.strictEqual(euler162(), '3D58725572C62302');
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f40f1000cf542c50ff22
title: 问题163阴影线三角形
challengeType: 5
videoUrl: ''
title: 问题163阴影线三角形
---
## Description
<section id="description">考虑等边三角形其中从每个顶点到相对侧的中间绘制直线例如在下面草图中的1号三角形中。 <p>现在可以在该三角形中观察到具有不同形状或大小或方向或位置的十六个三角形。使用大小为1的三角形作为构建块可以形成更大的三角形例如上面草图中的大小为2的三角形。现在可以在该尺寸2三角形中观察到具有不同形状或尺寸或方向或位置的一百四十个三角形。可以观察到2号三角形包含4个1号三角形构造块。大小为3的三角形将包含9个大小为1的三角形构建块因此大小为n的三角形将包含n2个大小为1的三角形构建块。如果我们将Tn表示为大小为n的三角形中存在的三角形的数量则T1= 16 T2= 104 Find T36</p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑等边三角形其中从每个顶点到相对侧的中间绘制直线例如在下面草图中的1号三角形中。
## Tests
<section id='tests'>
现在可以在该三角形中观察到具有不同形状或大小或方向或位置的十六个三角形。使用大小为1的三角形作为构建块可以形成更大的三角形例如上面草图中的大小为2的三角形。现在可以在该尺寸2三角形中观察到具有不同形状或尺寸或方向或位置的一百四十个三角形。可以观察到2号三角形包含4个1号三角形构造块。大小为3的三角形将包含9个大小为1的三角形构建块因此大小为n的三角形将包含n2个大小为1的三角形构建块。如果我们将Tn表示为大小为n的三角形中存在的三角形的数量则T1= 16 T2= 104 Find T36
```yml
tests:
- text: <code>euler163()</code>应返回343047。
testString: assert.strictEqual(euler163(), 343047);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler163()`应返回343047。
```js
function euler163() {
// Good luck!
return true;
}
euler163();
assert.strictEqual(euler163(), 343047);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4111000cf542c50ff23
title: 问题164没有三个连续数字的总和大于给定值的数字
challengeType: 5
videoUrl: ''
title: 问题164没有三个连续数字的总和大于给定值的数字
---
## Description
<section id="description">存在多少20个数字n没有任何前导零使得n的三个连续数字的总和不大于9 </section>
# --description--
## Instructions
<section id="instructions">
</section>
存在多少20个数字n没有任何前导零使得n的三个连续数字的总和不大于9
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler164()</code>应该返回378158756814587。
testString: assert.strictEqual(euler164(), 378158756814587);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler164()`应该返回378158756814587。
```js
function euler164() {
// Good luck!
return true;
}
euler164();
assert.strictEqual(euler164(), 378158756814587);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f4111000cf542c50ff24
title: 问题165交叉口
challengeType: 5
videoUrl: ''
title: 问题165交叉口
---
## Description
<section id="description">段由其两个端点唯一定义。通过考虑平面几何中的两个线段存在三种可能性段具有零点一个点或无限多个共同点。此外当两个段恰好具有一个共同点时可能是该公共点是任一段或两者的端点的情况。如果两个段的公共点不是任一段的端点则它是两个段的内点。如果T是L1和L2的唯一公共点则我们将两个段L1和L2的公共点T称为L1和L2的真实交点并且T是两个段的内点。 <p>考虑三个段L1L2和L3L127,4412,32L246,5317,62L346,7022,40可以证实线段L2和L3具有真实的交叉点。我们注意到作为L3的终点之一22,40位于L1上这不被认为是真正的交点。 L1和L2没有共同点。因此在三个线段中我们找到一个真正的交叉点。现在让我们对5000个线段进行相同的操作。为此我们使用所谓的“Blum Blum Shub”伪随机数生成器生成20000个数字。 s0 = 290797 sn + 1 = sn×snmodulo 50515093tn = snmodulo 500为了创建每个线段我们使用四个连续的数字tn。也就是说第一个线段由下式给出t1t2t3t4根据上述发生器计算的前四个数字应该是27,144,12和232.因此第一个线段是( 27,14412,232。在5000个线段中发现了多少个不同的真实交叉点 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
段由其两个端点唯一定义。通过考虑平面几何中的两个线段存在三种可能性段具有零点一个点或无限多个共同点。此外当两个段恰好具有一个共同点时可能是该公共点是任一段或两者的端点的情况。如果两个段的公共点不是任一段的端点则它是两个段的内点。如果T是L1和L2的唯一公共点则我们将两个段L1和L2的公共点T称为L1和L2的真实交点并且T是两个段的内点。
## Tests
<section id='tests'>
考虑三个段L1L2和L3L127,4412,32L246,5317,62L346,7022,40可以证实线段L2和L3具有真实的交叉点。我们注意到作为L3的终点之一22,40位于L1上这不被认为是真正的交点。 L1和L2没有共同点。因此在三个线段中我们找到一个真正的交叉点。现在让我们对5000个线段进行相同的操作。为此我们使用所谓的“Blum Blum Shub”伪随机数生成器生成20000个数字。 s0 = 290797 sn + 1 = sn×snmodulo 50515093tn = snmodulo 500为了创建每个线段我们使用四个连续的数字tn。也就是说第一个线段由下式给出t1t2t3t4根据上述发生器计算的前四个数字应该是27,144,12和232.因此第一个线段是( 27,14412,232。在5000个线段中发现了多少个不同的真实交叉点
```yml
tests:
- text: <code>euler165()</code>应该返回2868868。
testString: assert.strictEqual(euler165(), 2868868);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler165()`应该返回2868868。
```js
function euler165() {
// Good luck!
return true;
}
euler165();
assert.strictEqual(euler165(), 2868868);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,29 @@
---
id: 5900f4131000cf542c50ff25
title: 问题166克里斯十字架
challengeType: 5
videoUrl: ''
title: 问题166克里斯十字架
---
## Description
<section id="description"> 4x4网格填充数字d0≤d≤9。 <p>可以看出,在网格中</p><p> 6 3 3 0 5 0 4 3 0 7 1 4 1 2 4 5 </p><p>每行和每列的总和值为12.此外每个对角线的总和也是12。 </p><p>在多少种方法中您可以使用数字d0≤d≤9填充4x4网格以便每行每列和两个对角线具有相同的总和 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
4x4网格填充数字d0≤d≤9。
## Tests
<section id='tests'>
可以看出,在网格中
```yml
tests:
- text: <code>euler166()</code>应返回7130034。
testString: assert.strictEqual(euler166(), 7130034);
6 3 3 0 5 0 4 3 0 7 1 4 1 2 4 5
```
每行和每列的总和值为12.此外每个对角线的总和也是12。
</section>
在多少种方法中您可以使用数字d0≤d≤9填充4x4网格以便每行每列和两个对角线具有相同的总和
## Challenge Seed
<section id='challengeSeed'>
# --hints--
<div id='js-seed'>
`euler166()`应返回7130034。
```js
function euler166() {
// Good luck!
return true;
}
euler166();
assert.strictEqual(euler166(), 7130034);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4141000cf542c50ff26
title: 问题167研究Ulam序列
challengeType: 5
videoUrl: ''
title: 问题167研究Ulam序列
---
## Description
<section id="description">对于两个正整数a和bUlam序列Uab由Uab1 = aUab2 = b定义对于k&gt; 2Uab k是大于Uabk-1的最小整数它可以用一种方式写成Uab的两个不同的先前成员的总和。例如序列U1,2以1,2,3 = 1 + 2,4 = 1 + 3,6 = 2 + 4,8 = 2 + 6,11 = 3 + 8开始; 5不属于它因为5 = 1 + 4 = 2 + 3有两个表示作为前两个成员的总和同样7 = 1 + 6 = 3 + 4.找到ΣU2,2n + 1k为2≤n≤10其中k = 1011。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
对于两个正整数a和bUlam序列Uab由Uab1 = aUab2 = b定义对于k> 2Uab k是大于Uabk-1的最小整数它可以用一种方式写成Uab的两个不同的先前成员的总和。例如序列U1,2以1,2,3 = 1 + 2,4 = 1 + 3,6 = 2 + 4,8 = 2 + 6,11 = 3 + 8开始; 5不属于它因为5 = 1 + 4 = 2 + 3有两个表示作为前两个成员的总和同样7 = 1 + 6 = 3 + 4.找到ΣU2,2n + 1k为2≤n≤10其中k = 1011。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler167()</code>应该返回3916160068885。
testString: assert.strictEqual(euler167(), 3916160068885);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler167()`应该返回3916160068885。
```js
function euler167() {
// Good luck!
return true;
}
euler167();
assert.strictEqual(euler167(), 3916160068885);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4151000cf542c50ff27
title: 问题168数字轮换
challengeType: 5
videoUrl: ''
title: 问题168数字轮换
---
## Description
<section id="description">考虑数字142857.我们可以通过将最后一个数字7移动到它的前面来右旋这个数字给我们714285.可以验证714285 = 5×142857。这证明了142857的一个不寻常的属性它是右旋的除数。找到具有此属性的所有整数n10 &lt;n &lt;10100之和的最后5位数。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑数字142857.我们可以通过将最后一个数字7移动到它的前面来右旋这个数字给我们714285.可以验证714285 = 5×142857。这证明了142857的一个不寻常的属性它是右旋的除数。找到具有此属性的所有整数n10 &lt;n &lt;10100之和的最后5位数。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler168()</code>应返回<code>euler168()</code> 。
testString: assert.strictEqual(euler168(), 59206);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler168()`应返回`euler168()`
```js
function euler168() {
// Good luck!
return true;
}
euler168();
assert.strictEqual(euler168(), 59206);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4151000cf542c50ff28
title: 问题169探索数字可以表示为2的幂之和的不同方式的数量
challengeType: 5
videoUrl: ''
title: 问题169探索数字可以表示为2的幂之和的不同方式的数量
---
## Description
<section id="description">将f0= 1和fn定义为不同方式的数量n可以表示为2的整数幂之和使用每个幂不超过两次。例如f10= 5因为有五种不同的表达方式101 + 1 + 8 1 + 1 + 4 + 41 + 1 + 2 + 2 + 4 2 + 4 + 4 2 + 8什么是f 1025 </section>
# --description--
## Instructions
<section id="instructions">
</section>
将f0= 1和fn定义为不同方式的数量n可以表示为2的整数幂之和使用每个幂不超过两次。例如f10= 5因为有五种不同的表达方式101 + 1 + 8 1 + 1 + 4 + 41 + 1 + 2 + 2 + 4 2 + 4 + 4 2 + 8什么是f 1025
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler169()</code>应该返回178653872807。
testString: assert.strictEqual(euler169(), 178653872807);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler169()`应该返回178653872807。
```js
function euler169() {
// Good luck!
return true;
}
euler169();
assert.strictEqual(euler169(), 178653872807);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,59 +1,33 @@
---
id: 5900f37d1000cf542c50fe90
title: 问题17数字字母计数
challengeType: 5
videoUrl: ''
title: 问题17数字字母计数
---
## Description
<section id="description">如果数字1到5用文字写出则总共使用3 + 3 + 5 + 4 + 4 = 19个字母。如果从1到包含<code>limit</code>所有数字都用文字写出,那么会使用多少个字母? <b>注意:</b>不要计算空格或连字符。例如342三百四十二包含23个字母115一百一十五包含20个字母。在写出数字时使用“和”符合英国的用法。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
如果数字1到5用文字写出则总共使用3 + 3 + 5 + 4 + 4 = 19个字母。如果从1到包含`limit`所有数字都用文字写出,那么会使用多少个字母? **注意:** 不要计算空格或连字符。例如342三百四十二包含23个字母115一百一十五包含20个字母。在写出数字时使用“和”符合英国的用法。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>numberLetterCounts(5)</code>应返回19。
testString: assert.strictEqual(numberLetterCounts(5), 19);
- text: <code>numberLetterCounts(150)</code>应该返回1903。
testString: assert.strictEqual(numberLetterCounts(150), 1903);
- text: <code>numberLetterCounts(1000)</code>应该返回21124。
testString: assert.strictEqual(numberLetterCounts(1000), 21124);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`numberLetterCounts(5)`应返回19。
```js
function numberLetterCounts(limit) {
// Good luck!
return true;
}
numberLetterCounts(5);
assert.strictEqual(numberLetterCounts(5), 19);
```
</div>
</section>
## Solution
<section id='solution'>
`numberLetterCounts(150)`应该返回1903。
```js
// solution required
assert.strictEqual(numberLetterCounts(150), 1903);
```
/section>
`numberLetterCounts(1000)`应该返回21124。
```js
assert.strictEqual(numberLetterCounts(1000), 21124);
```
# --solutions--

View File

@ -1,55 +1,29 @@
---
id: 5900f4161000cf542c50ff29
title: 问题170找到可以通过连接产品形成的最大的0到9个pandigital
challengeType: 5
videoUrl: ''
title: 问题170找到可以通过连接产品形成的最大的0到9个pandigital
---
## Description
<section id="description">取数字6并乘以1273和9854 <p> 6×1273 = 7638 6×9854 = 59124 </p><p>通过连接这些产品我们得到1到9 pandigital 763859124.我们将763859124称为“6和1273,9854”的连接产品。另请注意输入数字612739854的串联也是1到9 pandigital。 </p><p>对于0到9个pandigital数字也可以这样做。 </p><p>什么是具有两个或更多其他整数的整数的0到9 pandigital 10位连接产品这样输入数字的串联也是0到9 pandigital 10位数字 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
取数字6并乘以1273和9854
## Tests
<section id='tests'>
6×1273 = 7638 6×9854 = 59124
```yml
tests:
- text: <code>euler170()</code>应返回9857164023。
testString: assert.strictEqual(euler170(), 9857164023);
通过连接这些产品我们得到1到9 pandigital 763859124.我们将763859124称为“6和1273,9854”的连接产品。另请注意输入数字612739854的串联也是1到9 pandigital。
```
对于0到9个pandigital数字也可以这样做。
</section>
什么是具有两个或更多其他整数的整数的0到9 pandigital 10位连接产品这样输入数字的串联也是0到9 pandigital 10位数字
## Challenge Seed
<section id='challengeSeed'>
# --hints--
<div id='js-seed'>
`euler170()`应返回9857164023。
```js
function euler170() {
// Good luck!
return true;
}
euler170();
assert.strictEqual(euler170(), 9857164023);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4181000cf542c50ff2a
title: 问题171找到数字的平方和为正方形的数字
challengeType: 5
videoUrl: ''
title: 问题171找到数字的平方和为正方形的数字
---
## Description
<section id="description">对于正整数n令fn为n的数字在基数10中的平方和例如f3= 32 = 9f25= 22 + 52 = 4 + 25 = 29f442= 42 + 42 + 22 = 16 + 16 + 4 = 36找到所有n的总和的最后九位数0 &lt;n &lt;1020使得fn是一个完美的平方。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
对于正整数n令fn为n的数字在基数10中的平方和例如f3= 32 = 9f25= 22 + 52 = 4 + 25 = 29f442= 42 + 42 + 22 = 16 + 16 + 4 = 36找到所有n的总和的最后九位数0 &lt;n &lt;1020使得fn是一个完美的平方。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler171()</code>应该返回142989277。
testString: assert.strictEqual(euler171(), 142989277);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler171()`应该返回142989277。
```js
function euler171() {
// Good luck!
return true;
}
euler171();
assert.strictEqual(euler171(), 142989277);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4181000cf542c50ff2b
title: 问题172调查重复数字很少的数字
challengeType: 5
videoUrl: ''
title: 问题172调查重复数字很少的数字
---
## Description
<section id="description">有多少个18位数字n没有前导零n中没有数字出现超过三次 </section>
# --description--
## Instructions
<section id="instructions">
</section>
有多少个18位数字n没有前导零n中没有数字出现超过三次
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler172()</code>应返回227485267000992000。
testString: assert.strictEqual(euler172(), 227485267000992000);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler172()`应返回227485267000992000。
```js
function euler172() {
// Good luck!
return true;
}
euler172();
assert.strictEqual(euler172(), 227485267000992000);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f41a1000cf542c50ff2c
title: 问题173使用多达一百万个瓷砖可以形成多少个不同的“空心”方形薄片
challengeType: 5
videoUrl: ''
title: 问题173使用多达一百万个瓷砖可以形成多少个不同的“空心”方形薄片
---
## Description
<section id="description">我们将方形薄片定义为具有方形“孔”的方形轮廓,使得该形状具有垂直和水平对称性。例如,使用正好三十二平方的瓷砖,我们可以形成两个不同的方形薄片: <p>使用一百个瓷砖,并且不一定一次使用所有瓷砖,可以形成四十一个不同的方形薄片。使用多达一百万个瓷砖可以形成多少个不同的方形薄片? </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
我们将方形薄片定义为具有方形“孔”的方形轮廓,使得该形状具有垂直和水平对称性。例如,使用正好三十二平方的瓷砖,我们可以形成两个不同的方形薄片:
## Tests
<section id='tests'>
使用一百个瓷砖,并且不一定一次使用所有瓷砖,可以形成四十一个不同的方形薄片。使用多达一百万个瓷砖可以形成多少个不同的方形薄片?
```yml
tests:
- text: <code>euler173()</code>应该返回1572729。
testString: assert.strictEqual(euler173(), 1572729);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler173()`应该返回1572729。
```js
function euler173() {
// Good luck!
return true;
}
euler173();
assert.strictEqual(euler173(), 1572729);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f41a1000cf542c50ff2d
title: 问题174计算可以形成一个两个三个......不同排列的“空心”方形薄片的数量
challengeType: 5
videoUrl: ''
title: 问题174计算可以形成一个两个三个......不同排列的“空心”方形薄片的数量
---
## Description
<section id="description">我们将方形薄片定义为具有方形“孔”的方形轮廓使得该形状具有垂直和水平对称性。给定八个瓷砖可以仅以一种方式形成薄层3x3正方形中间有1x1个孔。但是使用32个瓷砖可以形成两个不同的薄片。 <p>如果t表示使用的瓦片数我们将说t = 8是类型L1并且t = 32是类型L2。令Nn为t≤1000000的数使得t为Ln型;例如N15= 832.对于1≤n≤10ΣNn是多少 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
我们将方形薄片定义为具有方形“孔”的方形轮廓使得该形状具有垂直和水平对称性。给定八个瓷砖可以仅以一种方式形成薄层3x3正方形中间有1x1个孔。但是使用32个瓷砖可以形成两个不同的薄片。
## Tests
<section id='tests'>
如果t表示使用的瓦片数我们将说t = 8是类型L1并且t = 32是类型L2。令Nn为t≤1000000的数使得t为Ln型;例如N15= 832.对于1≤n≤10ΣNn是多少
```yml
tests:
- text: <code>euler174()</code>应该返回209566。
testString: assert.strictEqual(euler174(), 209566);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler174()`应该返回209566。
```js
function euler174() {
// Good luck!
return true;
}
euler174();
assert.strictEqual(euler174(), 209566);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f41c1000cf542c50ff2e
title: 问题175涉及不同方式的数量的分数数字可以表示为2的幂的总和
challengeType: 5
videoUrl: ''
title: 问题175涉及不同方式的数量的分数数字可以表示为2的幂的总和
---
## Description
<section id="description">将f0= 1和fn定义为将n作为2的幂之和进行写入的方式的数量其中没有功率发生超过两次。 <p>例如f10= 5因为有五种不同的表达方式10:10 = 8 + 2 = 8 + 1 + 1 = 4 + 4 + 2 = 4 + 2 + 2 + 1 + 1 = 4 + 4 + 1 + 1 </p><p>可以证明对于每个分数p / qp&gt; 0q&gt; 0存在至少一个整数n使得fn/ fn-1= p / q。例如fn/ fn-1= 13/17的最小n是241. 241的二进制扩展是11110001.从最高有效位到最低有效位读取这个二进制数有4个13个零和1个。我们将字符串4,3,1称为缩短的二进制扩展241.找到最小n的缩短二进制扩展其中fn/ fn-1= 123456789/987654321。以逗号分隔的整数给出答案没有任何空格。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
将f0= 1和fn定义为将n作为2的幂之和进行写入的方式的数量其中没有功率发生超过两次。
## Tests
<section id='tests'>
例如f10= 5因为有五种不同的表达方式10:10 = 8 + 2 = 8 + 1 + 1 = 4 + 4 + 2 = 4 + 2 + 2 + 1 + 1 = 4 + 4 + 1 + 1
```yml
tests:
- text: '<code>euler175()</code>应该返回1,13717420,8。'
testString: assert.strictEqual(euler175(), 1, 13717420, 8);
可以证明对于每个分数p / qp> 0q> 0存在至少一个整数n使得fn/ fn-1= p / q。例如fn/ fn-1= 13/17的最小n是241. 241的二进制扩展是11110001.从最高有效位到最低有效位读取这个二进制数有4个13个零和1个。我们将字符串4,3,1称为缩短的二进制扩展241.找到最小n的缩短二进制扩展其中fn/ fn-1= 123456789/987654321。以逗号分隔的整数给出答案没有任何空格。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler175()`应该返回1,13717420,8。
```js
function euler175() {
// Good luck!
return true;
}
euler175();
assert.strictEqual(euler175(), 1, 13717420, 8);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f41c1000cf542c50ff2f
title: 问题176共用一个cathetus的直角三角形
challengeType: 5
videoUrl: ''
title: 问题176共用一个cathetus的直角三角形
---
## Description
<section id="description">具有侧面9,12,1512,16,205,12,1312,35,37的四个直角三角形都具有相等的一个短边导管可以证明没有其他整数侧直角三角形存在其中一个导管等于12.找到最小整数可以是恰好47547个不同整数侧直角三角形的cathetus的长度。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
具有侧面9,12,1512,16,205,12,1312,35,37的四个直角三角形都具有相等的一个短边导管可以证明没有其他整数侧直角三角形存在其中一个导管等于12.找到最小整数可以是恰好47547个不同整数侧直角三角形的cathetus的长度。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler176()</code>应返回96818198400000。
testString: assert.strictEqual(euler176(), 96818198400000);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler176()`应返回96818198400000。
```js
function euler176() {
// Good luck!
return true;
}
euler176();
assert.strictEqual(euler176(), 96818198400000);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f41e1000cf542c50ff30
title: 问题177整数角四边形
challengeType: 5
videoUrl: ''
title: 问题177整数角四边形
---
## Description
<section id="description">设ABCD为凸四边形对角线为AC和BD。在每个顶点处对角线与两侧中的每一侧形成一个角度从而产生八个角度角。 <p>例如在顶点A处两个角度是CADCAB。我们称之为四边形当以“整角四边形”度数度量时所有八个角度角都具有整数值。整数角度四边形的示例是正方形其中所有八个角度角都是45°。另一个例子是DAC = 20°BAC = 60°ABD = 50°CBD = 30°BCA = 40°DCA = 30°CDB = 80°ADB = 50°。非相似整数角度四边形的总数是多少注意在计算中如果计算出的角度在整数值的10-9范围内则可以假定计算出的角度是整数。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
设ABCD为凸四边形对角线为AC和BD。在每个顶点处对角线与两侧中的每一侧形成一个角度从而产生八个角度角。
## Tests
<section id='tests'>
例如在顶点A处两个角度是CADCAB。我们称之为四边形当以“整角四边形”度数度量时所有八个角度角都具有整数值。整数角度四边形的示例是正方形其中所有八个角度角都是45°。另一个例子是DAC = 20°BAC = 60°ABD = 50°CBD = 30°BCA = 40°DCA = 30°CDB = 80°ADB = 50°。非相似整数角度四边形的总数是多少注意在计算中如果计算出的角度在整数值的10-9范围内则可以假定计算出的角度是整数。
```yml
tests:
- text: <code>euler177()</code>应返回129325。
testString: assert.strictEqual(euler177(), 129325);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler177()`应返回129325。
```js
function euler177() {
// Good luck!
return true;
}
euler177();
assert.strictEqual(euler177(), 129325);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f41e1000cf542c50ff31
title: 问题178步骤编号
challengeType: 5
videoUrl: ''
title: 问题178步骤编号
---
## Description
<section id="description">考虑数字45656.可以看出45656的每对连续数字的差值为1。每对连续数字的差值为1的数字称为步数。 pandigital数字包含从0到9的每个十进制数字至少一次。 <p>有多少pandigital步数小于1040 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑数字45656.可以看出45656的每对连续数字的差值为1。每对连续数字的差值为1的数字称为步数。 pandigital数字包含从0到9的每个十进制数字至少一次。
## Tests
<section id='tests'>
有多少pandigital步数小于1040
```yml
tests:
- text: <code>euler178()</code>应该返回126461847755。
testString: assert.strictEqual(euler178(), 126461847755);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler178()`应该返回126461847755。
```js
function euler178() {
// Good luck!
return true;
}
euler178();
assert.strictEqual(euler178(), 126461847755);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f41f1000cf542c50ff32
title: 问题179连续的正向除数
challengeType: 5
videoUrl: ''
title: 问题179连续的正向除数
---
## Description
<section id="description">求整数1 &lt;n &lt;107其中n和n + 1具有相同的正除数。例如14具有正除数1,2,7,14而15具有1,3,5,15。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
求整数1 &lt;n &lt;107其中n和n + 1具有相同的正除数。例如14具有正除数1,2,7,14而15具有1,3,5,15。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler179()</code>应返回986262。
testString: assert.strictEqual(euler179(), 986262);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler179()`应返回986262。
```js
function euler179() {
// Good luck!
return true;
}
euler179();
assert.strictEqual(euler179(), 986262);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,71 +1,44 @@
---
id: 5900f37e1000cf542c50fe91
title: 问题18最大路径总和I.
challengeType: 5
videoUrl: ''
title: 问题18最大路径总和I.
---
## Description
<section id="description">通过启动在低于该三角形的顶部和移动到相邻的数字下面的行中最大总从上到下为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>也就是说3 + 7 + 4 + 9 = 23.找到下面三角形从上到下的最大总数: <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>注意:</b>由于只有16384条路线因此可以通过尝试每条路线来解决此问题。然而问题67与包含一百行的三角形是同样的挑战;它无法通过蛮力解决,需要一种聪明的方法! ; O </section>
# --description--
## Instructions
<section id="instructions">
</section>
通过启动在低于该三角形的顶部和移动到相邻的数字下面的行中最大总从上到下为23 **3**
**7** 4
2 **4** 6
8 5 **9** 3也就是说3 + 7 + 4 + 9 = 23.找到下面三角形从上到下的最大总数: 75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23 **注意:** 由于只有16384条路线因此可以通过尝试每条路线来解决此问题。然而问题67与包含一百行的三角形是同样的挑战;它无法通过蛮力解决,需要一种聪明的方法! ; O
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>maximumPathSumI(testTriangle)</code>应该返回23。
testString: assert.strictEqual(maximumPathSumI(testTriangle), 23);
- text: <code>maximumPathSumI(numTriangle)</code>应该返回1074。
testString: assert.strictEqual(maximumPathSumI(numTriangle), 1074);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`maximumPathSumI(testTriangle)`应该返回23。
```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);
assert.strictEqual(maximumPathSumI(testTriangle), 23);
```
</div>
### Before Test
<div id='js-setup'>
`maximumPathSumI(numTriangle)`应该返回1074。
```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]];
assert.strictEqual(maximumPathSumI(numTriangle), 1074);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4201000cf542c50ff33
title: 问题180三个变量函数的有理零点
challengeType: 5
videoUrl: ''
title: 问题180三个变量函数的有理零点
---
## Description
<section id="description">对于任何整数n考虑三个函数f1nxyz= xn + 1 + yn + 1 - zn + 1f2nxyz=xy + yz + zx* xn-1 + yn-1-zn-1f3nxyz= xyz *xn-2 + yn-2-zn-2及其组合fnxyz= f1nxyz+ f2nxyz - f3nxyz如果是x我们将xyz称为k阶的黄金三元组 y和z都是形式为a / b的有理数0 &lt;a &lt;b≤k且存在至少一个整数n因此fnxyz= 0.设sx yz= x + y + z。设t = u / v是所有不同sxyz的所有黄金三元组xyz的总和。所有sxyz和t必须在减少形式。找到你+ v。 </section>
# --description--
## Instructions
<section id="instructions">
</section>
对于任何整数n考虑三个函数f1nxyz= xn + 1 + yn + 1 - zn + 1f2nxyz=xy + yz + zx\* xn-1 + yn-1-zn-1f3nxyz= xyz \*xn-2 + yn-2-zn-2及其组合fnxyz= f1nxyz+ f2nxyz - f3nxyz如果是x我们将xyz称为k阶的黄金三元组 y和z都是形式为a / b的有理数0 &lt;a &lt;b≤k且存在至少一个整数n因此fnxyz= 0.设sx yz= x + y + z。设t = u / v是所有不同sxyz的所有黄金三元组xyz的总和。所有sxyz和t必须在减少形式。找到你+ v。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler180()</code>应该返回285196020571078980。
testString: assert.strictEqual(euler180(), 285196020571078980);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler180()`应该返回285196020571078980。
```js
function euler180() {
// Good luck!
return true;
}
euler180();
assert.strictEqual(euler180(), 285196020571078980);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,21 @@
---
id: 5900f4231000cf542c50ff34
title: 问题181调查两种不同颜色的对象可以分组的方式
challengeType: 5
videoUrl: ''
title: 问题181调查两种不同颜色的对象可以分组的方式
---
## Description
<section id="description">有三个黑色物体B和一个白色物体W它们可以用7种方式分组BBBWBBBWBBBWBBBWBBBW BBBWBBBW在六十个黑色物体B和四十个白色物体W的分组方式中有多少种 </section>
# --description--
## Instructions
<section id="instructions">
</section>
有三个黑色物体B和一个白色物体W它们可以用7种方式分组BBBWBBBWBBBWBBBWBBBW BBBWBBBW在六十个黑色物体B和四十个白色物体W的分组方式中有多少种
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>euler181()</code>应该返回83735848679360670。
testString: assert.strictEqual(euler181(), 83735848679360670);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler181()`应该返回83735848679360670。
```js
function euler181() {
// Good luck!
return true;
}
euler181();
assert.strictEqual(euler181(), 83735848679360670);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,41 @@
---
id: 5900f4231000cf542c50ff35
title: 'Problem 182: RSA encryption'
challengeType: 5
videoUrl: ''
title: 问题182RSA加密
forumTopicId: 301818
---
## Description
<section id="description"> RSA加密基于以下过程生成两个不同的素数p和q。计算n = pq和φ=p-1q-1。求整数e1 <e<φ, such="" that="" gcd(e,φ)="1." a="" message="" in="" this="" system="" is="" number="" the="" interval="" [0,n-1].="" text="" to="" be="" encrypted="" then="" somehow="" converted="" messages="" (numbers="" [0,n-1]).="" encrypt="" text,="" for="" each="" message,="" m,="" c="me" mod="" n="" calculated.="" decrypt="" following="" procedure="" needed:="" calculate="" d="" ed="1" φ,="" c,="" m="cd" n.="" there="" exist="" values="" of="" e="" and="" me="" call="" which="" unconcealed="" messages.="" an="" issue="" when="" choosing="" should="" not="" too="" many="" instance,="" let="" p="19" q="37." φ="18*36=648." if="" we="" choose="" then,="" although="" gcd(181,648)="1" it="" turns="" out="" all="" possible="" messagesm="" (0mn-1)="" are="" calculating="" any="" valid="" choice="" some="" it&#x27;s="" important="" at="" minimum.="" find="" sum="" e,="" 1&#x3C;e&#x3C;φ(1009,3643)="" so="" value="" &#x3C;="" section=""><h2>说明</h2><section id="instructions"></section><h2>测试</h2><section id="tests"><pre> <code class="language-yml">tests: - text: &lt;code&gt;euler182()&lt;/code&gt; should return 399788195976. testString: &#39;assert.strictEqual(euler182(), 399788195976, &quot;&lt;code&gt;euler182()&lt;/code&gt; should return 399788195976.&quot;);&#39;</code> </pre></section><h2>挑战种子</h2><section id="challengeSeed"><div id="js-seed"><pre> <code class="language-js">function euler182() { // Good luck! return true; } euler182();</code> </pre></div></section><h2></h2><section id="solution"><pre> <code class="language-js">// solution required</code> </pre></section></e<φ,></section>
# --description--
## Instructions
<section id="instructions">
</section>
The RSA encryption is based on the following procedure:
## Tests
<section id='tests'>
Generate two distinct primes p and q.Compute n=pq and φ=(p-1)(q-1).
```yml
tests:
- text: <code>euler182()</code>应该返回399788195976。
testString: 'assert.strictEqual(euler182(), 399788195976, "<code>euler182()</code> should return 399788195976.");'
Find an integer e, 1&lt;e&lt;φ, such='' that='' gcd(e,φ)='1.' a='' message='' in='' this='' system='' is='' number='' the='' interval='' \[0,n-1].='' text='' to='' be='' encrypted='' then='' somehow='' converted='' messages='' (numbers='' \[0,n-1]).='' encrypt='' text,='' for='' each='' message,='' m,='' c='me' mod='' n='' calculated.='' decrypt='' following='' procedure='' needed:='' calculate='' d='' ed='1' φ,='' c,='' m='cd' n.='' there='' exist='' values='' of='' e='' and='' me='' call='' which='' unconcealed='' messages.='' an='' issue='' when='' choosing='' should='' not='' too='' many='' instance,='' let='' p='19' q='37.' φ='18\*36=648.' if='' we='' choose='' then,='' although='' gcd(181,648)='1' it='' turns='' out='' all='' possible='' messagesm='' (0≤m≤n-1)='' are='' calculating='' any='' valid='' choice='' some='' it's='' important='' at='' minimum.='' find='' sum='' e,='' 1&lt;e&lt;φ(1009,3643)='' so='' value='' &lt;='' section=''>&lt;/e&lt;φ,>
# --hints--
`euler182()` should return 399788195976.
```js
assert.strictEqual(euler182(), 399788195976);
```
</section>
# --seed--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
## --seed-contents--
```js
function euler182() {
// Good luck!
return true;
}
euler182();
```
</div>
</section>
## Solution
<section id='solution'>
# --solutions--
```js
// solution required
```
/section>

View File

@ -1,55 +1,35 @@
---
id: 5900f4231000cf542c50ff36
title: 问题183零件的最大产品
challengeType: 5
videoUrl: ''
title: 问题183零件的最大产品
---
## Description
<section id="description">令N为正整数并且将N分成k个相等的部分r = N / k使得N = r + r + ... + r。设P是这些部分的乘积P = r×r×...×r = rk。 <p>例如如果11被分成五个相等的部分11 = 2.2 + 2.2 + 2.2 + 2.2 + 2.2那么P = 2.25 = 51.53632。 </p><p>对于给定的N值设MN= Pmax。 </p><p>事实证明N = 11的最大值是通过将11分成4个相等的部分得到的这导致Pmax =11/44;即M11= 14641/256 = 57.19140625,这是终止小数。 </p><p>然而对于N = 8通过将其分成三个相等的部分来实现最大值因此M8= 512/27这是非终止小数。 </p><p>如果MN是非终止小数则令DN= N如果MN是终止小数则DN= -N。 </p><p>例如5≤N≤100的ΣDN是2438。 </p><p>求ΣDN为5≤N≤10000。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
令N为正整数并且将N分成k个相等的部分r = N / k使得N = r + r + ... + r。设P是这些部分的乘积P = r×r×...×r = rk。
## Tests
<section id='tests'>
例如如果11被分成五个相等的部分11 = 2.2 + 2.2 + 2.2 + 2.2 + 2.2那么P = 2.25 = 51.53632。
```yml
tests:
- text: <code>euler183()</code>应该返回48861552。
testString: assert.strictEqual(euler183(), 48861552);
对于给定的N值设MN= Pmax。
```
事实证明N = 11的最大值是通过将11分成4个相等的部分得到的这导致Pmax =11/44;即M11= 14641/256 = 57.19140625,这是终止小数。
</section>
然而对于N = 8通过将其分成三个相等的部分来实现最大值因此M8= 512/27这是非终止小数。
## Challenge Seed
<section id='challengeSeed'>
如果MN是非终止小数则令DN= N如果MN是终止小数则DN= -N。
<div id='js-seed'>
例如5≤N≤100的ΣDN是2438。
求ΣDN为5≤N≤10000。
# --hints--
`euler183()`应该返回48861552。
```js
function euler183() {
// Good luck!
return true;
}
euler183();
assert.strictEqual(euler183(), 48861552);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f4241000cf542c50ff37
title: 问题184包含原点的三角形
challengeType: 5
videoUrl: ''
title: 问题184包含原点的三角形
---
## Description
<section id="description">考虑点xy的集合Ir其中半径为r的圆内部的整数坐标以原点为中心即x2 + y2 &lt;r2。对于半径为2I2包含九个点0,01,01,10,1 - 1,1 - 1,0 -1-10-11-1。在I2中有八个三角形具有全部三个顶点其中包含内部的原点。其中两个如下所示其他通过旋转从这些中获得。 <p>对于半径为3有360个三角形包含内部的原点并且所有顶点都在I3中而对于I5该数字是10600。 </p><p>有多少个三角形包含内部的原点并且在I105中包含所有三个顶点 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑点xy的集合Ir其中半径为r的圆内部的整数坐标以原点为中心即x2 + y2 &lt;r2。对于半径为2I2包含九个点0,01,01,10,1 - 1,1 - 1,0 -1-10-11-1。在I2中有八个三角形具有全部三个顶点其中包含内部的原点。其中两个如下所示其他通过旋转从这些中获得。
## Tests
<section id='tests'>
对于半径为3有360个三角形包含内部的原点并且所有顶点都在I3中而对于I5该数字是10600。
```yml
tests:
- text: <code>euler184()</code>应返回1725323624056。
testString: assert.strictEqual(euler184(), 1725323624056);
有多少个三角形包含内部的原点并且在I105中包含所有三个顶点
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler184()`应返回1725323624056。
```js
function euler184() {
// Good luck!
return true;
}
euler184();
assert.strictEqual(euler184(), 1725323624056);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,29 @@
---
id: 5900f4251000cf542c50ff38
title: 问题185数字思维
challengeType: 5
videoUrl: ''
title: 问题185数字思维
---
## Description
<section id="description">游戏Number Mind是众所周知的游戏Master Mind的变种。而不是彩色钉你必须猜测一个秘密的数字序列。在每次猜测之后你只会告诉你猜对了多少个正确的数字。所以如果序列是1234并且你猜到了2036那么你会被告知你有一个正确的数字;但是,你不会被告知你在错误的地方也有另一个数字。 <p>例如给出以下5位秘密序列的猜测90342; 2正确70794; 0正确39458; 2正确34109; 1正确51545; 2正确12531; 1正确正确序列39542是唯一的。 </p><p>基于以下猜测, </p><p> 5616185650518293 2正确3847439647293047 1正确5855462940810587 3正确9742855507068353 3正确4296849643607543 3正确3174248439465858 1正确4513559094146117 2正确7890971548908067 3正确8157356344118483 1正确2615250744386899 2正确8690095851526254 3正确6375711915077050 1正确6913859173121360; 1更正6442889055042768; 2更正2321386104303845; 0更正2326509471271448; 2更正5251583379644322; 2更正1748270476758276; 3更正4895722652190306; 1更正3041631117224635; 3更正1841236454324589; 3更正2659862637316867; 2更正</p><p>找到唯一的16位秘密序列。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
游戏Number Mind是众所周知的游戏Master Mind的变种。而不是彩色钉你必须猜测一个秘密的数字序列。在每次猜测之后你只会告诉你猜对了多少个正确的数字。所以如果序列是1234并且你猜到了2036那么你会被告知你有一个正确的数字;但是,你不会被告知你在错误的地方也有另一个数字。
## Tests
<section id='tests'>
例如给出以下5位秘密序列的猜测90342; 2正确70794; 0正确39458; 2正确34109; 1正确51545; 2正确12531; 1正确正确序列39542是唯一的。
```yml
tests:
- text: <code>euler185()</code>应该返回4640261571849533。
testString: assert.strictEqual(euler185(), 4640261571849533);
基于以下猜测,
```
5616185650518293 2正确3847439647293047 1正确5855462940810587 3正确9742855507068353 3正确4296849643607543 3正确3174248439465858 1正确4513559094146117 2正确7890971548908067 3正确8157356344118483 1正确2615250744386899 2正确8690095851526254 3正确6375711915077050 1正确6913859173121360; 1更正6442889055042768; 2更正2321386104303845; 0更正2326509471271448; 2更正5251583379644322; 2更正1748270476758276; 3更正4895722652190306; 1更正3041631117224635; 3更正1841236454324589; 3更正2659862637316867; 2更正
</section>
找到唯一的16位秘密序列。
## Challenge Seed
<section id='challengeSeed'>
# --hints--
<div id='js-seed'>
`euler185()`应该返回4640261571849533。
```js
function euler185() {
// Good luck!
return true;
}
euler185();
assert.strictEqual(euler185(), 4640261571849533);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,31 @@
---
id: 5900f4281000cf542c50ff39
title: 问题186网络的连通性
challengeType: 5
videoUrl: ''
title: 问题186网络的连通性
---
## Description
<section id="description">以下是来自拥有100万用户的繁忙电话系统的记录 <p> RecNrCallerCalled120000710005326001835004393600863701497 .........来电者的电话号码和记录n中的被叫号码是来电者n= S2n-1和被叫n= S2n其中S1,2,3...来来自“Lagged Fibonacci Generator” </p><p>对于1≤k≤55Sk = [100003 - 200003k + 300007k3]模1000000对于56≤kSk = [Sk-24 + Sk-55]模1000000 </p><p>如果Callern= Calledn则假定用户误操作并且呼叫失败;否则通话成功。 </p><p>从记录的开头我们说如果X调用Y则任何一对用户X和Y都是朋友反之亦然。类似地如果X是Y的朋友并且Y是Z的朋友则X是Z的朋友的朋友;等等更长的链条。 </p><p>总理的电话号码是524287.经过多少次成功的电话不计算误操作99的用户包括PM将成为总理的朋友朋友的朋友等 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
以下是来自拥有100万用户的繁忙电话系统的记录
## Tests
<section id='tests'>
RecNrCallerCalled120000710005326001835004393600863701497 .........来电者的电话号码和记录n中的被叫号码是来电者n= S2n-1和被叫n= S2n其中S1,2,3...来来自“Lagged Fibonacci Generator”
```yml
tests:
- text: <code>euler186()</code>应返回2325629。
testString: assert.strictEqual(euler186(), 2325629);
对于1≤k≤55Sk = \[100003 - 200003k + 300007k3]模1000000对于56≤kSk = \[Sk-24 + Sk-55]模1000000
```
如果Callern= Calledn则假定用户误操作并且呼叫失败;否则通话成功。
</section>
从记录的开头我们说如果X调用Y则任何一对用户X和Y都是朋友反之亦然。类似地如果X是Y的朋友并且Y是Z的朋友则X是Z的朋友的朋友;等等更长的链条。
## Challenge Seed
<section id='challengeSeed'>
总理的电话号码是524287.经过多少次成功的电话不计算误操作99的用户包括PM将成为总理的朋友朋友的朋友等
<div id='js-seed'>
# --hints--
`euler186()`应返回2325629。
```js
function euler186() {
// Good luck!
return true;
}
euler186();
assert.strictEqual(euler186(), 2325629);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,25 @@
---
id: 5900f4291000cf542c50ff3a
title: 问题187半致
challengeType: 5
videoUrl: ''
title: 问题187半致
---
## Description
<section id="description">复合是包含至少两个素因子的数字。例如15 = 3×5; 9 = 3×3; 12 = 2×2×3。 <p>在30以下有十种复合材料恰好包含两个不一定是不同的主要因素4,6,9,10,14,15,21,22,25,26。 </p><p>有多少复合整数n &lt;108恰好有两个不一定是不同的素因子 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
复合是包含至少两个素因子的数字。例如15 = 3×5; 9 = 3×3; 12 = 2×2×3。
## Tests
<section id='tests'>
在30以下有十种复合材料恰好包含两个不一定是不同的主要因素4,6,9,10,14,15,21,22,25,26。
```yml
tests:
- text: <code>euler187()</code>应该返回17427258。
testString: assert.strictEqual(euler187(), 17427258);
有多少复合整数n &lt;108恰好有两个不一定是不同的素因子
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler187()`应该返回17427258。
```js
function euler187() {
// Good luck!
return true;
}
euler187();
assert.strictEqual(euler187(), 17427258);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,23 @@
---
id: 5900f4291000cf542c50ff3b
title: 问题188数字的过度扩展
challengeType: 5
videoUrl: ''
title: 问题188数字的过度扩展
---
## Description
<section id="description">由↑^ b或ba表示的正整数b的数字a的过度增强或分解通过以下方式递归地定义a↑↑1 = aa↑↑k + 1= aa↑↑k )。 <p>因此我们有例如3↑↑2 = 33 = 27因此3↑↑3 = 327 = 7625597484987和3↑↑4大致是103.6383346400240996 * 10 ^ 12。查找1777↑↑1855的最后8位数字。 </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
由↑^ b或ba表示的正整数b的数字a的过度增强或分解通过以下方式递归地定义a↑↑1 = aa↑↑k + 1= aa↑↑k )。
## Tests
<section id='tests'>
因此我们有例如3↑↑2 = 33 = 27因此3↑↑3 = 327 = 7625597484987和3↑↑4大致是103.6383346400240996 \* 10 ^ 12。查找1777↑↑1855的最后8位数字。
```yml
tests:
- text: <code>euler188()</code>应该返回95962097。
testString: assert.strictEqual(euler188(), 95962097);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`euler188()`应该返回95962097。
```js
function euler188() {
// Good luck!
return true;
}
euler188();
assert.strictEqual(euler188(), 95962097);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
// solution required
```
/section>

View File

@ -1,55 +1,29 @@
---
id: 5900f4291000cf542c50ff3c
title: 问题189三角网格三色
challengeType: 5
videoUrl: ''
title: 问题189三角网格三色
---
## Description
<section id="description">考虑以下64个三角形的配置 <p>我们希望用三种颜色中的一种为每个三角形的内部着色:红色,绿色或蓝色,这样就不会有两个相邻的三角形具有相同的颜色。这种着色应称为有效。这里,如果两个三角形共享边缘,则称它们是相邻的。注意:如果它们只共享一个顶点,那么它们不是邻居。 </p><p>例如,以下是上面网格的有效着色: </p><p>通过旋转或反射从着色C获得的着色C&#39;被认为与C不同除非两者相同。 </p><p>上述配置有多少种不同的有效着色? </p></section>
# --description--
## Instructions
<section id="instructions">
</section>
考虑以下64个三角形的配置
## Tests
<section id='tests'>
我们希望用三种颜色中的一种为每个三角形的内部着色:红色,绿色或蓝色,这样就不会有两个相邻的三角形具有相同的颜色。这种着色应称为有效。这里,如果两个三角形共享边缘,则称它们是相邻的。注意:如果它们只共享一个顶点,那么它们不是邻居。
```yml
tests:
- text: <code>euler189()</code>应该返回10834893628237824。
testString: assert.strictEqual(euler189(), 10834893628237824);
例如,以下是上面网格的有效着色:
```
通过旋转或反射从着色C获得的着色C'被认为与C不同除非两者相同。
</section>
上述配置有多少种不同的有效着色?
## Challenge Seed
<section id='challengeSeed'>
# --hints--
<div id='js-seed'>
`euler189()`应该返回10834893628237824。
```js
function euler189() {
// Good luck!
return true;
}
euler189();
assert.strictEqual(euler189(), 10834893628237824);
```
</div>
# --solutions--
</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