feat: enable new langs (#42491)

Enable italian and portuguese

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md

@@ -0,0 +1,97 @@
+---
+id: a77dbc43c33f39daa4429b4f
+title: Boo who
+challengeType: 5
+forumTopicId: 16000
+dashedName: boo-who
+---
+
+# --description--
+
+Check if a value is classified as a boolean primitive. Return `true` or `false`.
+
+Boolean primitives are `true` and `false`.
+
+# --hints--
+
+`booWho(true)` should return `true`.
+
+```js
+assert.strictEqual(booWho(true), true);
+```
+
+`booWho(false)` should return `true`.
+
+```js
+assert.strictEqual(booWho(false), true);
+```
+
+`booWho([1, 2, 3])` should return `false`.
+
+```js
+assert.strictEqual(booWho([1, 2, 3]), false);
+```
+
+`booWho([].slice)` should return `false`.
+
+```js
+assert.strictEqual(booWho([].slice), false);
+```
+
+`booWho({ "a": 1 })` should return `false`.
+
+```js
+assert.strictEqual(booWho({ a: 1 }), false);
+```
+
+`booWho(1)` should return `false`.
+
+```js
+assert.strictEqual(booWho(1), false);
+```
+
+`booWho(NaN)` should return `false`.
+
+```js
+assert.strictEqual(booWho(NaN), false);
+```
+
+`booWho("a")` should return `false`.
+
+```js
+assert.strictEqual(booWho('a'), false);
+```
+
+`booWho("true")` should return `false`.
+
+```js
+assert.strictEqual(booWho('true'), false);
+```
+
+`booWho("false")` should return `false`.
+
+```js
+assert.strictEqual(booWho('false'), false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function booWho(bool) {
+  return bool;
+}
+
+booWho(null);
+```
+
+# --solutions--
+
+```js
+function booWho(bool) {
+  return typeof bool === "boolean";
+}
+
+booWho(null);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md

@@ -0,0 +1,110 @@
+---
+id: a9bd25c716030ec90084d8a1
+title: Chunky Monkey
+challengeType: 5
+forumTopicId: 16005
+dashedName: chunky-monkey
+---
+
+# --description--
+
+Write a function that splits an array (first argument) into groups the length of `size` (second argument) and returns them as a two-dimensional array.
+
+# --hints--
+
+`chunkArrayInGroups(["a", "b", "c", "d"], 2)` should return `[["a", "b"], ["c", "d"]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups(['a', 'b', 'c', 'd'], 2), [
+  ['a', 'b'],
+  ['c', 'd']
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)` should return `[[0, 1, 2], [3, 4, 5]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [
+  [0, 1, 2],
+  [3, 4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)` should return `[[0, 1], [2, 3], [4, 5]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [
+  [0, 1],
+  [2, 3],
+  [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)` should return `[[0, 1, 2, 3], [4, 5]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [
+  [0, 1, 2, 3],
+  [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)` should return `[[0, 1, 2], [3, 4, 5], [6]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [
+  [0, 1, 2],
+  [3, 4, 5],
+  [6]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)` should return `[[0, 1, 2, 3], [4, 5, 6, 7], [8]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [
+  [0, 1, 2, 3],
+  [4, 5, 6, 7],
+  [8]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)` should return `[[0, 1], [2, 3], [4, 5], [6, 7], [8]]`.
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [
+  [0, 1],
+  [2, 3],
+  [4, 5],
+  [6, 7],
+  [8]
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chunkArrayInGroups(arr, size) {
+  return arr;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
+
+# --solutions--
+
+```js
+function chunkArrayInGroups(arr, size) {
+  let out = [];
+
+  for (let i = 0; i < arr.length; i += size) {
+    out.push(arr.slice(i, i + size));
+  }
+
+  return out;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md

@@ -0,0 +1,113 @@
+---
+id: acda2fb1324d9b0fa741e6b5
+title: Confirm the Ending
+challengeType: 5
+forumTopicId: 16006
+dashedName: confirm-the-ending
+---
+
+# --description--
+
+Check if a string (first argument, `str`) ends with the given target string (second argument, `target`).
+
+This challenge *can* be solved with the `.endsWith()` method, which was introduced in ES2015. But for the purpose of this challenge, we would like you to use one of the JavaScript substring methods instead.
+
+# --hints--
+
+`confirmEnding("Bastian", "n")` should return `true`.
+
+```js
+assert(confirmEnding('Bastian', 'n') === true);
+```
+
+`confirmEnding("Congratulation", "on")` should return `true`.
+
+```js
+assert(confirmEnding('Congratulation', 'on') === true);
+```
+
+`confirmEnding("Connor", "n")` should return `false`.
+
+```js
+assert(confirmEnding('Connor', 'n') === false);
+```
+
+`confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")` should return `false`.
+
+```js
+assert(
+  confirmEnding(
+    'Walking on water and developing software from a specification are easy if both are frozen',
+    'specification'
+  ) === false
+);
+```
+
+`confirmEnding("He has to give me a new name", "name")` should return `true`.
+
+```js
+assert(confirmEnding('He has to give me a new name', 'name') === true);
+```
+
+`confirmEnding("Open sesame", "same")` should return `true`.
+
+```js
+assert(confirmEnding('Open sesame', 'same') === true);
+```
+
+`confirmEnding("Open sesame", "sage")` should return `false`.
+
+```js
+assert(confirmEnding('Open sesame', 'sage') === false);
+```
+
+`confirmEnding("Open sesame", "game")` should return `false`.
+
+```js
+assert(confirmEnding('Open sesame', 'game') === false);
+```
+
+`confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")` should return `false`.
+
+```js
+assert(
+  confirmEnding(
+    'If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing',
+    'mountain'
+  ) === false
+);
+```
+
+`confirmEnding("Abstraction", "action")` should return `true`.
+
+```js
+assert(confirmEnding('Abstraction', 'action') === true);
+```
+
+Your code should not use the built-in method `.endsWith()` to solve the challenge.
+
+```js
+assert(!/\.endsWith\(.*?\)\s*?;?/.test(code) && !/\['endsWith'\]/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function confirmEnding(str, target) {
+  return str;
+}
+
+confirmEnding("Bastian", "n");
+```
+
+# --solutions--
+
+```js
+function confirmEnding(str, target) {
+  return str.substring(str.length - target.length) === target;
+}
+
+confirmEnding("Bastian", "n");
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md

@@ -0,0 +1,76 @@
+---
+id: 56533eb9ac21ba0edf2244b3
+title: Convert Celsius to Fahrenheit
+challengeType: 1
+forumTopicId: 16806
+dashedName: convert-celsius-to-fahrenheit
+---
+
+# --description--
+
+The algorithm to convert from Celsius to Fahrenheit is the temperature in Celsius times `9/5`, plus `32`.
+
+You are given a variable `celsius` representing a temperature in Celsius. Use the variable `fahrenheit` already defined and assign it the Fahrenheit temperature equivalent to the given Celsius temperature. Use the algorithm mentioned above to help convert the Celsius temperature to Fahrenheit.
+
+# --hints--
+
+`convertToF(0)` should return a number
+
+```js
+assert(typeof convertToF(0) === 'number');
+```
+
+`convertToF(-30)` should return a value of `-22`
+
+```js
+assert(convertToF(-30) === -22);
+```
+
+`convertToF(-10)` should return a value of `14`
+
+```js
+assert(convertToF(-10) === 14);
+```
+
+`convertToF(0)` should return a value of `32`
+
+```js
+assert(convertToF(0) === 32);
+```
+
+`convertToF(20)` should return a value of `68`
+
+```js
+assert(convertToF(20) === 68);
+```
+
+`convertToF(30)` should return a value of `86`
+
+```js
+assert(convertToF(30) === 86);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToF(celsius) {
+  let fahrenheit;
+  return fahrenheit;
+}
+
+convertToF(30);
+```
+
+# --solutions--
+
+```js
+function convertToF(celsius) {
+  let fahrenheit = celsius * 9/5 + 32;
+
+  return fahrenheit;
+}
+
+convertToF(30);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md

@@ -0,0 +1,73 @@
+---
+id: a302f7aae1aa3152a5b413bc
+title: Factorialize a Number
+challengeType: 5
+forumTopicId: 16013
+dashedName: factorialize-a-number
+---
+
+# --description--
+
+Return the factorial of the provided integer.
+
+If the integer is represented with the letter `n`, a factorial is the product of all positive integers less than or equal to `n`.
+
+Factorials are often represented with the shorthand notation `n!`
+
+For example: `5! = 1 * 2 * 3 * 4 * 5 = 120`
+
+Only integers greater than or equal to zero will be supplied to the function.
+
+# --hints--
+
+`factorialize(5)` should return a number.
+
+```js
+assert(typeof factorialize(5) === 'number');
+```
+
+`factorialize(5)` should return `120`.
+
+```js
+assert(factorialize(5) === 120);
+```
+
+`factorialize(10)` should return `3628800`.
+
+```js
+assert(factorialize(10) === 3628800);
+```
+
+`factorialize(20)` should return `2432902008176640000`.
+
+```js
+assert(factorialize(20) === 2432902008176640000);
+```
+
+`factorialize(0)` should return `1`.
+
+```js
+assert(factorialize(0) === 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function factorialize(num) {
+  return num;
+}
+
+factorialize(5);
+```
+
+# --solutions--
+
+```js
+function factorialize(num) {
+  return num < 1 ? 1 : num * factorialize(num - 1);
+}
+
+factorialize(5);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md

@@ -0,0 +1,63 @@
+---
+id: adf08ec01beb4f99fc7a68f2
+title: Falsy Bouncer
+challengeType: 5
+forumTopicId: 16014
+dashedName: falsy-bouncer
+---
+
+# --description--
+
+Remove all falsy values from an array.
+
+Falsy values in JavaScript are `false`, `null`, `0`, `""`, `undefined`, and `NaN`.
+
+Hint: Try converting each value to a Boolean.
+
+# --hints--
+
+`bouncer([7, "ate", "", false, 9])` should return `[7, "ate", 9]`.
+
+```js
+assert.deepEqual(bouncer([7, 'ate', '', false, 9]), [7, 'ate', 9]);
+```
+
+`bouncer(["a", "b", "c"])` should return `["a", "b", "c"]`.
+
+```js
+assert.deepEqual(bouncer(['a', 'b', 'c']), ['a', 'b', 'c']);
+```
+
+`bouncer([false, null, 0, NaN, undefined, ""])` should return `[]`.
+
+```js
+assert.deepEqual(bouncer([false, null, 0, NaN, undefined, '']), []);
+```
+
+`bouncer([null, NaN, 1, 2, undefined])` should return `[1, 2]`.
+
+```js
+assert.deepEqual(bouncer([null, NaN, 1, 2, undefined]), [1, 2]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function bouncer(arr) {
+  return arr;
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
+
+# --solutions--
+
+```js
+function bouncer(arr) {
+  return arr.filter(e => e);
+}
+
+bouncer([7, "ate", "", false, 9]);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md

@@ -0,0 +1,87 @@
+---
+id: a26cbbe9ad8655a977e1ceb5
+title: Find the Longest Word in a String
+challengeType: 5
+forumTopicId: 16015
+dashedName: find-the-longest-word-in-a-string
+---
+
+# --description--
+
+Return the length of the longest word in the provided sentence.
+
+Your response should be a number.
+
+# --hints--
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` should return a number.
+
+```js
+assert(
+  typeof findLongestWordLength(
+    'The quick brown fox jumped over the lazy dog'
+  ) === 'number'
+);
+```
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` should return `6`.
+
+```js
+assert(
+  findLongestWordLength('The quick brown fox jumped over the lazy dog') === 6
+);
+```
+
+`findLongestWordLength("May the force be with you")` should return `5`.
+
+```js
+assert(findLongestWordLength('May the force be with you') === 5);
+```
+
+`findLongestWordLength("Google do a barrel roll")` should return `6`.
+
+```js
+assert(findLongestWordLength('Google do a barrel roll') === 6);
+```
+
+`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` should return `8`.
+
+```js
+assert(
+  findLongestWordLength(
+    'What is the average airspeed velocity of an unladen swallow'
+  ) === 8
+);
+```
+
+`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` should return `19`.
+
+```js
+assert(
+  findLongestWordLength(
+    'What if we try a super-long word such as otorhinolaryngology'
+  ) === 19
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findLongestWordLength(str) {
+  return str.length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
+
+# --solutions--
+
+```js
+function findLongestWordLength(str) {
+  return str.split(' ').sort((a, b) => b.length - a.length)[0].length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md

@@ -0,0 +1,58 @@
+---
+id: a6e40f1041b06c996f7b2406
+title: Finders Keepers
+challengeType: 5
+forumTopicId: 16016
+dashedName: finders-keepers
+---
+
+# --description--
+
+Create a function that looks through an array `arr` and returns the first element in it that passes a 'truth test'. This means that given an element `x`, the 'truth test' is passed if `func(x)` is `true`. If no element passes the test, return `undefined`.
+
+# --hints--
+
+`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` should return `8`.
+
+```js
+assert.strictEqual(
+  findElement([1, 3, 5, 8, 9, 10], function (num) {
+    return num % 2 === 0;
+  }),
+  8
+);
+```
+
+`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` should return `undefined`.
+
+```js
+assert.strictEqual(
+  findElement([1, 3, 5, 9], function (num) {
+    return num % 2 === 0;
+  }),
+  undefined
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findElement(arr, func) {
+  let num = 0;
+  return num;
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
+
+# --solutions--
+
+```js
+function findElement(arr, func) {
+  return arr.filter(func)[0];
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md

@@ -0,0 +1,117 @@
+---
+id: af2170cad53daa0770fabdea
+title: Mutations
+challengeType: 5
+forumTopicId: 16025
+dashedName: mutations
+---
+
+# --description--
+
+Return `true` if the string in the first element of the array contains all of the letters of the string in the second element of the array.
+
+For example, `["hello", "Hello"]`, should return `true` because all of the letters in the second string are present in the first, ignoring case.
+
+The arguments `["hello", "hey"]` should return `false` because the string `hello` does not contain a `y`.
+
+Lastly, `["Alien", "line"]`, should return `true` because all of the letters in `line` are present in `Alien`.
+
+# --hints--
+
+`mutation(["hello", "hey"])` should return `false`.
+
+```js
+assert(mutation(['hello', 'hey']) === false);
+```
+
+`mutation(["hello", "Hello"])` should return `true`.
+
+```js
+assert(mutation(['hello', 'Hello']) === true);
+```
+
+`mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])` should return `true`.
+
+```js
+assert(mutation(['zyxwvutsrqponmlkjihgfedcba', 'qrstu']) === true);
+```
+
+`mutation(["Mary", "Army"])` should return `true`.
+
+```js
+assert(mutation(['Mary', 'Army']) === true);
+```
+
+`mutation(["Mary", "Aarmy"])` should return `true`.
+
+```js
+assert(mutation(['Mary', 'Aarmy']) === true);
+```
+
+`mutation(["Alien", "line"])` should return `true`.
+
+```js
+assert(mutation(['Alien', 'line']) === true);
+```
+
+`mutation(["floor", "for"])` should return `true`.
+
+```js
+assert(mutation(['floor', 'for']) === true);
+```
+
+`mutation(["hello", "neo"])` should return `false`.
+
+```js
+assert(mutation(['hello', 'neo']) === false);
+```
+
+`mutation(["voodoo", "no"])` should return `false`.
+
+```js
+assert(mutation(['voodoo', 'no']) === false);
+```
+
+`mutation(["ate", "date"])` should return `false`.
+
+```js
+assert(mutation(['ate', 'date']) === false);
+```
+
+`mutation(["Tiger", "Zebra"])` should return `false`.
+
+```js
+assert(mutation(['Tiger', 'Zebra']) === false);
+```
+
+`mutation(["Noel", "Ole"])` should return `true`.
+
+```js
+assert(mutation(['Noel', 'Ole']) === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mutation(arr) {
+  return arr;
+}
+
+mutation(["hello", "hey"]);
+```
+
+# --solutions--
+
+```js
+function mutation(arr) {
+  let hash = Object.create(null);
+
+  arr[0].toLowerCase().split('').forEach(c => hash[c] = true);
+
+  return !arr[1].toLowerCase().split('').filter(c => !hash[c]).length;
+}
+
+mutation(["hello", "hey"]);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md

@@ -0,0 +1,84 @@
+---
+id: afcc8d540bea9ea2669306b6
+title: Repeat a String Repeat a String
+challengeType: 5
+forumTopicId: 16041
+dashedName: repeat-a-string-repeat-a-string
+---
+
+# --description--
+
+Repeat a given string `str` (first argument) for `num` times (second argument). Return an empty string if `num` is not a positive number. For the purpose of this challenge, do *not* use the built-in `.repeat()` method.
+
+# --hints--
+
+`repeatStringNumTimes("*", 3)` should return the string `***`.
+
+```js
+assert(repeatStringNumTimes('*', 3) === '***');
+```
+
+`repeatStringNumTimes("abc", 3)` should return the string `abcabcabc`.
+
+```js
+assert(repeatStringNumTimes('abc', 3) === 'abcabcabc');
+```
+
+`repeatStringNumTimes("abc", 4)` should return the string `abcabcabcabc`.
+
+```js
+assert(repeatStringNumTimes('abc', 4) === 'abcabcabcabc');
+```
+
+`repeatStringNumTimes("abc", 1)` should return the string `abc`.
+
+```js
+assert(repeatStringNumTimes('abc', 1) === 'abc');
+```
+
+`repeatStringNumTimes("*", 8)` should return the string `********`.
+
+```js
+assert(repeatStringNumTimes('*', 8) === '********');
+```
+
+`repeatStringNumTimes("abc", -2)` should return an empty string (`""`).
+
+```js
+assert(repeatStringNumTimes('abc', -2) === '');
+```
+
+The built-in `repeat()` method should not be used.
+
+```js
+assert(!/\.repeat/g.test(code));
+```
+
+`repeatStringNumTimes("abc", 0)` should return `""`.
+
+```js
+assert(repeatStringNumTimes('abc', 0) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function repeatStringNumTimes(str, num) {
+  return str;
+}
+
+repeatStringNumTimes("abc", 3);
+```
+
+# --solutions--
+
+```js
+function repeatStringNumTimes(str, num) {
+  if (num < 1) return '';
+  return num === 1 ? str : str + repeatStringNumTimes(str, num-1);
+}
+
+repeatStringNumTimes("abc", 3);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md

@@ -0,0 +1,92 @@
+---
+id: a789b3483989747d63b0e427
+title: Return Largest Numbers in Arrays
+challengeType: 5
+forumTopicId: 16042
+dashedName: return-largest-numbers-in-arrays
+---
+
+# --description--
+
+Return an array consisting of the largest number from each provided sub-array. For simplicity, the provided array will contain exactly 4 sub-arrays.
+
+Remember, you can iterate through an array with a simple for loop, and access each member with array syntax `arr[i]`.
+
+# --hints--
+
+`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` should return an array.
+
+```js
+assert(
+  largestOfFour([
+    [4, 5, 1, 3],
+    [13, 27, 18, 26],
+    [32, 35, 37, 39],
+    [1000, 1001, 857, 1]
+  ]).constructor === Array
+);
+```
+
+`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` should return `[27, 5, 39, 1001]`.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [13, 27, 18, 26],
+    [4, 5, 1, 3],
+    [32, 35, 37, 39],
+    [1000, 1001, 857, 1]
+  ]),
+  [27, 5, 39, 1001]
+);
+```
+
+`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` should return `[9, 35, 97, 1000000]`.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [4, 9, 1, 3],
+    [13, 35, 18, 26],
+    [32, 35, 97, 39],
+    [1000000, 1001, 857, 1]
+  ]),
+  [9, 35, 97, 1000000]
+);
+```
+
+`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` should return `[25, 48, 21, -3]`.
+
+```js
+assert.deepEqual(
+  largestOfFour([
+    [17, 23, 25, 12],
+    [25, 7, 34, 48],
+    [4, -10, 18, 21],
+    [-72, -3, -17, -10]
+  ]),
+  [25, 48, 21, -3]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function largestOfFour(arr) {
+  return arr;
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
+
+# --solutions--
+
+```js
+function largestOfFour(arr) {
+  return arr.map(subArr => Math.max.apply(null, subArr));
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md

@@ -0,0 +1,63 @@
+---
+id: a202eed8fc186c8434cb6d61
+title: Reverse a String
+challengeType: 5
+forumTopicId: 16043
+dashedName: reverse-a-string
+---
+
+# --description--
+
+Reverse the provided string.
+
+You may need to turn the string into an array before you can reverse it.
+
+Your result must be a string.
+
+# --hints--
+
+`reverseString("hello")` should return a string.
+
+```js
+assert(typeof reverseString('hello') === 'string');
+```
+
+`reverseString("hello")` should return the string `olleh`.
+
+```js
+assert(reverseString('hello') === 'olleh');
+```
+
+`reverseString("Howdy")` should return the string `ydwoH`.
+
+```js
+assert(reverseString('Howdy') === 'ydwoH');
+```
+
+`reverseString("Greetings from Earth")` should return the string `htraE morf sgniteerG`.
+
+```js
+assert(reverseString('Greetings from Earth') === 'htraE morf sgniteerG');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function reverseString(str) {
+  return str;
+}
+
+reverseString("hello");
+```
+
+# --solutions--
+
+```js
+function reverseString(str) {
+  return str.split('').reverse().join('');
+}
+
+reverseString("hello");
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md

@@ -0,0 +1,98 @@
+---
+id: 579e2a2c335b9d72dd32e05c
+title: Slice and Splice
+challengeType: 5
+forumTopicId: 301148
+dashedName: slice-and-splice
+---
+
+# --description--
+
+You are given two arrays and an index.
+
+Copy each element of the first array into the second array, in order.
+
+Begin inserting elements at index `n` of the second array.
+
+Return the resulting array. The input arrays should remain the same after the function runs.
+
+# --hints--
+
+`frankenSplice([1, 2, 3], [4, 5], 1)` should return `[4, 1, 2, 3, 5]`.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5]);
+```
+
+`frankenSplice([1, 2], ["a", "b"], 1)` should return `["a", 1, 2, "b"]`.
+
+```js
+assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ['a', 1, 2, 'b']);
+```
+
+`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` should return `["head", "shoulders", "claw", "tentacle", "knees", "toes"]`.
+
+```js
+assert.deepEqual(
+  frankenSplice(
+    ['claw', 'tentacle'],
+    ['head', 'shoulders', 'knees', 'toes'],
+    2
+  ),
+  ['head', 'shoulders', 'claw', 'tentacle', 'knees', 'toes']
+);
+```
+
+All elements from the first array should be added to the second array in their original order.
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4]);
+```
+
+The first array should remain the same after the function runs.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr1, [1, 2]);
+```
+
+The second array should remain the same after the function runs.
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr2, ['a', 'b']);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+let testArr1 = [1, 2];
+let testArr2 = ["a", "b"];
+```
+
+## --seed-contents--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+  return arr2;
+}
+
+frankenSplice([1, 2, 3], [4, 5, 6], 1);
+```
+
+# --solutions--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+  // It's alive. It's alive!
+  let result = arr2.slice();
+  for (let i = 0; i < arr1.length; i++) {
+    result.splice(n+i, 0, arr1[i]);
+  }
+  return result;
+}
+
+frankenSplice([1, 2, 3], [4, 5], 1);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md

@@ -0,0 +1,64 @@
+---
+id: ab6137d4e35944e21037b769
+title: Title Case a Sentence
+challengeType: 5
+forumTopicId: 16088
+dashedName: title-case-a-sentence
+---
+
+# --description--
+
+Return the provided string with the first letter of each word capitalized. Make sure the rest of the word is in lower case.
+
+For the purpose of this exercise, you should also capitalize connecting words like `the` and `of`.
+
+# --hints--
+
+`titleCase("I'm a little tea pot")` should return a string.
+
+```js
+assert(typeof titleCase("I'm a little tea pot") === 'string');
+```
+
+`titleCase("I'm a little tea pot")` should return the string `I'm A Little Tea Pot`.
+
+```js
+assert(titleCase("I'm a little tea pot") === "I'm A Little Tea Pot");
+```
+
+`titleCase("sHoRt AnD sToUt")` should return the string `Short And Stout`.
+
+```js
+assert(titleCase('sHoRt AnD sToUt') === 'Short And Stout');
+```
+
+`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` should return the string `Here Is My Handle Here Is My Spout`.
+
+```js
+assert(
+  titleCase('HERE IS MY HANDLE HERE IS MY SPOUT') ===
+    'Here Is My Handle Here Is My Spout'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function titleCase(str) {
+  return str;
+}
+
+titleCase("I'm a little tea pot");
+```
+
+# --solutions--
+
+```js
+function titleCase(str) {
+  return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.substring(1).toLowerCase()).join(' ');
+}
+
+titleCase("I'm a little tea pot");
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md

@@ -0,0 +1,91 @@
+---
+id: ac6993d51946422351508a41
+title: Truncate a String
+challengeType: 5
+forumTopicId: 16089
+dashedName: truncate-a-string
+---
+
+# --description--
+
+Truncate a string (first argument) if it is longer than the given maximum string length (second argument). Return the truncated string with a `...` ending.
+
+# --hints--
+
+`truncateString("A-tisket a-tasket A green and yellow basket", 8)` should return the string `A-tisket...`.
+
+```js
+assert(
+  truncateString('A-tisket a-tasket A green and yellow basket', 8) ===
+    'A-tisket...'
+);
+```
+
+`truncateString("Peter Piper picked a peck of pickled peppers", 11)` should return the string `Peter Piper...`.
+
+```js
+assert(
+  truncateString('Peter Piper picked a peck of pickled peppers', 11) ===
+    'Peter Piper...'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)` should return the string `A-tisket a-tasket A green and yellow basket`.
+
+```js
+assert(
+  truncateString(
+    'A-tisket a-tasket A green and yellow basket',
+    'A-tisket a-tasket A green and yellow basket'.length
+  ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)` should return the string `A-tisket a-tasket A green and yellow basket`.
+
+```js
+assert(
+  truncateString(
+    'A-tisket a-tasket A green and yellow basket',
+    'A-tisket a-tasket A green and yellow basket'.length + 2
+  ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-", 1)` should return the string `A...`.
+
+```js
+assert(truncateString('A-', 1) === 'A...');
+```
+
+`truncateString("Absolutely Longer", 2)` should return the string `Ab...`.
+
+```js
+assert(truncateString('Absolutely Longer', 2) === 'Ab...');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function truncateString(str, num) {
+  return str;
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
+
+# --solutions--
+
+```js
+function truncateString(str, num) {
+  if (num >= str.length) {
+    return str;
+  }
+
+  return str.slice(0, num) + '...';
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md

@@ -0,0 +1,143 @@
+---
+id: a24c1a4622e3c05097f71d67
+title: Where do I Belong
+challengeType: 5
+forumTopicId: 16094
+dashedName: where-do-i-belong
+---
+
+# --description--
+
+Return the lowest index at which a value (second argument) should be inserted into an array (first argument) once it has been sorted. The returned value should be a number.
+
+For example, `getIndexToIns([1,2,3,4], 1.5)` should return `1` because it is greater than `1` (index 0), but less than `2` (index 1).
+
+Likewise, `getIndexToIns([20,3,5], 19)` should return `2` because once the array has been sorted it will look like `[3,5,20]` and `19` is less than `20` (index 2) and greater than `5` (index 1).
+
+# --hints--
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` should return `3`.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` should return a number.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 35) === 'number');
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` should return `2`.
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` should return a number.
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 30) === 'number');
+```
+
+`getIndexToIns([40, 60], 50)` should return `1`.
+
+```js
+assert(getIndexToIns([40, 60], 50) === 1);
+```
+
+`getIndexToIns([40, 60], 50)` should return a number.
+
+```js
+assert(typeof getIndexToIns([40, 60], 50) === 'number');
+```
+
+`getIndexToIns([3, 10, 5], 3)` should return `0`.
+
+```js
+assert(getIndexToIns([3, 10, 5], 3) === 0);
+```
+
+`getIndexToIns([3, 10, 5], 3)` should return a number.
+
+```js
+assert(typeof getIndexToIns([3, 10, 5], 3) === 'number');
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` should return `2`.
+
+```js
+assert(getIndexToIns([5, 3, 20, 3], 5) === 2);
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` should return a number.
+
+```js
+assert(typeof getIndexToIns([5, 3, 20, 3], 5) === 'number');
+```
+
+`getIndexToIns([2, 20, 10], 19)` should return `2`.
+
+```js
+assert(getIndexToIns([2, 20, 10], 19) === 2);
+```
+
+`getIndexToIns([2, 20, 10], 19)` should return a number.
+
+```js
+assert(typeof getIndexToIns([2, 20, 10], 19) === 'number');
+```
+
+`getIndexToIns([2, 5, 10], 15)` should return `3`.
+
+```js
+assert(getIndexToIns([2, 5, 10], 15) === 3);
+```
+
+`getIndexToIns([2, 5, 10], 15)` should return a number.
+
+```js
+assert(typeof getIndexToIns([2, 5, 10], 15) === 'number');
+```
+
+`getIndexToIns([], 1)` should return `0`.
+
+```js
+assert(getIndexToIns([], 1) === 0);
+```
+
+`getIndexToIns([], 1)` should return a number.
+
+```js
+assert(typeof getIndexToIns([], 1) === 'number');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getIndexToIns(arr, num) {
+  return num;
+}
+
+getIndexToIns([40, 60], 50);
+```
+
+# --solutions--
+
+```js
+function getIndexToIns(arr, num) {
+  arr = arr.sort((a, b) => a - b);
+
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] >= num) {
+      return i;
+    }
+  }
+
+  return arr.length;
+}
+
+getIndexToIns([40, 60], 50);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md

@@ -0,0 +1,82 @@
+---
+id: 5a661e0f1068aca922b3ef17
+title: Access an Array's Contents Using Bracket Notation
+challengeType: 1
+forumTopicId: 301149
+dashedName: access-an-arrays-contents-using-bracket-notation
+---
+
+# --description--
+
+The fundamental feature of any data structure is, of course, the ability to not only store data, but to be able to retrieve that data on command. So, now that we've learned how to create an array, let's begin to think about how we can access that array's information.
+
+When we define a simple array as seen below, there are 3 items in it:
+
+```js
+let ourArray = ["a", "b", "c"];
+```
+
+In an array, each array item has an <dfn>index</dfn>. This index doubles as the position of that item in the array, and how you reference it. However, it is important to note, that JavaScript arrays are <dfn>zero-indexed</dfn>, meaning that the first element of an array is actually at the ***zeroth*** position, not the first. In order to retrieve an element from an array we can enclose an index in brackets and append it to the end of an array, or more commonly, to a variable which references an array object. This is known as <dfn>bracket notation</dfn>. For example, if we want to retrieve the `a` from `ourArray` and assign it to a variable, we can do so with the following code:
+
+```js
+let ourVariable = ourArray[0];
+```
+
+Now `ourVariable` has the value of `a`.
+
+In addition to accessing the value associated with an index, you can also *set* an index to a value using the same notation:
+
+```js
+ourArray[1] = "not b anymore";
+```
+
+Using bracket notation, we have now reset the item at index 1 from the string `b`, to `not b anymore`. Now `ourArray` is `["a", "not b anymore", "c"]`.
+
+# --instructions--
+
+In order to complete this challenge, set the 2nd position (index `1`) of `myArray` to anything you want, besides the letter `b`.
+
+# --hints--
+
+`myArray[0]` should be equal to the letter `a`
+
+```js
+assert.strictEqual(myArray[0], 'a');
+```
+
+`myArray[1]` should not be equal to the letter `b`
+
+```js
+assert.notStrictEqual(myArray[1], 'b');
+```
+
+`myArray[2]` should be equal to the letter `c`
+
+```js
+assert.strictEqual(myArray[2], 'c');
+```
+
+`myArray[3]` should be equal to the letter `d`
+
+```js
+assert.strictEqual(myArray[3], 'd');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+// Only change code below this line
+
+// Only change code above this line
+console.log(myArray);
+```
+
+# --solutions--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+myArray[1] = "e";
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md

@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b1a
+title: Access Property Names with Bracket Notation
+challengeType: 1
+forumTopicId: 301150
+dashedName: access-property-names-with-bracket-notation
+---
+
+# --description--
+
+In the first object challenge we mentioned the use of bracket notation as a way to access property values using the evaluation of a variable. For instance, imagine that our `foods` object is being used in a program for a supermarket cash register. We have some function that sets the `selectedFood` and we want to check our `foods` object for the presence of that food. This might look like:
+
+```js
+let selectedFood = getCurrentFood(scannedItem);
+let inventory = foods[selectedFood];
+```
+
+This code will evaluate the value stored in the `selectedFood` variable and return the value of that key in the `foods` object, or `undefined` if it is not present. Bracket notation is very useful because sometimes object properties are not known before runtime or we need to access them in a more dynamic way.
+
+# --instructions--
+
+We've defined a function, `checkInventory`, which receives a scanned item as an argument. Return the current value of the `scannedItem` key in the `foods` object. You can assume that only valid keys will be provided as an argument to `checkInventory`.
+
+# --hints--
+
+`checkInventory` should be a function.
+
+```js
+assert.strictEqual(typeof checkInventory, 'function');
+```
+
+The `foods` object should have only the following key-value pairs: `apples: 25`, `oranges: 32`, `plums: 28`, `bananas: 13`, `grapes: 35`, `strawberries: 27`.
+
+```js
+assert.deepEqual(foods, {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+});
+```
+
+`checkInventory("apples")` should return `25`.
+
+```js
+assert.strictEqual(checkInventory('apples'), 25);
+```
+
+`checkInventory("bananas")` should return `13`.
+
+```js
+assert.strictEqual(checkInventory('bananas'), 13);
+```
+
+`checkInventory("strawberries")` should return `27`.
+
+```js
+assert.strictEqual(checkInventory('strawberries'), 27);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(checkInventory("apples"));
+```
+
+# --solutions--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+  return foods[scannedItem];
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md

@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b0e
+title: Add Items to an Array with push() and unshift()
+challengeType: 1
+forumTopicId: 301151
+dashedName: add-items-to-an-array-with-push-and-unshift
+---
+
+# --description--
+
+An array's length, like the data types it can contain, is not fixed. Arrays can be defined with a length of any number of elements, and elements can be added or removed over time; in other words, arrays are <dfn>mutable</dfn>. In this challenge, we will look at two methods with which we can programmatically modify an array: `Array.push()` and `Array.unshift()`.
+
+Both methods take one or more elements as parameters and add those elements to the array the method is being called on; the `push()` method adds elements to the end of an array, and `unshift()` adds elements to the beginning. Consider the following:
+
+```js
+let twentyThree = 'XXIII';
+let romanNumerals = ['XXI', 'XXII'];
+
+romanNumerals.unshift('XIX', 'XX');
+```
+
+`romanNumerals` would have the value `['XIX', 'XX', 'XXI', 'XXII']`.
+
+```js
+romanNumerals.push(twentyThree);
+```
+
+`romanNumerals` would have the value `['XIX', 'XX', 'XXI', 'XXII', 'XXIII']`. Notice that we can also pass variables, which allows us even greater flexibility in dynamically modifying our array's data.
+
+# --instructions--
+
+We have defined a function, `mixedNumbers`, which we are passing an array as an argument. Modify the function by using `push()` and `unshift()` to add `'I', 2, 'three'` to the beginning of the array and `7, 'VIII', 9` to the end so that the returned array contains representations of the numbers 1-9 in order.
+
+# --hints--
+
+`mixedNumbers(["IV", 5, "six"])` should now return `["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]`
+
+```js
+assert.deepEqual(mixedNumbers(['IV', 5, 'six']), [
+  'I',
+  2,
+  'three',
+  'IV',
+  5,
+  'six',
+  7,
+  'VIII',
+  9
+]);
+```
+
+The `mixedNumbers` function should utilize the `push()` method
+
+```js
+assert(mixedNumbers.toString().match(/\.push/));
+```
+
+The `mixedNumbers` function should utilize the `unshift()` method
+
+```js
+assert(mixedNumbers.toString().match(/\.unshift/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mixedNumbers(arr) {
+  // Only change code below this line
+
+  // Only change code above this line
+  return arr;
+}
+
+console.log(mixedNumbers(['IV', 5, 'six']));
+```
+
+# --solutions--
+
+```js
+function mixedNumbers(arr) {
+  arr.push(7,'VIII',9);
+  arr.unshift('I',2,'three');
+  return arr;
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md

@@ -0,0 +1,93 @@
+---
+id: 587d78b3367417b2b2512b11
+title: Add Items Using splice()
+challengeType: 1
+forumTopicId: 301152
+dashedName: add-items-using-splice
+---
+
+# --description--
+
+Remember in the last challenge we mentioned that `splice()` can take up to three parameters? Well, you can use the third parameter, comprised of one or more element(s), to add to the array. This can be incredibly useful for quickly switching out an element, or a set of elements, for another.
+
+```js
+const numbers = [10, 11, 12, 12, 15];
+const startIndex = 3;
+const amountToDelete = 1;
+
+numbers.splice(startIndex, amountToDelete, 13, 14);
+console.log(numbers);
+```
+
+The second occurrence of `12` is removed, and we add `13` and `14` at the same index. The `numbers` array would now be `[ 10, 11, 12, 13, 14, 15 ]`.
+
+Here, we begin with an array of numbers. Then, we pass the following to `splice()`: The index at which to begin deleting elements (3), the number of elements to be deleted (1), and the remaining arguments (13, 14) will be inserted starting at that same index. Note that there can be any number of elements (separated by commas) following `amountToDelete`, each of which gets inserted.
+
+# --instructions--
+
+We have defined a function, `htmlColorNames`, which takes an array of HTML colors as an argument. Modify the function using `splice()` to remove the first two elements of the array and add `'DarkSalmon'` and `'BlanchedAlmond'` in their respective places.
+
+# --hints--
+
+`htmlColorNames` should return `["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurquoise", "FireBrick"]`
+
+```js
+assert.deepEqual(
+  htmlColorNames([
+    'DarkGoldenRod',
+    'WhiteSmoke',
+    'LavenderBlush',
+    'PaleTurquoise',
+    'FireBrick'
+  ]),
+  [
+    'DarkSalmon',
+    'BlanchedAlmond',
+    'LavenderBlush',
+    'PaleTurquoise',
+    'FireBrick'
+  ]
+);
+```
+
+The `htmlColorNames` function should utilize the `splice()` method
+
+```js
+assert(/.splice/.test(code));
+```
+
+You should not use `shift()` or `unshift()`.
+
+```js
+assert(!/shift|unshift/.test(code));
+```
+
+You should not use array bracket notation.
+
+```js
+assert(!/\[\d\]\s*=/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function htmlColorNames(arr) {
+  // Only change code below this line
+
+  // Only change code above this line
+  return arr;
+}
+
+console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurquoise', 'FireBrick']));
+```
+
+# --solutions--
+
+```js
+function htmlColorNames(arr) {
+  arr.splice(0,2,'DarkSalmon', 'BlanchedAlmond');
+  return arr;
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md

@@ -0,0 +1,124 @@
+---
+id: 587d7b7c367417b2b2512b18
+title: Add Key-Value Pairs to JavaScript Objects
+challengeType: 1
+forumTopicId: 301153
+dashedName: add-key-value-pairs-to-javascript-objects
+---
+
+# --description--
+
+At their most basic, objects are just collections of <dfn>key-value</dfn> pairs. In other words, they are pieces of data (<dfn>values</dfn>) mapped to unique identifiers called <dfn>properties</dfn> (<dfn>keys</dfn>). Take a look at an example:
+
+```js
+const tekkenCharacter = {
+  player: 'Hwoarang',
+  fightingStyle: 'Tae Kwon Doe',
+  human: true
+};
+```
+
+The above code defines a Tekken video game character object called `tekkenCharacter`. It has three properties, each of which map to a specific value. If you want to add an additional property, such as "origin", it can be done by assigning `origin` to the object:
+
+```js
+tekkenCharacter.origin = 'South Korea';
+```
+
+This uses dot notation. If you were to observe the `tekkenCharacter` object, it will now include the `origin` property. Hwoarang also had distinct orange hair. You can add this property with bracket notation by doing:
+
+```js
+tekkenCharacter['hair color'] = 'dyed orange';
+```
+
+Bracket notation is required if your property has a space in it or if you want to use a variable to name the property. In the above case, the property is enclosed in quotes to denote it as a string and will be added exactly as shown. Without quotes, it will be evaluated as a variable and the name of the property will be whatever value the variable is. Here's an example with a variable:
+
+```js
+const eyes = 'eye color';
+
+tekkenCharacter[eyes] = 'brown';
+```
+
+After adding all the examples, the object will look like this:
+
+```js
+{
+  player: 'Hwoarang',
+  fightingStyle: 'Tae Kwon Doe',
+  human: true,
+  origin: 'South Korea',
+  'hair color': 'dyed orange',
+  'eye color': 'brown'
+};
+```
+
+# --instructions--
+
+A `foods` object has been created with three entries. Using the syntax of your choice, add three more entries to it: `bananas` with a value of `13`, `grapes` with a value of `35`, and `strawberries` with a value of `27`.
+
+# --hints--
+
+`foods` should be an object.
+
+```js
+assert(typeof foods === 'object');
+```
+
+The `foods` object should have a key `bananas` with a value of `13`.
+
+```js
+assert(foods.bananas === 13);
+```
+
+The `foods` object should have a key `grapes` with a value of `35`.
+
+```js
+assert(foods.grapes === 35);
+```
+
+The `foods` object should have a key `strawberries` with a value of `27`.
+
+```js
+assert(foods.strawberries === 27);
+```
+
+The key-value pairs should be set using dot or bracket notation.
+
+```js
+assert(
+  code.search(/bananas:/) === -1 &&
+    code.search(/grapes:/) === -1 &&
+    code.search(/strawberries:/) === -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28
+};
+
+foods['bananas'] = 13;
+foods['grapes']  = 35;
+foods['strawberries'] = 27;
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md

@@ -0,0 +1,93 @@
+---
+id: 587d7b7b367417b2b2512b14
+title: Check For The Presence of an Element With indexOf()
+challengeType: 1
+forumTopicId: 301154
+dashedName: check-for-the-presence-of-an-element-with-indexof
+---
+
+# --description--
+
+Since arrays can be changed, or *mutated*, at any time, there's no guarantee about where a particular piece of data will be on a given array, or if that element even still exists. Luckily, JavaScript provides us with another built-in method, `indexOf()`, that allows us to quickly and easily check for the presence of an element on an array. `indexOf()` takes an element as a parameter, and when called, it returns the position, or index, of that element, or `-1` if the element does not exist on the array.
+
+For example:
+
+```js
+let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];
+
+fruits.indexOf('dates');
+fruits.indexOf('oranges');
+fruits.indexOf('pears');
+```
+
+`indexOf('dates')` returns `-1`, `indexOf('oranges')` returns `2`, and `indexOf('pears')` returns `1` (the first index at which each element exists).
+
+# --instructions--
+
+`indexOf()` can be incredibly useful for quickly checking for the presence of an element on an array. We have defined a function, `quickCheck`, that takes an array and an element as arguments. Modify the function using `indexOf()` so that it returns `true` if the passed element exists on the array, and `false` if it does not.
+
+# --hints--
+
+The `quickCheck` function should return a boolean (`true` or `false`), not a string (`"true"` or `"false"`)
+
+```js
+assert.isBoolean(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+`quickCheck(["squash", "onions", "shallots"], "mushrooms")` should return `false`
+
+```js
+assert.strictEqual(
+  quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'),
+  false
+);
+```
+
+`quickCheck(["onions", "squash", "shallots"], "onions")` should return `true`
+
+```js
+assert.strictEqual(
+  quickCheck(['onions', 'squash', 'shallots'], 'onions'),
+  true
+);
+```
+
+`quickCheck([3, 5, 9, 125, 45, 2], 125)` should return `true`
+
+```js
+assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true);
+```
+
+`quickCheck([true, false, false], undefined)` should return `false`
+
+```js
+assert.strictEqual(quickCheck([true, false, false], undefined), false);
+```
+
+The `quickCheck` function should utilize the `indexOf()` method
+
+```js
+assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function quickCheck(arr, elem) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+# --solutions--
+
+```js
+function quickCheck(arr, elem) {
+  return arr.indexOf(elem) >= 0; 
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md

@@ -0,0 +1,161 @@
+---
+id: 587d7b7d367417b2b2512b1c
+title: Check if an Object has a Property
+challengeType: 1
+forumTopicId: 301155
+dashedName: check-if-an-object-has-a-property
+---
+
+# --description--
+
+Now we can add, modify, and remove keys from objects. But what if we just wanted to know if an object has a specific property? JavaScript provides us with two different ways to do this. One uses the `hasOwnProperty()` method and the other uses the `in` keyword. If we have an object `users` with a property of `Alan`, we could check for its presence in either of the following ways:
+
+```js
+users.hasOwnProperty('Alan');
+'Alan' in users;
+```
+
+Both of these would return `true`.
+
+# --instructions--
+
+Finish writing the function so that it returns true if the object passed to it contains all four names, `Alan`, `Jeff`, `Sarah` and `Ryan` and returns false otherwise.
+
+# --hints--
+
+The `users` object should not be accessed directly
+
+```js 
+
+assert(code.match(/users/gm).length <= 2)
+
+```
+
+The `users` object should only contain the keys `Alan`, `Jeff`, `Sarah`, and `Ryan`
+
+```js
+assert(
+  'Alan' in users &&
+    'Jeff' in users &&
+    'Sarah' in users &&
+    'Ryan' in users &&
+    Object.keys(users).length === 4
+);
+```
+
+The function `isEveryoneHere` should return `true` if `Alan`, `Jeff`, `Sarah`, and `Ryan` are properties on the object passed to it. 
+
+```js
+assert(isEveryoneHere(users) === true);
+```
+
+The function `isEveryoneHere` should return `false` if `Alan` is not a property on the object passed to it.
+
+```js
+assert(
+  (function () {
+    delete users.Alan;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+The function `isEveryoneHere` should return `false` if `Jeff` is not a property on the object passed to it.
+
+```js
+assert(
+  (function () {
+    delete users.Jeff;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+The function `isEveryoneHere` should return `false` if `Sarah` is not a property on the object passed to it.
+
+```js
+assert(
+  (function () {
+    delete users.Sarah;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+The function `isEveryoneHere` should return `false` if `Ryan` is not a property on the object passed to it.
+
+```js
+assert(
+  (function () {
+    delete users.Ryan;
+    return isEveryoneHere(users);
+  })() === false
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: true
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: true
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function isEveryoneHere(userObj) {
+  // Only change code below this line
+  
+  // Only change code above this line
+}
+
+console.log(isEveryoneHere(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: true
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: true
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function isEveryoneHere(userObj) {
+  return [
+    'Alan',
+    'Jeff',
+    'Sarah',
+    'Ryan'
+  ].every(user => userObj.hasOwnProperty(user));
+}
+
+console.log(isEveryoneHere(users));
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md

@@ -0,0 +1,63 @@
+---
+id: 587d7b7b367417b2b2512b17
+title: Combine Arrays with the Spread Operator
+challengeType: 1
+forumTopicId: 301156
+dashedName: combine-arrays-with-the-spread-operator
+---
+
+# --description--
+
+Another huge advantage of the <dfn>spread</dfn> operator is the ability to combine arrays, or to insert all the elements of one array into another, at any index. With more traditional syntaxes, we can concatenate arrays, but this only allows us to combine arrays at the end of one, and at the start of another. Spread syntax makes the following operation extremely simple:
+
+```js
+let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];
+
+let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];
+```
+
+`thatArray` would have the value `['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']`.
+
+Using spread syntax, we have just achieved an operation that would have been more complex and more verbose had we used traditional methods.
+
+# --instructions--
+
+We have defined a function `spreadOut` that returns the variable `sentence`. Modify the function using the <dfn>spread</dfn> operator so that it returns the array `['learning', 'to', 'code', 'is', 'fun']`.
+
+# --hints--
+
+`spreadOut` should return `["learning", "to", "code", "is", "fun"]`
+
+```js
+assert.deepEqual(spreadOut(), ['learning', 'to', 'code', 'is', 'fun']);
+```
+
+The `spreadOut` function should utilize spread syntax
+
+```js
+assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function spreadOut() {
+  let fragment = ['to', 'code'];
+  let sentence; // Change this line
+  return sentence;
+}
+
+console.log(spreadOut());
+```
+
+# --solutions--
+
+```js
+function spreadOut() {
+  let fragment = ['to', 'code'];
+  let sentence = ['learning', ...fragment, 'is', 'fun'];
+  return sentence;
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md

@@ -0,0 +1,102 @@
+---
+id: 587d7b7b367417b2b2512b13
+title: Copy an Array with the Spread Operator
+challengeType: 1
+forumTopicId: 301157
+dashedName: copy-an-array-with-the-spread-operator
+---
+
+# --description--
+
+While `slice()` allows us to be selective about what elements of an array to copy, among several other useful tasks, ES6's new <dfn>spread operator</dfn> allows us to easily copy *all* of an array's elements, in order, with a simple and highly readable syntax. The spread syntax simply looks like this: `...`
+
+In practice, we can use the spread operator to copy an array like so:
+
+```js
+let thisArray = [true, true, undefined, false, null];
+let thatArray = [...thisArray];
+```
+
+`thatArray` equals `[true, true, undefined, false, null]`. `thisArray` remains unchanged and `thatArray` contains the same elements as `thisArray`.
+
+# --instructions--
+
+We have defined a function, `copyMachine` which takes `arr` (an array) and `num` (a number) as arguments. The function is supposed to return a new array made up of `num` copies of `arr`. We have done most of the work for you, but it doesn't work quite right yet. Modify the function using spread syntax so that it works correctly (hint: another method we have already covered might come in handy here!).
+
+# --hints--
+
+`copyMachine([true, false, true], 2)` should return `[[true, false, true], [true, false, true]]`
+
+```js
+assert.deepEqual(copyMachine([true, false, true], 2), [
+  [true, false, true],
+  [true, false, true]
+]);
+```
+
+`copyMachine([1, 2, 3], 5)` should return `[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]`
+
+```js
+assert.deepEqual(copyMachine([1, 2, 3], 5), [
+  [1, 2, 3],
+  [1, 2, 3],
+  [1, 2, 3],
+  [1, 2, 3],
+  [1, 2, 3]
+]);
+```
+
+`copyMachine([true, true, null], 1)` should return `[[true, true, null]]`
+
+```js
+assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]]);
+```
+
+`copyMachine(["it works"], 3)` should return `[["it works"], ["it works"], ["it works"]]`
+
+```js
+assert.deepEqual(copyMachine(['it works'], 3), [
+  ['it works'],
+  ['it works'],
+  ['it works']
+]);
+```
+
+The `copyMachine` function should utilize the `spread operator` with array `arr`
+
+```js
+assert(code.match(/\.\.\.arr/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function copyMachine(arr, num) {
+  let newArr = [];
+  while (num >= 1) {
+    // Only change code below this line
+
+    // Only change code above this line
+    num--;
+  }
+  return newArr;
+}
+
+console.log(copyMachine([true, false, true], 2));
+```
+
+# --solutions--
+
+```js
+function copyMachine(arr,num){
+    let newArr=[];
+    while(num >=1){
+    newArr.push([...arr]);
+    num--;
+    }
+    return newArr;
+}
+console.log(copyMachine([true, false, true], 2));
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md

@@ -0,0 +1,65 @@
+---
+id: 587d7b7a367417b2b2512b12
+title: Copy Array Items Using slice()
+challengeType: 1
+forumTopicId: 301158
+dashedName: copy-array-items-using-slice
+---
+
+# --description--
+
+The next method we will cover is `slice()`. Rather than modifying an array, `slice()` copies or *extracts* a given number of elements to a new array, leaving the array it is called upon untouched. `slice()` takes only 2 parameters — the first is the index at which to begin extraction, and the second is the index at which to stop extraction (extraction will occur up to, but not including the element at this index). Consider this:
+
+```js
+let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];
+
+let todaysWeather = weatherConditions.slice(1, 3);
+```
+
+`todaysWeather` would have the value `['snow', 'sleet']`, while `weatherConditions` would still have `['rain', 'snow', 'sleet', 'hail', 'clear']`.
+
+In effect, we have created a new array by extracting elements from an existing array.
+
+# --instructions--
+
+We have defined a function, `forecast`, that takes an array as an argument. Modify the function using `slice()` to extract information from the argument array and return a new array that contains the string elements `warm` and `sunny`.
+
+# --hints--
+
+`forecast` should return `["warm", "sunny"]`
+
+```js
+assert.deepEqual(
+  forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']),
+  ['warm', 'sunny']
+);
+```
+
+The `forecast` function should utilize the `slice()` method
+
+```js
+assert(/\.slice\(/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function forecast(arr) {
+  // Only change code below this line
+
+  return arr;
+}
+
+// Only change code above this line
+console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));
+```
+
+# --solutions--
+
+```js
+function forecast(arr) {
+  return arr.slice(2,4);
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md

@@ -0,0 +1,218 @@
+---
+id: 587d7b7b367417b2b2512b16
+title: Create complex multi-dimensional arrays
+challengeType: 1
+forumTopicId: 301159
+dashedName: create-complex-multi-dimensional-arrays
+---
+
+# --description--
+
+Awesome! You have just learned a ton about arrays! This has been a fairly high level overview, and there is plenty more to learn about working with arrays, much of which you will see in later sections. But before moving on to looking at <dfn>Objects</dfn>, lets take one more look, and see how arrays can become a bit more complex than what we have seen in previous challenges.
+
+One of the most powerful features when thinking of arrays as data structures, is that arrays can contain, or even be completely made up of other arrays. We have seen arrays that contain arrays in previous challenges, but fairly simple ones. However, arrays can contain an infinite depth of arrays that can contain other arrays, each with their own arbitrary levels of depth, and so on. In this way, an array can very quickly become very complex data structure, known as a <dfn>multi-dimensional</dfn>, or nested array. Consider the following example:
+
+```js
+let nestedArray = [
+  ['deep'],
+  [
+    ['deeper'], ['deeper'] 
+  ],
+  [
+    [
+      ['deepest'], ['deepest']
+    ],
+    [
+      [
+        ['deepest-est?']
+      ]
+    ]
+  ]
+];
+```
+
+The `deep` array is nested 2 levels deep. The `deeper` arrays are 3 levels deep. The `deepest` arrays are 4 levels, and the `deepest-est?` is 5.
+
+While this example may seem convoluted, this level of complexity is not unheard of, or even unusual, when dealing with large amounts of data. However, we can still very easily access the deepest levels of an array this complex with bracket notation:
+
+```js
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+This logs the string `deepest-est?`. And now that we know where that piece of data is, we can reset it if we need to:
+
+```js
+nestedArray[2][1][0][0][0] = 'deeper still';
+
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+Now it logs `deeper still`.
+
+# --instructions--
+
+We have defined a variable, `myNestedArray`, set equal to an array. Modify `myNestedArray`, using any combination of <dfn>strings</dfn>, <dfn>numbers</dfn>, and <dfn>booleans</dfn> for data elements, so that it has exactly five levels of depth (remember, the outer-most array is level 1). Somewhere on the third level, include the string `deep`, on the fourth level, include the string `deeper`, and on the fifth level, include the string `deepest`.
+
+# --hints--
+
+`myNestedArray` should contain only numbers, booleans, and strings as data elements
+
+```js
+assert.strictEqual(
+  (function (arr) {
+    let flattened = (function flatten(arr) {
+      const flat = [].concat(...arr);
+      return flat.some(Array.isArray) ? flatten(flat) : flat;
+    })(arr);
+    for (let i = 0; i < flattened.length; i++) {
+      if (
+        typeof flattened[i] !== 'number' &&
+        typeof flattened[i] !== 'string' &&
+        typeof flattened[i] !== 'boolean'
+      ) {
+        return false;
+      }
+    }
+    return true;
+  })(myNestedArray),
+  true
+);
+```
+
+`myNestedArray` should have exactly 5 levels of depth
+
+```js
+assert.strictEqual(
+  (function (arr) {
+    let depth = 0;
+    function arrayDepth(array, i, d) {
+      if (Array.isArray(array[i])) {
+        arrayDepth(array[i], 0, d + 1);
+      } else {
+        depth = d > depth ? d : depth;
+      }
+      if (i < array.length) {
+        arrayDepth(array, i + 1, d);
+      }
+    }
+    arrayDepth(arr, 0, 0);
+    return depth;
+  })(myNestedArray),
+  4
+);
+```
+
+`myNestedArray` should contain exactly one occurrence of the string `deep` on an array nested 3 levels deep
+
+```js
+assert(
+  (function howDeep(array, target, depth = 0) {
+    return array.reduce((combined, current) => {
+      if (Array.isArray(current)) {
+        return combined.concat(howDeep(current, target, depth + 1));
+      } else if (current === target) {
+        return combined.concat(depth);
+      } else {
+        return combined;
+      }
+    }, []);
+  })(myNestedArray, 'deep').length === 1 &&
+    (function howDeep(array, target, depth = 0) {
+      return array.reduce((combined, current) => {
+        if (Array.isArray(current)) {
+          return combined.concat(howDeep(current, target, depth + 1));
+        } else if (current === target) {
+          return combined.concat(depth);
+        } else {
+          return combined;
+        }
+      }, []);
+    })(myNestedArray, 'deep')[0] === 2
+);
+```
+
+`myNestedArray` should contain exactly one occurrence of the string `deeper` on an array nested 4 levels deep
+
+```js
+assert(
+  (function howDeep(array, target, depth = 0) {
+    return array.reduce((combined, current) => {
+      if (Array.isArray(current)) {
+        return combined.concat(howDeep(current, target, depth + 1));
+      } else if (current === target) {
+        return combined.concat(depth);
+      } else {
+        return combined;
+      }
+    }, []);
+  })(myNestedArray, 'deeper').length === 1 &&
+    (function howDeep(array, target, depth = 0) {
+      return array.reduce((combined, current) => {
+        if (Array.isArray(current)) {
+          return combined.concat(howDeep(current, target, depth + 1));
+        } else if (current === target) {
+          return combined.concat(depth);
+        } else {
+          return combined;
+        }
+      }, []);
+    })(myNestedArray, 'deeper')[0] === 3
+);
+```
+
+`myNestedArray` should contain exactly one occurrence of the string `deepest` on an array nested 5 levels deep
+
+```js
+assert(
+  (function howDeep(array, target, depth = 0) {
+    return array.reduce((combined, current) => {
+      if (Array.isArray(current)) {
+        return combined.concat(howDeep(current, target, depth + 1));
+      } else if (current === target) {
+        return combined.concat(depth);
+      } else {
+        return combined;
+      }
+    }, []);
+  })(myNestedArray, 'deepest').length === 1 &&
+    (function howDeep(array, target, depth = 0) {
+      return array.reduce((combined, current) => {
+        if (Array.isArray(current)) {
+          return combined.concat(howDeep(current, target, depth + 1));
+        } else if (current === target) {
+          return combined.concat(depth);
+        } else {
+          return combined;
+        }
+      }, []);
+    })(myNestedArray, 'deepest')[0] === 4
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myNestedArray = [
+  // Only change code below this line
+  ['unshift', false, 1, 2, 3, 'complex', 'nested'],
+  ['loop', 'shift', 6, 7, 1000, 'method'],
+  ['concat', false, true, 'spread', 'array'],
+  ['mutate', 1327.98, 'splice', 'slice', 'push'],
+  ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+  // Only change code above this line
+];
+```
+
+# --solutions--
+
+```js
+let myNestedArray = [
+  ['unshift', ['deep', ['deeper', ['deepest']]],false, 1, 2, 3, 'complex', 'nested'],
+  ['loop', 'shift', 6, 7, 1000, 'method'],
+  ['concat', false, true, 'spread', 'array'],
+  ['mutate', 1327.98, 'splice', 'slice', 'push'],
+  ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+];
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md

@@ -0,0 +1,111 @@
+---
+id: 587d7b7d367417b2b2512b1e
+title: Generate an Array of All Object Keys with Object.keys()
+challengeType: 1
+forumTopicId: 301160
+dashedName: generate-an-array-of-all-object-keys-with-object-keys
+---
+
+# --description--
+
+We can also generate an array which contains all the keys stored in an object using the `Object.keys()` method and passing in an object as the argument. This will return an array with strings representing each property in the object. Again, there will be no specific order to the entries in the array.
+
+# --instructions--
+
+Finish writing the `getArrayOfUsers` function so that it returns an array containing all the properties in the object it receives as an argument.
+
+# --hints--
+
+The `users` object should only contain the keys `Alan`, `Jeff`, `Sarah`, and `Ryan`
+
+```js
+assert(
+  'Alan' in users &&
+    'Jeff' in users &&
+    'Sarah' in users &&
+    'Ryan' in users &&
+    Object.keys(users).length === 4
+);
+```
+
+The `getArrayOfUsers` function should return an array which contains all the keys in the `users` object
+
+```js
+assert(
+  (function () {
+    users.Sam = {};
+    users.Lewis = {};
+    let R = getArrayOfUsers(users);
+    return (
+      R.indexOf('Alan') !== -1 &&
+      R.indexOf('Jeff') !== -1 &&
+      R.indexOf('Sarah') !== -1 &&
+      R.indexOf('Ryan') !== -1 &&
+      R.indexOf('Sam') !== -1 &&
+      R.indexOf('Lewis') !== -1
+    );
+  })() === true
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: false
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: false
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function getArrayOfUsers(obj) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(getArrayOfUsers(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+  Alan: {
+    age: 27,
+    online: false
+  },
+  Jeff: {
+    age: 32,
+    online: true
+  },
+  Sarah: {
+    age: 48,
+    online: false
+  },
+  Ryan: {
+    age: 19,
+    online: true
+  }
+};
+
+function getArrayOfUsers(obj) {
+  return Object.keys(obj);
+}
+
+console.log(getArrayOfUsers(users));
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md

@@ -0,0 +1,138 @@
+---
+id: 587d7b7b367417b2b2512b15
+title: Iterate Through All an Array's Items Using For Loops
+challengeType: 1
+forumTopicId: 301161
+dashedName: iterate-through-all-an-arrays-items-using-for-loops
+---
+
+# --description--
+
+Sometimes when working with arrays, it is very handy to be able to iterate through each item to find one or more elements that we might need, or to manipulate an array based on which data items meet a certain set of criteria. JavaScript offers several built in methods that each iterate over arrays in slightly different ways to achieve different results (such as `every()`, `forEach()`, `map()`, etc.), however the technique which is most flexible and offers us the greatest amount of control is a simple `for` loop.
+
+Consider the following:
+
+```js
+function greaterThanTen(arr) {
+  let newArr = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] > 10) {
+      newArr.push(arr[i]);
+    }
+  }
+  return newArr;
+}
+
+greaterThanTen([2, 12, 8, 14, 80, 0, 1]);
+```
+
+Using a `for` loop, this function iterates through and accesses each element of the array, and subjects it to a simple test that we have created. In this way, we have easily and programmatically determined which data items are greater than `10`, and returned a new array, `[12, 14, 80]`, containing those items.
+
+# --instructions--
+
+We have defined a function, `filteredArray`, which takes `arr`, a nested array, and `elem` as arguments, and returns a new array. `elem` represents an element that may or may not be present on one or more of the arrays nested within `arr`. Modify the function, using a `for` loop, to return a filtered version of the passed array such that any array nested within `arr` containing `elem` has been removed.
+
+# --hints--
+
+`filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)` should return `[[10, 8, 3], [14, 6, 23]]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      [10, 8, 3],
+      [14, 6, 23],
+      [3, 18, 6]
+    ],
+    18
+  ),
+  [
+    [10, 8, 3],
+    [14, 6, 23]
+  ]
+);
+```
+
+`filteredArray([["trumpets", 2], ["flutes", 4], ["saxophones", 2]], 2)` should return `[["flutes", 4]]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      ['trumpets', 2],
+      ['flutes', 4],
+      ['saxophones', 2]
+    ],
+    2
+  ),
+  [['flutes', 4]]
+);
+```
+
+`filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter")` should return `[["amy", "beth", "sam"]]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      ['amy', 'beth', 'sam'],
+      ['dave', 'sean', 'peter']
+    ],
+    'peter'
+  ),
+  [['amy', 'beth', 'sam']]
+);
+```
+
+`filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)` should return `[]`
+
+```js
+assert.deepEqual(
+  filteredArray(
+    [
+      [3, 2, 3],
+      [1, 6, 3],
+      [3, 13, 26],
+      [19, 3, 9]
+    ],
+    3
+  ),
+  []
+);
+```
+
+The `filteredArray` function should utilize a `for` loop
+
+```js
+assert.notStrictEqual(filteredArray.toString().search(/for/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function filteredArray(arr, elem) {
+  let newArr = [];
+  // Only change code below this line
+
+  // Only change code above this line
+  return newArr;
+}
+
+console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
+```
+
+# --solutions--
+
+```js
+function filteredArray(arr, elem) {
+  let newArr = [];
+  for (let i = 0; i<arr.length; i++) {
+    if (arr[i].indexOf(elem) < 0) {
+      newArr.push(arr[i]);
+    }
+  }
+  return newArr;
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md

@@ -0,0 +1,138 @@
+---
+id: 587d7b7d367417b2b2512b1d
+title: Iterate Through the Keys of an Object with a for...in Statement
+challengeType: 1
+forumTopicId: 301162
+dashedName: iterate-through-the-keys-of-an-object-with-a-for---in-statement
+---
+
+# --description--
+
+Sometimes you may need to iterate through all the keys within an object. This requires a specific syntax in JavaScript called a <dfn>for...in</dfn> statement. For our `users` object, this could look like:
+
+```js
+for (let user in users) {
+  console.log(user);
+}
+```
+
+This would log `Alan`, `Jeff`, `Sarah`, and `Ryan` - each value on its own line.
+
+In this statement, we defined a variable `user`, and as you can see, this variable was reset during each iteration to each of the object's keys as the statement looped through the object, resulting in each user's name being printed to the console.
+
+**NOTE:** Objects do not maintain an ordering to stored keys like arrays do; thus a key's position on an object, or the relative order in which it appears, is irrelevant when referencing or accessing that key.
+
+# --instructions--
+
+We've defined a function `countOnline` which accepts one argument (a users object). Use a <dfn>for...in</dfn> statement within this function to loop through the users object passed into the function and return the number of users whose `online` property is set to `true`. An example of a users object which could be passed to `countOnline` is shown below. Each user will have an `online` property with either a `true` or `false` value.
+
+```js
+{
+  Alan: {
+    online: false
+  },
+  Jeff: {
+    online: true
+  },
+  Sarah: {
+    online: false
+  }
+}
+```
+
+# --hints--
+
+The function `countOnline` should use a `for in` statement to iterate through the object keys of the object passed to it.
+
+```js
+assert(
+  code.match(
+    /for\s*\(\s*(var|let|const)\s+[a-zA-Z_$]\w*\s+in\s+[a-zA-Z_$]\w*\s*\)/
+  )
+);
+```
+
+The function `countOnline` should return `1` when the object `{ Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } }` is passed to it
+
+```js
+assert(countOnline(usersObj1) === 1);
+```
+
+The function `countOnline` should return `2` when the object `{ Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } }` is passed to it
+
+```js
+assert(countOnline(usersObj2) === 2);
+```
+
+The function `countOnline` should return `0` when the object `{ Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } }` is passed to it
+
+```js
+assert(countOnline(usersObj3) === 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const usersObj1 = {
+  Alan: {
+    online: false
+  },
+  Jeff: {
+    online: true
+  },
+  Sarah: {
+    online: false
+  }
+}
+
+const usersObj2 = {
+  Alan: {
+    online: true
+  },
+  Jeff: {
+    online: false
+  },
+  Sarah: {
+    online: true
+  }
+}
+
+
+const usersObj3 = {
+  Alan: {
+    online: false
+  },
+  Jeff: {
+    online: false
+  },
+  Sarah: {
+    online: false
+  }
+}
+```
+
+## --seed-contents--
+
+```js
+function countOnline(usersObj) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function countOnline(usersObj) {
+  let online = 0;
+  for(let user in usersObj){
+    if(usersObj[user].online) {
+      online++;
+    }
+  }
+  return online;
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md

@@ -0,0 +1,112 @@
+---
+id: 587d7b7d367417b2b2512b1f
+title: Modify an Array Stored in an Object
+challengeType: 1
+forumTopicId: 301163
+dashedName: modify-an-array-stored-in-an-object
+---
+
+# --description--
+
+Now you've seen all the basic operations for JavaScript objects. You can add, modify, and remove key-value pairs, check if keys exist, and iterate over all the keys in an object. As you continue learning JavaScript you will see even more versatile applications of objects. Additionally, the Data Structures lessons located in the Coding Interview Prep section of the curriculum also cover the ES6 <dfn>Map</dfn> and <dfn>Set</dfn> objects, both of which are similar to ordinary objects but provide some additional features. Now that you've learned the basics of arrays and objects, you're fully prepared to begin tackling more complex problems using JavaScript!
+
+# --instructions--
+
+Take a look at the object we've provided in the code editor. The `user` object contains three keys. The `data` key contains five keys, one of which contains an array of `friends`. From this, you can see how flexible objects are as data structures. We've started writing a function `addFriend`. Finish writing it so that it takes a `user` object and adds the name of the `friend` argument to the array stored in `user.data.friends` and returns that array.
+
+# --hints--
+
+The `user` object should have `name`, `age`, and `data` keys.
+
+```js
+assert('name' in user && 'age' in user && 'data' in user);
+```
+
+The `addFriend` function should accept a `user` object and a `friend` string as arguments and add the friend to the array of `friends` in the `user` object.
+
+```js
+assert(
+  (function () {
+    let L1 = user.data.friends.length;
+    addFriend(user, 'Sean');
+    let L2 = user.data.friends.length;
+    return L2 === L1 + 1;
+  })()
+);
+```
+
+`addFriend(user, "Pete")` should return `["Sam", "Kira", "Tomo", "Pete"]`.
+
+```js
+assert.deepEqual(
+  (function () {
+    delete user.data.friends;
+    user.data.friends = ['Sam', 'Kira', 'Tomo'];
+    return addFriend(user, 'Pete');
+  })(),
+  ['Sam', 'Kira', 'Tomo', 'Pete']
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let user = {
+  name: 'Kenneth',
+  age: 28,
+  data: {
+    username: 'kennethCodesAllDay',
+    joinDate: 'March 26, 2016',
+    organization: 'freeCodeCamp',
+    friends: [
+      'Sam',
+      'Kira',
+      'Tomo'
+    ],
+    location: {
+      city: 'San Francisco',
+      state: 'CA',
+      country: 'USA'
+    }
+  }
+};
+
+function addFriend(userObj, friend) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+console.log(addFriend(user, 'Pete'));
+```
+
+# --solutions--
+
+```js
+let user = {
+  name: 'Kenneth',
+  age: 28,
+  data: {
+    username: 'kennethCodesAllDay',
+    joinDate: 'March 26, 2016',
+    organization: 'freeCodeCamp',
+    friends: [
+      'Sam',
+      'Kira',
+      'Tomo'
+    ],
+    location: {
+      city: 'San Francisco',
+      state: 'CA',
+      country: 'USA'
+    }
+  }
+};
+
+function addFriend(userObj, friend) {
+  userObj.data.friends.push(friend);
+  return userObj.data.friends;
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md

@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b19
+title: Modify an Object Nested Within an Object
+challengeType: 1
+forumTopicId: 301164
+dashedName: modify-an-object-nested-within-an-object
+---
+
+# --description--
+
+Now let's take a look at a slightly more complex object. Object properties can be nested to an arbitrary depth, and their values can be any type of data supported by JavaScript, including arrays and even other objects. Consider the following:
+
+```js
+let nestedObject = {
+  id: 28802695164,
+  date: 'December 31, 2016',
+  data: {
+    totalUsers: 99,
+    online: 80,
+    onlineStatus: {
+      active: 67,
+      away: 13,
+      busy: 8
+    }
+  }
+};
+```
+
+`nestedObject` has three properties: `id` (value is a number), `date` (value is a string), and `data` (value is an object with its nested structure). While structures can quickly become complex, we can still use the same notations to access the information we need. To assign the value `10` to the `busy` property of the nested `onlineStatus` object, we use dot notation to reference the property:
+
+```js
+nestedObject.data.onlineStatus.busy = 10;
+```
+
+# --instructions--
+
+Here we've defined an object `userActivity`, which includes another object nested within it. Set the value of the `online` key to `45`.
+
+# --hints--
+
+`userActivity` should have `id`, `date` and `data` properties.
+
+```js
+assert(
+  'id' in userActivity && 'date' in userActivity && 'data' in userActivity
+);
+```
+
+`userActivity` should have a `data` key set to an object with keys `totalUsers` and `online`.
+
+```js
+assert('totalUsers' in userActivity.data && 'online' in userActivity.data);
+```
+
+The `online` property nested in the `data` key of `userActivity` should be set to `45`
+
+```js
+assert(userActivity.data.online === 45);
+```
+
+The `online` property should be set using dot or bracket notation.
+
+```js
+assert.strictEqual(code.search(/online: 45/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let userActivity = {
+  id: 23894201352,
+  date: 'January 1, 2017',
+  data: {
+    totalUsers: 51,
+    online: 42
+  }
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(userActivity);
+```
+
+# --solutions--
+
+```js
+let userActivity = {
+  id: 23894201352,
+  date: 'January 1, 2017',
+  data: {
+    totalUsers: 51,
+    online: 42
+  }
+};
+
+userActivity.data.online = 45;
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md

@@ -0,0 +1,86 @@
+---
+id: 587d78b2367417b2b2512b0f
+title: Remove Items from an Array with pop() and shift()
+challengeType: 1
+forumTopicId: 301165
+dashedName: remove-items-from-an-array-with-pop-and-shift
+---
+
+# --description--
+
+Both `push()` and `unshift()` have corresponding methods that are nearly functional opposites: `pop()` and `shift()`. As you may have guessed by now, instead of adding, `pop()` *removes* an element from the end of an array, while `shift()` removes an element from the beginning. The key difference between `pop()` and `shift()` and their cousins `push()` and `unshift()`, is that neither method takes parameters, and each only allows an array to be modified by a single element at a time.
+
+Let's take a look:
+
+```js
+let greetings = ['whats up?', 'hello', 'see ya!'];
+
+greetings.pop();
+```
+
+`greetings` would have the value `['whats up?', 'hello']`.
+
+```js
+greetings.shift();
+```
+
+`greetings` would have the value `['hello']`.
+
+We can also return the value of the removed element with either method like this:
+
+```js
+let popped = greetings.pop();
+```
+
+`greetings` would have the value `[]`, and `popped` would have the value `hello`.
+
+# --instructions--
+
+We have defined a function, `popShift`, which takes an array as an argument and returns a new array. Modify the function, using `pop()` and `shift()`, to remove the first and last elements of the argument array, and assign the removed elements to their corresponding variables, so that the returned array contains their values.
+
+# --hints--
+
+`popShift(["challenge", "is", "not", "complete"])` should return `["challenge", "complete"]`
+
+```js
+assert.deepEqual(popShift(['challenge', 'is', 'not', 'complete']), [
+  'challenge',
+  'complete'
+]);
+```
+
+The `popShift` function should utilize the `pop()` method
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1);
+```
+
+The `popShift` function should utilize the `shift()` method
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.shift\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function popShift(arr) {
+  let popped; // Change this line
+  let shifted; // Change this line
+  return [shifted, popped];
+}
+
+console.log(popShift(['challenge', 'is', 'not', 'complete']));
+```
+
+# --solutions--
+
+```js
+function popShift(arr) {
+  let popped = arr.pop(); // Change this line
+  let shifted = arr.shift(); // Change this line
+  return [shifted, popped];
+}
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md

@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b10
+title: Remove Items Using splice()
+challengeType: 1
+forumTopicId: 301166
+dashedName: remove-items-using-splice
+---
+
+# --description--
+
+Ok, so we've learned how to remove elements from the beginning and end of arrays using `shift()` and `pop()`, but what if we want to remove an element from somewhere in the middle? Or remove more than one element at once? Well, that's where `splice()` comes in. `splice()` allows us to do just that: **remove any number of consecutive elements** from anywhere in an array.
+
+`splice()` can take up to 3 parameters, but for now, we'll focus on just the first 2. The first two parameters of `splice()` are integers which represent indexes, or positions, of the array that `splice()` is being called upon. And remember, arrays are *zero-indexed*, so to indicate the first element of an array, we would use `0`. `splice()`'s first parameter represents the index on the array from which to begin removing elements, while the second parameter indicates the number of elements to delete. For example:
+
+```js
+let array = ['today', 'was', 'not', 'so', 'great'];
+
+array.splice(2, 2);
+```
+
+Here we remove 2 elements, beginning with the third element (at index 2). `array` would have the value `['today', 'was', 'great']`.
+
+`splice()` not only modifies the array it's being called on, but it also returns a new array containing the value of the removed elements:
+
+```js
+let array = ['I', 'am', 'feeling', 'really', 'happy'];
+
+let newArray = array.splice(3, 2);
+```
+
+`newArray` has the value `['really', 'happy']`.
+
+# --instructions--
+
+We've initialized an array `arr`. Use `splice()` to remove elements from `arr`, so that it only contains elements that sum to the value of `10`.
+
+# --hints--
+
+You should not change the original line of `const arr = [2, 4, 5, 1, 7, 5, 2, 1];`.
+
+```js
+assert(
+  __helpers.removeWhiteSpace(code).match(/constarr=\[2,4,5,1,7,5,2,1\];?/)
+);
+```
+
+`arr` should only contain elements that sum to `10`.
+
+```js
+assert.strictEqual(
+  arr.reduce((a, b) => a + b),
+  10
+);
+```
+
+Your code should utilize the `splice()` method on `arr`.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/arr\.splice\(/));
+```
+
+The splice should only remove elements from `arr` and not add any additional elements to `arr`.
+
+```js
+assert(
+  !__helpers.removeWhiteSpace(code).match(/arr\.splice\(\d+,\d+,\d+.*\)/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+// Only change code below this line
+
+// Only change code above this line
+console.log(arr);
+```
+
+# --solutions--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+arr.splice(1, 4);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md

@@ -0,0 +1,95 @@
+---
+id: 587d7b7e367417b2b2512b20
+title: Use an Array to Store a Collection of Data
+challengeType: 1
+forumTopicId: 301167
+dashedName: use-an-array-to-store-a-collection-of-data
+---
+
+# --description--
+
+The below is an example of the simplest implementation of an array data structure. This is known as a <dfn>one-dimensional array</dfn>, meaning it only has one level, or that it does not have any other arrays nested within it. Notice it contains <dfn>booleans</dfn>, <dfn>strings</dfn>, and <dfn>numbers</dfn>, among other valid JavaScript data types:
+
+```js
+let simpleArray = ['one', 2, 'three', true, false, undefined, null];
+console.log(simpleArray.length);
+```
+
+The `console.log` call displays `7`.
+
+All arrays have a length property, which as shown above, can be very easily accessed with the syntax `Array.length`. A more complex implementation of an array can be seen below. This is known as a <dfn>multi-dimensional array</dfn>, or an array that contains other arrays. Notice that this array also contains JavaScript <dfn>objects</dfn>, which we will examine very closely in our next section, but for now, all you need to know is that arrays are also capable of storing complex objects.
+
+```js
+let complexArray = [
+  [
+    {
+      one: 1,
+      two: 2
+    },
+    {
+      three: 3,
+      four: 4
+    }
+  ],
+  [
+    {
+      a: "a",
+      b: "b"
+    },
+    {
+      c: "c",
+      d: "d"
+    }
+  ]
+];
+```
+
+# --instructions--
+
+We have defined a variable called `yourArray`. Complete the statement by assigning an array of at least 5 elements in length to the `yourArray` variable. Your array should contain at least one <dfn>string</dfn>, one <dfn>number</dfn>, and one <dfn>boolean</dfn>.
+
+# --hints--
+
+`yourArray` should be an array.
+
+```js
+assert.strictEqual(Array.isArray(yourArray), true);
+```
+
+`yourArray` should be at least 5 elements long.
+
+```js
+assert.isAtLeast(yourArray.length, 5);
+```
+
+`yourArray` should contain at least one `boolean`.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'boolean').length >= 1);
+```
+
+`yourArray` should contain at least one `number`.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'number').length >= 1);
+```
+
+`yourArray` should contain at least one `string`.
+
+```js
+assert(yourArray.filter((el) => typeof el === 'string').length >= 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let yourArray; // Change this line
+```
+
+# --solutions--
+
+```js
+let yourArray = ['a string', 100, true, ['one', 2], 'another string'];
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md

@@ -0,0 +1,86 @@
+---
+id: 587d7b7c367417b2b2512b1b
+title: Use the delete Keyword to Remove Object Properties
+challengeType: 1
+forumTopicId: 301168
+dashedName: use-the-delete-keyword-to-remove-object-properties
+---
+
+# --description--
+
+Now you know what objects are and their basic features and advantages. In short, they are key-value stores which provide a flexible, intuitive way to structure data, ***and***, they provide very fast lookup time. Throughout the rest of these challenges, we will describe several common operations you can perform on objects so you can become comfortable applying these useful data structures in your programs.
+
+In earlier challenges, we have both added to and modified an object's key-value pairs. Here we will see how we can *remove* a key-value pair from an object.
+
+Let's revisit our `foods` object example one last time. If we wanted to remove the `apples` key, we can remove it by using the `delete` keyword like this:
+
+```js
+delete foods.apples;
+```
+
+# --instructions--
+
+Use the delete keyword to remove the `oranges`, `plums`, and `strawberries` keys from the `foods` object.
+
+# --hints--
+
+The `foods` object should only have three keys: `apples`, `grapes`, and `bananas`.
+
+```js
+assert(
+  !foods.hasOwnProperty('oranges') &&
+    !foods.hasOwnProperty('plums') &&
+    !foods.hasOwnProperty('strawberries') &&
+    Object.keys(foods).length === 3
+);
+```
+
+The `oranges`, `plums`, and `strawberries` keys should be removed using `delete`.
+
+```js
+assert(
+  code.search(/oranges:/) !== -1 &&
+    code.search(/plums:/) !== -1 &&
+    code.search(/strawberries:/) !== -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+  apples: 25,
+  oranges: 32,
+  plums: 28,
+  bananas: 13,
+  grapes: 35,
+  strawberries: 27
+};
+
+delete foods.oranges;
+delete foods.plums;
+delete foods.strawberries;
+
+console.log(foods);
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-001.md

@@ -0,0 +1,113 @@
+---
+id: 5d5a813321b9e3db6c106a46
+title: Part 1
+challengeType: 0
+dashedName: part-1
+---
+
+# --description--
+
+To keep track of the player's experience points, we've declared a variable called `xp` and assigned it the starting value of 0.
+
+Create another variable to keep track of health and start it at 100.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(health === 100);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+var xp = 0;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+var xp = 0;
+var health = 100;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-002.md

@@ -0,0 +1,113 @@
+---
+id: 5d5a8dd907f328a948d398ce
+title: Part 2
+challengeType: 0
+dashedName: part-2
+---
+
+# --description--
+
+Create a variable called `gold` and set it to the value 50.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(gold === 50);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+var xp = 0;
+var health = 100;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+var xp = 0;
+var health = 100;
+var gold = 50;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-003.md

@@ -0,0 +1,117 @@
+---
+id: 5d5a8f1c07f328a948d398cf
+title: Part 3
+challengeType: 0
+dashedName: part-3
+---
+
+# --description--
+
+Create a variable called `currentWeapon` and set it to 0. When a name has two words, the convention is to use so-called "lowerCamelCase". The first word is all lowercase, and then the first letter of every preceding word is uppercased.
+
+When a name has two words, the convention is to use so-called "lowerCamelCase". The variable name should look like this: currentWeapon.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(currentWeapon === 0);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+var xp = 0;
+var health = 100;
+var gold = 50;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+var xp = 0;
+var health = 100;
+var gold = 50;
+var currentWeapon = 0;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-004.md

@@ -0,0 +1,123 @@
+---
+id: 5d5a903507f328a948d398d0
+title: Part 4
+challengeType: 0
+dashedName: part-4
+---
+
+# --description--
+
+We've been declaring variables with the `var` keyword. However, in modern JavaScript, it's better to use `let` instead of `var` because it fixes a number of unusual behaviors with `var` that make it difficult to reason about.
+
+Change every `var` to `let`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  /let\s+xp\s*\=\s*0\;?/.test(code) &&
+    /let\s+health\s*\=\s*100\;?/.test(code) &&
+    /let\s+gold\s*\=\s*50\;?/.test(code) &&
+    /let\s+currentWeapon\s*\=\s*0\;?/.test(code)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+var xp = 0;
+var health = 100;
+var gold = 50;
+var currentWeapon = 0;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-005.md

@@ -0,0 +1,119 @@
+---
+id: 5d5aaa5807f328a948d398d1
+title: Part 5
+challengeType: 0
+dashedName: part-5
+---
+
+# --description--
+
+Now you will declare a variable without initializing it.
+
+Using the `let` keyword, declare a variable called `fighting` but don't set it equal to anything. Just end the line with a semicolon right after the variable name.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(/let\s+fighting\s*;?/.test(code) && fighting === undefined);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-006.md

@@ -0,0 +1,120 @@
+---
+id: 5d5aab5d07f328a948d398d2
+title: Part 6
+challengeType: 0
+dashedName: part-6
+---
+
+# --description--
+
+Declare variables named `monsterHealth` and `inventory` without initializing them.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(monsterHealth === undefined && inventory === undefined);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-007.md

@@ -0,0 +1,124 @@
+---
+id: 5d5aac9c07f328a948d398d3
+title: Part 7
+challengeType: 0
+dashedName: part-7
+---
+
+# --description--
+
+Now set the inventory to equal the string "stick".
+
+Strings must be surrounded with double quotes `"`, single quotes `'`, or backticks `` ` ``.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(inventory === 'stick');
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = "stick";
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-008.md

@@ -0,0 +1,132 @@
+---
+id: 5d5aad2307f328a948d398d4
+title: Part 8
+challengeType: 0
+dashedName: part-8
+---
+
+# --description--
+
+Since the inventory can store multiple items, change the value of `inventory` to an array with the items stick, dagger, and sword.
+
+Here is an example of a variable sandwich that equals a three-item array:
+
+```js
+let sandwich = ["peanut butter", "jelly", "bread"];
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  inventory.includes('stick') &&
+    inventory.includes('dagger') &&
+    inventory.includes('sword')
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = "stick";
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick", "dagger", "sword"];
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-009.md

@@ -0,0 +1,122 @@
+---
+id: 5d5aae1207f328a948d398d5
+title: Part 9
+challengeType: 0
+dashedName: part-9
+---
+
+# --description--
+
+For now, let's start the player with just the stick. Delete the dagger and sword items in the array. More items will be added to the array during game play.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(inventory[0] === 'stick' && inventory.length === 1);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick", "dagger", "sword"];
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-010.md

@@ -0,0 +1,131 @@
+---
+id: 5d5ab57f07f328a948d398d6
+title: Part 10
+challengeType: 0
+dashedName: part-10
+---
+
+# --description--
+
+In order to update HTML elements on the page, you need to get references to them in your JavaScript code. The code `let el = document.querySelector("#el");` gets a reference to an HTML element with an `id` of `el` and assigns it to the variable `el`.
+
+Get a reference to the HTML element with the `id` of `button1` and assign it to a variable with the name `button1`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  /let\s+button1\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#button1\s*[\'\"\`]\s*\);?/.test(
+    code
+  )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+  
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+let button1 = document.querySelector('#button1');
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-011.md

@@ -0,0 +1,126 @@
+---
+id: 5d5b66ce07f328a948d398d7
+title: Part 11
+challengeType: 0
+dashedName: part-11
+---
+
+# --description--
+
+You can also declare variables with the `const` key word. Since `button1` is a constant that will never change, switch the `let` keyword that declares the variable to `const`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(/const\s+button1\s*/.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+let button1 = document.querySelector('#button1');
+  
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-012.md

@@ -0,0 +1,165 @@
+---
+id: 5d64cf8f853b56a21cd16319
+title: Part 12
+challengeType: 0
+dashedName: part-12
+---
+
+# --description--
+
+Here are the ids of the other HTML elements that we want a reference to in the JavaScript code: `button2`, `button3`, `text`, `xpText`, `healthText`, `goldText`, `monsterStats`, `monsterNameText`, `monsterHealthText`.
+
+Just like you did with `storeButton`, create variables and set them equal to the element references.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  /const\s+button2\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#button2\s*[\'\"\`]\s*\);?/.test(
+    code
+  ) &&
+    /const\s+button3\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#button3\s*[\'\"\`]\s*\);?/.test(
+      code
+    ) &&
+    /const\s+text\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#text\s*[\'\"\`]\s*\);?/.test(
+      code
+    ) &&
+    /const\s+xpText\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#xpText\s*[\'\"\`]\s*\);?/.test(
+      code
+    ) &&
+    /const\s+healthText\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#healthText\s*[\'\"\`]\s*\);?/.test(
+      code
+    ) &&
+    /const\s+goldText\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#goldText\s*[\'\"\`]\s*\);?/.test(
+      code
+    ) &&
+    /const\s+monsterStats\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#monsterStats\s*[\'\"\`]\s*\);?/.test(
+      code
+    ) &&
+    /const\s+monsterNameText|monsterName\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#monsterName\s*[\'\"\`]\s*\);?/.test(
+      code
+    ) &&
+    /const\s+monsterHealthText|monsterHealth\s*\=\s*document.querySelector\(\s*[\'\"\`]\s*\#monsterHealth\s*[\'\"\`]\s*\);?/.test(
+      code
+    )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+  
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-013.md

@@ -0,0 +1,148 @@
+---
+id: 5d651ee1ee291f75bbd738ee
+title: Part 13
+challengeType: 0
+dashedName: part-13
+---
+
+# --description--
+
+Make a comment to describe what the next few lines of code will do. Comments can be written with either two forward-slashes `//` or with a multi-line sequence `/* */`. For example, here is a single line comment that says "hello world": `// hello world`.
+
+Write a single line comment that says "initialize buttons".
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(/\/\/\s*[iI]nitialize buttons/.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+  
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-014.md

@@ -0,0 +1,150 @@
+---
+id: 5d652e5a6e6bf7a6a27aa80a
+title: Part 14
+challengeType: 0
+dashedName: part-14
+---
+
+# --description--
+
+Designate what the first button in the HTML does by setting the `onclick` property of `button1` to the function name `goStore`. You will create the `goStore` function later. For example, in `button.onclick = openProgram;`, the `onclick` property of `button` is set to `openProgram`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(/button1\.onclick\s*\=\s*goStore\;?/.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-015.md

@@ -0,0 +1,155 @@
+---
+id: 5d653b2d6e6bf7a6a27aa80b
+title: Part 15
+challengeType: 0
+dashedName: part-15
+---
+
+# --description--
+
+Now set the `onclick` property of `button2` and `button3`. The second button should be set to `goCave` and the third button should be set to `fightDragon`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  /button2\.onclick\s*\=\s*goCave\;?/.test(code) &&
+    /button3\.onclick\s*\=\s*fightDragon\;?/.test(code)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-016.md

@@ -0,0 +1,162 @@
+---
+id: 5d653c4d6e6bf7a6a27aa80c
+title: Part 16
+challengeType: 0
+dashedName: part-16
+---
+
+# --description--
+
+Create the `goStore` function to hold the code that runs whenever the player goes to the store. Here is an example of an empty function called `functionName` (Note the opening curly brace at the end of the first line and the closing curly brace on the second line):
+
+```js
+function functionName() {
+}
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(typeof goStore === 'function');
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-017.md

@@ -0,0 +1,171 @@
+---
+id: 5d6542826e6bf7a6a27aa80d
+title: Part 17
+challengeType: 0
+dashedName: part-17
+---
+
+# --description--
+
+For now, make the `goStore` function output the message "Going to store." to the web console. For example, here is a function that outputs the message "Hello World" to the web console (Note that code inside a function should be indented):
+
+```js
+function functionName() {
+  console.log("Hello World");
+}
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  goStore
+    .toString()
+    .match(/console\.log\(\s*[\"\'\`]Going to store\.?[\"\'\`]\s*\)/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  console.log("Going to store.");
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-018.md

@@ -0,0 +1,170 @@
+---
+id: 5d65f2c62012114c7d7c57eb
+title: Part 18
+challengeType: 0
+dashedName: part-18
+---
+
+# --description--
+
+Similar to the `goStore` function, create a `goCave` function that prints "Going to cave." to the console.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  goCave
+    .toString()
+    .match(/console\.log\(\s*[\"\'\`]Going to cave\.?[\"\'\`]\s*\)/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  console.log("Going to store.")
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  console.log("Going to store.")
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-019.md

@@ -0,0 +1,180 @@
+---
+id: 5d65f4cd2012114c7d7c57ec
+title: Part 19
+challengeType: 0
+dashedName: part-19
+---
+
+# --description--
+
+Also, create a `fightDragon` function that prints "Fighting dragon." to the console.
+
+When you are finished, you can test out your program in the browser.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  fightDragon
+    .toString()
+    .match(/console\.log\(\s*[\"\'\`]Fighting dragon\.?[\"\'\`]\s*\)/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  console.log("Going to store.")
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  console.log("Going to store.")
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-020.md

@@ -0,0 +1,185 @@
+---
+id: 5d65f6392012114c7d7c57ed
+title: Part 20
+challengeType: 0
+dashedName: part-20
+---
+
+# --description--
+
+When a player clicks the 'Go to store' button, the buttons and text in the game should change. Remove the code inside the `goStore` function. Add a new line of code inside the function that updates the text of `button1` so that it says "Buy 10 health (10 gold)".
+
+For example, this code updates the text of `button` to say "Click Me": `button.innerText = "Click Me";`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  (() => {
+    goStore();
+    return button1.innerText === 'Buy 10 health (10 gold)';
+  })()
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  console.log("Going to store.");
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-021.md

@@ -0,0 +1,189 @@
+---
+id: 5d6606634bab337fbb433884
+title: Part 21
+challengeType: 0
+dashedName: part-21
+---
+
+# --description--
+
+After the line that updates `button1`, update the text of `button2` to say "Buy weapon (30 gold)" and update the text of `button3` to say "Go to town square".
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  (() => {
+    goStore();
+    return (
+      button1.innerText === 'Buy 10 health (10 gold)' &&
+      button2.innerText === 'Buy weapon (30 gold)' &&
+      button3.innerText === 'Go to town square'
+    );
+  })()
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-022.md

@@ -0,0 +1,189 @@
+---
+id: 5d66093c4bab337fbb433885
+title: Part 22
+challengeType: 0
+dashedName: part-22
+---
+
+# --description--
+
+Now that the text on the buttons have changed, the `onclick` properties on the buttons should change. Inside the goStore function, update the `onclick` property of all three buttons. The new functions should be `buyHealth`, `buyWeapon`, and `goTown`. If you have trouble, look at how the buttons were initialized.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  goStore.toString().match(/button1\.onclick\s*\=\s*buyHealth\;?/) &&
+    goStore.toString().match(/button2\.onclick\s*\=\s*buyWeapon\;?/) &&
+    goStore.toString().match(/button3\.onclick\s*\=\s*goTown\;?/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-023.md

@@ -0,0 +1,193 @@
+---
+id: 5d660a32e0696bdec46938d5
+title: Part 23
+challengeType: 0
+dashedName: part-23
+---
+
+# --description--
+
+Right after the `onclick` properties are updated, change the `innerText` property of `text` to "You enter the store."
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  goStore
+    .toString()
+    .match(/text\.innerText\s*\=\s*[\'\"\`]You enter the store\.?[\'\"\`]/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-024.md

@@ -0,0 +1,203 @@
+---
+id: 5d6616d8e0696bdec46938d6
+title: Part 24
+challengeType: 0
+dashedName: part-24
+---
+
+# --description--
+
+At the end of the current code, add three new empty functions called `buyHealth`, `buyWeapon`, and `goTown`. After this step, you can test out the game by clicking the "Go to store" button.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  typeof buyHealth === 'function' &&
+    typeof buyWeapon === 'function' &&
+    typeof goTown === 'function'
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+function goTown() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-025.md

@@ -0,0 +1,228 @@
+---
+id: 5d661814e0696bdec46938d7
+title: Part 25
+challengeType: 0
+dashedName: part-25
+---
+
+# --description--
+
+Move the `goTown` function to above the `goStore` function. Then, copy and paste the contents of the `goStore` function into the `goTown` function.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  (() => {
+    goTown();
+    return (
+      button1.innerText === 'Buy 10 health (10 gold)' &&
+      button2.innerText === 'Buy weapon (30 gold)' &&
+      button3.innerText === 'Go to town square' &&
+      text.innerText === 'You enter the store.' &&
+      goTown.toString().match(/button1\.onclick\s*\=\s*buyHealth\;?/) &&
+      goTown.toString().match(/button2\.onclick\s*\=\s*buyWeapon\;?/) &&
+      goTown.toString().match(/button3\.onclick\s*\=\s*goTown\;?/)
+    );
+  })()
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+function goTown() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goTown() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-026.md

@@ -0,0 +1,230 @@
+---
+id: 5d66198de0696bdec46938d8
+title: Part 26
+challengeType: 0
+dashedName: part-26
+---
+
+# --description--
+
+Add double quote marks around the word "Store" in the line "You see a sign that says Store." Before each quotation mark add a `\` to signal that the following quote is not the end of the string, but should instead appear inside the string. This is called escaping.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  (() => {
+    goTown();
+    return (
+      text.innerText ===
+      'You are in the town square. You see a sign that says "Store".'
+    );
+  })()
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says Store.";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-027.md

@@ -0,0 +1,235 @@
+---
+id: 5d661bc6e0696bdec46938d9
+title: Part 27
+challengeType: 0
+dashedName: part-27
+---
+
+# --description--
+
+There is repetition in the `goTown` and `goStore` functions. When you have repetition in code, it is a sign that you need a new function.
+
+Above the `goTown` function, create an empty function called `update`. This time the function should take a parameter named `location` so data can be passed into the function when it is called.
+
+Here is an example of a function named `testFun` that accepts a parameter named `param`:
+
+```js
+function testFun(param) {
+  console.log(param);
+}
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(update.toString().match(/function update\(\s*location\)\s*\{\s*\}/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-028.md

@@ -0,0 +1,230 @@
+---
+id: 5d6653d5e0696bdec46938da
+title: Part 28
+challengeType: 0
+dashedName: part-28
+---
+
+# --description--
+
+Below the list of `const` variables, create a new `const` variable called `locations`. Set it to equal an empty array. This will be used to store all the data for the locations in the game.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(Array.isArray(locations) && locations.length === 0);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-029.md

@@ -0,0 +1,236 @@
+---
+id: 5d665983e0696bdec46938dc
+title: Part 29
+challengeType: 0
+dashedName: part-29
+---
+
+# --description--
+
+Arrays can store any data type, including objects. Objects are similar to arrays, except that instead of using indexes to access and modify their data, you access the data in objects through what are called properties.
+
+Inside the `locations` array add an empty object using curly braces.
+
+Here is an example of an array named `arr` with an empty object inside: `const arr = [{}];`
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(JSON.stringify(locations), `[{}]`);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [{}];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-030.md

@@ -0,0 +1,246 @@
+---
+id: 5d674fd9e0696bdec46938dd
+title: Part 30
+challengeType: 0
+dashedName: part-30
+---
+
+# --description--
+
+Inside the object you just added, create a property called `name` with the value of "town square".
+
+For example, here is an example of an array with an object inside that has a property called `name` with a value of "Quincy Larson" (new lines are used only for the purpose of making the code more readable):
+
+```js
+const arr = [
+  {
+    name: "Quincy Larson"
+  }
+]
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(locations[0].name === 'town square');
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [{}];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square"
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-031.md

@@ -0,0 +1,252 @@
+---
+id: 5d6752e3e0696bdec46938de
+title: Part 31
+challengeType: 0
+dashedName: part-31
+---
+
+# --description--
+
+After the `name` property put a comma. On the next line add a property named `"button text"` that has a value of an empty array. Since the property name has more than one word, there must be quotes around it.
+
+Here is an example:
+
+```js
+const arr = [
+  {
+    name: "Quincy Larson",
+    "favorite colors": []
+  }
+]
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(locations[0]['button text'], []);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square"
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": []
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-032.md

@@ -0,0 +1,248 @@
+---
+id: 5d6755fce0696bdec46938df
+title: Part 32
+challengeType: 0
+dashedName: part-32
+---
+
+# --description--
+
+Inside the `"button text"` array, add three string elements. Use the three stings assigned to the buttons inside the `goTown` function.
+
+Here is an example array with three strings: `const arr = ["one", "two", "three"];`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(locations[0]['button text'], [
+  'Go to store',
+  'Go to cave',
+  'Fight dragon'
+]);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": []
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"]
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-033.md

@@ -0,0 +1,247 @@
+---
+id: 5d675726e0696bdec46938e0
+title: Part 33
+challengeType: 0
+dashedName: part-33
+---
+
+# --description--
+
+Add another property in the object with the name `"button functions"`. The value should be an array containing the three `onclick` functions from the `goTown` function. It should look like this: `[goStore, goCave, fightDragon]`
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(locations[0]['button functions'], [
+  goStore,
+  goCave,
+  fightDragon
+]);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"]
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon]
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-034.md

@@ -0,0 +1,248 @@
+---
+id: 5d678366e0696bdec46938e1
+title: Part 34
+challengeType: 0
+dashedName: part-34
+---
+
+# --description--
+
+Add one final property to the object named `text`. The value should be the final text from the `goTown` function.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  locations[0].text ===
+    'You are in the town square. You see a sign that says "Store."'
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon]
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-035.md

@@ -0,0 +1,261 @@
+---
+id: 5d67845ee0696bdec46938e2
+title: Part 35
+challengeType: 0
+dashedName: part-35
+---
+
+# --description--
+
+The `locations` array currently has one element which is an object. Within the array, and after the object's final curly brace, add a comma. On the next line within the array, add another object with all the same properties as the first object. Keep the property names the same on the second object, but change all the property values to the information from the `goStore` function. Also, set the `name` property to `store`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(locations[1], {
+  name: 'store',
+  'button text': [
+    'Buy 10 health (10 gold)',
+    'Buy weapon (30 gold)',
+    'Go to town square'
+  ],
+  'button functions': [buyHealth, buyWeapon, goTown],
+  text: 'You enter the store.'
+});
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-036.md

@@ -0,0 +1,267 @@
+---
+id: 5d67880ee0696bdec46938e3
+title: Part 36
+challengeType: 0
+dashedName: part-36
+---
+
+# --description--
+
+Now we are can consolidate the code inside the `goTown` and `goStore` functions. Copy the code inside the `goTown` function and paste it in the `update` function. Then delete all the code inside the `goTown` and `goStore` functions.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  (() => {
+    update();
+    return (
+      goTown.toString() === 'function goTown() {}' &&
+      goStore.toString() === 'function goStore() {}' &&
+      button1.innerText === 'Go to store' &&
+      button2.innerText === 'Go to cave' &&
+      button3.innerText === 'Fight dragon' &&
+      text.innerText ===
+        'You are in the town square. You see a sign that says "Store".' &&
+      update.toString().match(/button1\.onclick\s*\=\s*goStore\;?/) &&
+      update.toString().match(/button2\.onclick\s*\=\s*goCave\;?/) &&
+      update.toString().match(/button3\.onclick\s*\=\s*fightDragon\;?/)
+    );
+  })()
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+}
+
+function goTown() {
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goStore() {
+  button1.innerText = "Buy 10 health (10 gold)";
+  button2.innerText = "Buy weapon (30 gold)";
+  button3.innerText = "Go to town square";
+  button1.onclick = buyHealth;
+  button2.onclick = buyWeapon;
+  button3.onclick = goTown;
+  text.innerText = "You enter the store.";
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-037.md

@@ -0,0 +1,247 @@
+---
+id: 5d67ad3de0696bdec46938e4
+title: Part 37
+challengeType: 0
+dashedName: part-37
+---
+
+# --description--
+
+Instead of assigning the `innerText` and `onClick` properties to specific strings and functions like it does now, the `update` function will use data from the `location` that is passed into it. First, data needs to be passed into the `update` function. Inside the `goTown` function, call the `update` function.
+
+Here is how you would call a function named `exampleFunction`: `exampleFunction();`
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(goTown.toString().match(/update\(\)/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update();
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-038.md

@@ -0,0 +1,248 @@
+---
+id: 5d67ae95e0696bdec46938e5
+title: Part 38
+challengeType: 0
+dashedName: part-38
+---
+
+# --description--
+
+Now change the code you just wrote to call the `update` function so the `locations` array is passed in as an argument.
+
+Here is how you would call a function named `exampleFunction` with an argument called `arg`: `exampleFunction(arg);`
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(goTown.toString().match(/update\(locations\)/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update();
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-039.md

@@ -0,0 +1,246 @@
+---
+id: 5d67b284e0696bdec46938e6
+title: Part 39
+challengeType: 0
+dashedName: part-39
+---
+
+# --description--
+
+The `locations` array contains two locations: the town square and store. Currently the entire array with both locations is being passed in to the update function. Pass in only the first element of the locations array by adding `[0]` at the end of the name of the array. For example, `exampleFunction(arg[0]);`
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(goTown.toString().match(/update\(locations\[0\]\)/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-040.md

@@ -0,0 +1,252 @@
+---
+id: 5d67b945e0696bdec46938e7
+title: Part 40
+challengeType: 0
+dashedName: part-40
+---
+
+# --description--
+
+Now that the `goTown` function calls the `update` function with the first element of the `locations` array, it is time to use that location information to update the `innerText` and `onclick` properties.
+
+Inside the `update` function, change `button1.innerText` to equal `location["button text"]`. That line gets the `"button text"` property of the `location` that was passed into the `update` function\`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  update
+    .toString()
+    .match(/button1\.innerText\s*\=\s*location\[[\'\"\`]button text[\'\"\`]\]/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = "Go to store";
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"];
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-041.md

@@ -0,0 +1,252 @@
+---
+id: 5d68c3b1e0696bdec46938e8
+title: Part 41
+challengeType: 0
+dashedName: part-41
+---
+
+# --description--
+
+`location["button text"]` is an array with three elements. Use only the first element of the array by adding `[0]` at the end.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  update
+    .toString()
+    .match(
+      /button1\.innerText\s*\=\s*location\[[\'\"\`]button text[\'\"\`]\]\[0\]/
+    )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"];
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-042.md

@@ -0,0 +1,257 @@
+---
+id: 5d68c51ee0696bdec46938e9
+title: Part 42
+challengeType: 0
+dashedName: part-42
+---
+
+# --description--
+
+Now update the `innerText` of the other two buttons. They should be set to equal the same thing as the first button, except the number inside the brackets should be 1 for the second button and 2 for the third button.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  update
+    .toString()
+    .match(
+      /button2\.innerText\s*\=\s*location\[[\'\"\`]button text[\'\"\`]\]\[1\]/
+    ) &&
+    update
+      .toString()
+      .match(
+        /button3\.innerText\s*\=\s*location\[[\'\"\`]button text[\'\"\`]\]\[2\]/
+      )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = "Go to cave";
+  button3.innerText = "Fight dragon";
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-043.md

@@ -0,0 +1,262 @@
+---
+id: 5d68c5efe0696bdec46938ea
+title: Part 43
+challengeType: 0
+dashedName: part-43
+---
+
+# --description--
+
+Now update the three `onclick` properties. These will look very similar to the `innerText` properties, except instead of using the `"button text"` part of the `location`, use `"button functions"`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  update
+    .toString()
+    .match(
+      /button1\.onclick\s*\=\s*location\[[\'\"\`]button functions[\'\"\`]\]\[0\]/
+    ) &&
+    update
+      .toString()
+      .match(
+        /button2\.onclick\s*\=\s*location\[[\'\"\`]button functions[\'\"\`]\]\[1\]/
+      ) &&
+    update
+      .toString()
+      .match(
+        /button3\.onclick\s*\=\s*location\[[\'\"\`]button functions[\'\"\`]\]\[2\]/
+      )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = goStore;
+  button2.onclick = goCave;
+  button3.onclick = fightDragon;
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-044.md

@@ -0,0 +1,248 @@
+---
+id: 5d68c758e0696bdec46938eb
+title: Part 44
+challengeType: 0
+dashedName: part-44
+---
+
+# --description--
+
+Finally, update `text.innerText` to equal the `text` from the location object.
+
+So far we have been accessing properties of the location object using bracket notation. This time use dot notation. Here is how to access a `name` property of an object called `obj` using dot notation: `obj.name`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(update.toString().match(/text\.innerText\s*\=\s*location\.text\;?/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = "You are in the town square. You see a sign that says \"Store\".";
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-045.md

@@ -0,0 +1,247 @@
+---
+id: 5d68c947e0696bdec46938ec
+title: Part 45
+challengeType: 0
+dashedName: part-45
+---
+
+# --description--
+
+Now update the `goStore` function. The code should look just like the code inside the `goTown` function, except the number 0 should be changed to 1. After this step would be a good time to try out the game so far. You should be able to move between the store and the town square.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(goStore.toString().match(/update\(locations\[1\]\)/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-046.md

@@ -0,0 +1,266 @@
+---
+id: 5d68ca40e0696bdec46938ed
+title: Part 46
+challengeType: 0
+dashedName: part-46
+---
+
+# --description--
+
+Add a third object in the `locations` array with the same properties as the other two objects.
+
+Set `name` to "cave". Set the elements in the `"button text"` array to \["Fight slime", "Fight fanged beast", and "Go to town square". Set te elements in the `"button functions"` array to be "fightSlime", "fightBeast", and "goTown". Set the value of the `text` property to "You enter the cave. You see some monsters.".
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(locations[2], {
+  name: 'cave',
+  'button text': ['Fight slime', 'Fight fanged beast', 'Go to town square'],
+  'button functions': [fightSlime, fightBeast, goTown],
+  text: 'You enter the cave. You see some monsters.'
+});
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+<script>
+// Need to initialize for test
+function fightSlime() {}
+function fightBeast() {}
+</script>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-047.md

@@ -0,0 +1,265 @@
+---
+id: 5d68d3f7e0696bdec46938ee
+title: Part 47
+challengeType: 0
+dashedName: part-47
+---
+
+# --description--
+
+Now update the `goCave` function using the pattern from `goTown` and `goCave`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(goCave.toString().match(/update\(locations\[2\]\)\;?/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+<script>
+// Need to initialize for test
+function fightSlime() {}
+function fightBeast() {}
+</script>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  console.log("Going to cave.");
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-048.md

@@ -0,0 +1,266 @@
+---
+id: 5d68d4fde0696bdec46938ef
+title: Part 48
+challengeType: 0
+dashedName: part-48
+---
+
+# --description--
+
+Create two more empty functions: `fightSlime` and `fightBeast`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(typeof fightSlime === 'function' && typeof fightBeast === 'function');
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-049.md

@@ -0,0 +1,275 @@
+---
+id: 5d68d631e0696bdec46938f0
+title: Part 49
+challengeType: 0
+dashedName: part-49
+---
+
+# --description--
+
+Now that the store and cave locations are complete, we'll code the actions at those locations. Inside the `buyHealth` function, set `gold` to equal `gold` minus 10.
+
+For example here is how you would set set `num` to equal 5 less than `num`: `num = num - 5;`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+buyHealth(), assert(gold === 40);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold = gold - 10;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-050.md

@@ -0,0 +1,275 @@
+---
+id: 5d68dbf7e0696bdec46938f1
+title: Part 50
+challengeType: 0
+dashedName: part-50
+---
+
+# --description--
+
+After gold is subtracted, add ten to health.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+buyHealth(), assert(gold === 40 && health === 110);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold = gold - 10;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold = gold - 10;
+  health = health + 10;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-051.md

@@ -0,0 +1,281 @@
+---
+id: 5d6904b6e0696bdec46938f2
+title: Part 51
+challengeType: 0
+dashedName: part-51
+---
+
+# --description--
+
+There is a shorthand way to add or subtract from a variable called compound assignment. The long way to add to a variable is `num = num + 5`. The shorthand way is `num += 5`. It works the same way with subtraction.
+
+Update both lines inside the `buyHealth` function to use compound assignment.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  buyHealth.toString().match(/gold\s*\-\=\s*10\;?/) &&
+    buyHealth.toString().match(/health\s*\+\=\s*10\;?/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold = gold - 10;
+  health = health + 10;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold -= 10;
+  health += 10;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-052.md

@@ -0,0 +1,281 @@
+---
+id: 5d6905ace0696bdec46938f3
+title: Part 52
+challengeType: 0
+dashedName: part-52
+---
+
+# --description--
+
+Now that the gold and health variables have been updated, we need to update the values displayed on the screen. Inside the `buyHealth` function, add the line `goldText.innerText = gold;`. Then use the same pattern to update `healthText`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  buyHealth.toString().match(/goldText\.innerText\s*\=\s*gold\;?/) &&
+    buyHealth.toString().match(/healthText.innerText\s*\=\s*health\;?/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold -= 10;
+  health += 10;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold -= 10;
+  health += 10;
+  goldText.innerText = gold;
+  healthText.innerText = health;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-053.md

@@ -0,0 +1,302 @@
+---
+id: 5d6f6bfc7c812010bf3327cc
+title: Part 53
+challengeType: 0
+dashedName: part-53
+---
+
+# --description--
+
+What if the player doesn't have enough gold to buy health? Put all the code in the `buyHealth` function inside an `if` statement. Here is an example of an `if` statement inside a function:
+
+```js
+function checkMoney() {
+  if (condition) {
+    console.log("You have money!");
+  }
+}
+```
+
+Note: For now you should use the word "condition" inside the `if` statement but we'll be changing that next.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(
+  buyHealth
+    .toString()
+    .match(
+      /if\s*\(\s*condition\s*\)\s*\{\s*(gold|health|goldText|healthText)/
+    ) &&
+    buyHealth.toString().match(/gold\s*\-\=\s*10\;?/) &&
+    buyHealth.toString().match(/health\s*\+\=\s*10\;?/) &&
+    buyHealth.toString().match(/goldText\.innerText\s*\=\s*gold\;?/) &&
+    buyHealth.toString().match(/healthText\.innerText\s*\=\s*health\;?/)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  gold -= 10;
+  health += 10;
+  goldText.innerText = gold;
+  healthText.innerText = health;
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (condition) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-054.md

@@ -0,0 +1,292 @@
+---
+id: 5d6f6e3c7c812010bf3327cd
+title: Part 54
+challengeType: 0
+dashedName: part-54
+---
+
+# --description--
+
+The word "condition" inside the if statement is just a placeholder. Change the condition to check if the amount of gold the player has is greater than or equal to 10.
+
+Here is an `if` statement that checks if `num` is greater than or equal to 5:
+
+```js
+if (num >= 5) {
+  console.log("Num is greater than or equal to five!");
+}
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(buyHealth.toString().match(/if\s*\(\s*gold\s*\>\=\s*10\s*\)/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (condition) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-055.md

@@ -0,0 +1,295 @@
+---
+id: 5d6f6f747c812010bf3327ce
+title: Part 55
+challengeType: 0
+dashedName: part-55
+---
+
+# --description--
+
+Now when a player tries to buy health it will only work if they have enough money. If the player does not have enough money, nothing will happen. Add an `else` statement where you can put code to run if a player dees not have enough money.
+
+Here is an example of an empty `else` statement:
+
+```js
+if (num >= 5) {
+  console.log("Num is greater than or equal to five!");
+} else {
+}
+```
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(buyHealth.toString().match(/\}\s*else\s*\{\s*\}/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-056.md

@@ -0,0 +1,290 @@
+---
+id: 5d6f70937c812010bf3327cf
+title: Part 56
+challengeType: 0
+dashedName: part-56
+---
+
+# --description--
+
+Inside the `else` statement, set `text.innerText` to equal "You do not have enough gold to buy health."
+
+# --hints--
+
+See description above for instructions.
+
+```js
+(gold = 5),
+  buyHealth(),
+  assert(text.innerText === 'You do not have enough gold to buy health.');
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-057.md

@@ -0,0 +1,290 @@
+---
+id: 5d6f72657c812010bf3327d0
+title: Part 57
+challengeType: 0
+dashedName: part-57
+---
+
+# --description--
+
+Before we write the code for the `buyWeapon` function, use `const` to create a `weapons` variable right above the `locations` array. Set it to equal an empty array.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(weapons, []);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-058.md

@@ -0,0 +1,314 @@
+---
+id: 5d6f736b7c812010bf3327d2
+title: Part 58
+challengeType: 0
+dashedName: part-58
+---
+
+# --description--
+
+Just like in the `locations` array, all the elements in `weapons` will be objects. Add four objects to the `weapons` array, each with two properties: `name` and `power`. The first should be the `name` "stick" with `power` set to 5. Then, "dagger" with set `power` to 30. Next, "claw hammer" with a `power` of 50. Finally, "sword" with a `power` of 100.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert.deepStrictEqual(weapons, [
+  { name: 'stick', power: 5 },
+  { name: 'dagger', power: 30 },
+  { name: 'claw hammer', power: 50 },
+  { name: 'sword', power: 100 }
+]);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-059.md

@@ -0,0 +1,329 @@
+---
+id: 5d6f776c7c812010bf3327d3
+title: Part 59
+challengeType: 0
+dashedName: part-59
+---
+
+# --description--
+
+Inside the `buyWeapon` function, add an `if` statement to check if gold is greater than or equal to 30.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(buyWeapon.toString().match(/if\s*\(\s*gold\s*\>\=\s*30\)\s*\{\s*\}/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-060.md

@@ -0,0 +1,332 @@
+---
+id: 5d6f785f7c812010bf3327d4
+title: Part 60
+challengeType: 0
+dashedName: part-60
+---
+
+# --description--
+
+Similar to in the `buyHealth` function, set `gold` to equal 30 less than its current value.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+(gold = 50), buyWeapon(), assert(gold === 20);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-061.md

@@ -0,0 +1,333 @@
+---
+id: 5d6f79667c812010bf3327d6
+title: Part 61
+challengeType: 0
+dashedName: part-61
+---
+
+# --description--
+
+The value of `currentWeapon` corresponds to an index in the `weapons` array. The player starts with a stick since `currentWeapon` starts at 0 and `weapons[0]` is the "stick" weapon. In the `buyWeapon` function, add one to `currentWeapon` since the user is buying the next weapon in the `weapons` array.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+(currentWeapon = 0), buyWeapon(), assert(currentWeapon === 1);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+    currentWeapon += 1;
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-062.md

@@ -0,0 +1,342 @@
+---
+id: 5d6f7b917c812010bf3327d7
+title: Part 62
+challengeType: 0
+dashedName: part-62
+---
+
+# --description--
+
+You can easily increment or add one to a variable with the `++` operator. All three of these statements add one to a number:
+
+```js
+num = num + 1;
+num += 1;
+num++;
+```
+
+Change the line `currentWeapon += 1;` to use the `++` operator.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(buyWeapon.toString().match(/currentWeapon\s*\+\+\;?/));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+    currentWeapon += 1;
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+    currentWeapon++;
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-063.md

@@ -0,0 +1,340 @@
+---
+id: 5d6f82da7c812010bf3327d8
+title: Part 63
+challengeType: 0
+dashedName: part-63
+---
+
+# --description--
+
+Now update the `innerText` property of `goldText` and `text`. `text` should equal "You now have a new weapon.".
+
+# --hints--
+
+See description above for instructions.
+
+```js
+buyWeapon(),
+  assert(
+    goldText.innerText === '20' &&
+      text.innerText === 'You now have a new weapon.'
+  );
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+    currentWeapon++;
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+    currentWeapon++;
+    goldText.innerText = gold;
+    text.innerText = "You now have a new weapon.";
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```

curriculum/challenges/portuguese/02-javascript-algorithms-and-data-structures/basic-javascript-rpg-game/part-064.md

@@ -0,0 +1,339 @@
+---
+id: 5d6f919f7c812010bf3327d9
+title: Part 64
+challengeType: 0
+dashedName: part-64
+---
+
+# --description--
+
+Let's tell the player what weapon they bought. In between the two lines you just wrote, use `let` to initialize a new variable called `newWeapon`. Set `newWeapon` to equal `weapons`.
+
+# --hints--
+
+See description above for instructions.
+
+```js
+assert(/let\s*newWeapon\s*\=\s*weapons\;?/.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```html
+<!DOCTYPE html>
+<html lang="en" >
+<head>
+  <meta charset="UTF-8">
+  <title>RPG - Dragon Repeller</title>
+  <style>
+    body {
+      background-color: darkblue;
+    }
+    #text {
+      background-color: black;
+      color: white;
+      padding: 10px;
+    }
+    #game {
+      max-width: 500px;
+      max-height: 400px;
+      background-color: lightgray;
+      color: white;
+      margin: 0 auto;
+      padding: 10px;
+    }
+    #controls {
+      border: 1px black solid;
+      padding: 5px;
+    }
+    #stats {
+      border: 1px black solid;
+      color: black;
+      padding: 5px;
+    }
+    #monsterStats {
+      display: none;
+      border: 1px black solid;
+      color: white;
+      padding: 5px;
+      background-color: red;
+    }
+    .stat {
+      padding-right: 10px;
+    }
+  </style>
+</head>
+<body>
+<div id="game">
+  <div id="stats">
+    <span class="stat">XP: <strong><span id="xpText">0</span></strong></span>
+    <span class="stat">Health: <strong><span id="healthText">100</span></strong></span>
+    <span class="stat">Gold: <strong><span id="goldText">50</span></strong></span>
+  </div>
+  <div id="controls">
+    <button id="button1">Go to store</button>
+    <button id="button2">Go to cave</button>
+    <button id="button3">Fight dragon</button>
+  </div>
+  <div id="monsterStats">
+    <span class="stat">Monster Name: <strong><span id="monsterName"></span></strong></span>
+    <span class="stat">Health: <strong><span id="monsterHealth"></span></strong></span>
+  </div>
+  <div id="text">Welcome to Dragon Repeller. You must defeat the dragon that is preventing people from leaving the town. You are in the town square. Where do you want to go? Use the buttons above.</div>
+</div>
+```
+
+## --after-user-code--
+
+```html
+</body>
+</html>
+```
+
+## --seed-contents--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+  {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+    currentWeapon++;
+    goldText.innerText = gold;
+    text.innerText = "You now have a new weapon.";
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+
+</script>
+```
+
+# --solutions--
+
+```html
+<script>
+let xp = 0;
+let health = 100;
+let gold = 50;
+let currentWeapon = 0;
+let fighting;
+let monsterHealth;
+let inventory = ["stick"];
+
+const button1 = document.querySelector('#button1');
+const button2 = document.querySelector("#button2");
+const button3 = document.querySelector("#button3");
+const text = document.querySelector("#text");
+const xpText = document.querySelector("#xpText");
+const healthText = document.querySelector("#healthText");
+const goldText = document.querySelector("#goldText");
+const monsterStats = document.querySelector("#monsterStats");
+const monsterNameText = document.querySelector("#monsterName");
+const monsterHealthText = document.querySelector("#monsterHealth");
+
+const weapons = [
+  {
+    name: "stick",
+    power: 5
+  },
+  {
+    name: "dagger",
+    power: 30
+  },
+  {
+    name: "claw hammer",
+    power: 50
+  },
+  {
+    name: "sword",
+    power: 100
+  }
+];
+
+const locations = [
+  {
+    name: "town square",
+    "button text": ["Go to store", "Go to cave", "Fight dragon"],
+    "button functions": [goStore, goCave, fightDragon],
+    text: "You are in the town square. You see a sign that says \"Store.\""
+  },
+  {
+    name: "store",
+    "button text": ["Buy 10 health (10 gold)", "Buy weapon (30 gold)", "Go to town square"],
+    "button functions": [buyHealth, buyWeapon, goTown],
+    text: "You enter the store."
+  },
+    {
+    name: "cave",
+    "button text": ["Fight slime", "Fight fanged beast", "Go to town square"],
+    "button functions": [fightSlime, fightBeast, goTown],
+    text: "You enter the cave. You see some monsters."
+  }
+];
+
+// initialize buttons
+button1.onclick = goStore;
+button2.onclick = goCave;
+button3.onclick = fightDragon;
+
+function update(location) {  
+  button1.innerText = location["button text"][0];
+  button2.innerText = location["button text"][1];
+  button3.innerText = location["button text"][2];
+  button1.onclick = location["button functions"][0];
+  button2.onclick = location["button functions"][1];
+  button3.onclick = location["button functions"][2];
+  text.innerText = location.text;
+}
+
+function goTown() {
+  update(locations[0]);
+}
+
+function goStore() {
+  update(locations[1]);
+}
+
+function goCave() {
+  update(locations[2]);
+}
+
+function fightDragon() {
+  console.log("Fighting dragon.");
+}
+
+function buyHealth() {
+  if (gold >= 10) {
+    gold -= 10;
+    health += 10;
+    goldText.innerText = gold;
+    healthText.innerText = health;
+  } else {
+    text.innerText = "You do not have enough gold to buy health.";
+  }
+}
+
+function buyWeapon() {
+  if (gold >= 30) {
+    gold -= 30;
+    currentWeapon++;
+    goldText.innerText = gold;
+    let newWeapon = weapons;
+    text.innerText = "You now have a new weapon.";
+  }
+}
+
+function fightSlime() {
+}
+
+function fightBeast() {
+}
+</script>
+```