Oliver Eyton-Williams ee1e8abd87

feat(curriculum): restore seed + solution to Chinese (#40683 )

* feat(tools): add seed/solution restore script

* chore(curriculum): remove empty sections' markers

* chore(curriculum): add seed + solution to Chinese

* chore: remove old formatter

* fix: update getChallenges

parse translated challenges separately, without reference to the source

* chore(curriculum): add dashedName to English

* chore(curriculum): add dashedName to Chinese

* refactor: remove unused challenge property 'name'

* fix: relax dashedName requirement

* fix: stray tag

Remove stray `pre` tag from challenge file.

Signed-off-by: nhcarrigan <nhcarrigan@gmail.com>

Co-authored-by: nhcarrigan <nhcarrigan@gmail.com>

2021-01-12 19:31:00 -07:00

4.1 KiB

Raw Blame History

id, title, challengeType, videoUrl, dashedName

id	title	challengeType	videoUrl	dashedName
594d966a1467eb84194f0086	平均值 - 毕达哥拉斯指的是	5		averagespythagorean-means

--description--

计算整数1到10 （包括）的所有三个毕达哥拉斯方法。

为这组正整数显示$ A（x_1，\ ldots，x_n）\ geq G（x_1，\ ldots，x_n）\ geq H（x_1，\ ldots，x_n）$ 。

这三种方法中最常见的算术平均值是列表的总和除以其长度： $ A（x_1，\\ ldots，x_n）= \\ frac {x_1 + \\ cdots + x_n} {n} $ 几何mean是列表产品的$ n $ th根： $ G（x_1，\\ ldots，x_n）= \\ sqrt \[n] {x_1 \\ cdots x_n} $ 调和平均值是$ n $除以总和列表中每个项目的倒数： $ H（x_1，\\ ldots，x_n）= \\ frac {n} {\\ frac {1} {x_1} + \\ cdots + \\ frac {1} {x_n}} $

假设输入是包含所有数字的有序数组。

要获得答案，请按以下格式输出对象：

 {
  值：{
    算术：5.5，
    几何：4.528728688116765，
    谐波：3.414171521474055
  }，
  测试：'是A> = G> = H？是'
}

--hints--

pythagoreanMeans是一种功能。

assert(typeof pythagoreanMeans === 'function');

pythagoreanMeans([1, 2, ..., 10])应该等于上面相同的输出。

assert.deepEqual(pythagoreanMeans(range1), answer1);

--seed--

--after-user-code--

const range1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const answer1 = {
  values: {
    Arithmetic: 5.5,
    Geometric: 4.528728688116765,
    Harmonic: 3.414171521474055
  },
  test: 'is A >= G >= H ? yes'
};

--seed-contents--

function pythagoreanMeans(rangeArr) {

}

--solutions--

function pythagoreanMeans(rangeArr) {
  // arithmeticMean :: [Number] -> Number
  const arithmeticMean = xs =>
    foldl((sum, n) => sum + n, 0, xs) / length(xs);

  // geometricMean :: [Number] -> Number
  const geometricMean = xs =>
    raise(foldl((product, x) => product * x, 1, xs), 1 / length(xs));

  // harmonicMean :: [Number] -> Number
  const harmonicMean = xs =>
    length(xs) / foldl((invSum, n) => invSum + (1 / n), 0, xs);

  // GENERIC FUNCTIONS ------------------------------------------------------

  // A list of functions applied to a list of arguments
  // <*> :: [(a -> b)] -> [a] -> [b]
  const ap = (fs, xs) => //
    Array.prototype.concat(...fs.map(f => //
      Array.prototype.concat(...xs.map(x => [f(x)]))));

  // foldl :: (b -> a -> b) -> b -> [a] -> b
  const foldl = (f, a, xs) => xs.reduce(f, a);

  // length :: [a] -> Int
  const length = xs => xs.length;

  // mapFromList :: [(k, v)] -> Dictionary
  const mapFromList = kvs =>
    foldl((a, [k, v]) =>
      (a[(typeof k === 'string' && k)] = v, a), {}, kvs);

  // raise :: Num -> Int -> Num
  const raise = (n, e) => Math.pow(n, e);
/*
  // show :: a -> String
  // show :: a -> Int -> String
  const show = (...x) =>
    JSON.stringify.apply(
      null, x.length > 1 ? [x[0], null, x[1]] : x
    );
*/
  // zip :: [a] -> [b] -> [(a,b)]
  const zip = (xs, ys) =>
    xs.slice(0, Math.min(xs.length, ys.length))
      .map((x, i) => [x, ys[i]]);

  // TEST -------------------------------------------------------------------
  // mean :: Dictionary
  const mean = mapFromList(zip(
    ['Arithmetic', 'Geometric', 'Harmonic'],
    ap([arithmeticMean, geometricMean, harmonicMean], [
      rangeArr
    ])
  ));

  return {
    values: mean,
    test: `is A >= G >= H ? ${mean.Arithmetic >= mean.Geometric &&
      mean.Geometric >= mean.Harmonic ? 'yes' : 'no'}`
  };
}

4.1 KiB Raw Blame History Unescape Escape