Hi there (new) contributors.

The way this works is you can follow the link below to the problem specifications. This is the canonical data we have for this exercise. If you want a grasp of how this exercise might look, have a look at other tracks, where this exercise is implemented. You'll probably want to start with similar languages such as typescript and coffeescript, and then perhaps other loosly-typed languages such as ruby or python.

1. Open a new issue, we'll label it with new exercise ✨
2. We'll assign the issue to you, so you get to work on this exercise
3. Create a new folder in /exercises
4. You'll need to sync this folder with the matching config files. You can use scripts/sync to do this: ASSIGNMENT=slug npx @babel/node scripts/sync.
5. Create a <slug>.js stub file.
6. Create a <slug>.spec.js test file. Here add the tests, per canonical data if possible.
7. Create a example.js file. Place a working implementation, assuming it's renamed to <slug>.js
8. Run the tests locally, using scripts/test: ASSIGNMENT=slug npx @babel/node scripts/test.
9. Open a PR.

NOTE: Use this link for a ⚡️ live list of unimplemented exercises.

Describe the improvement:

When a solution has +expression instead of Number(expression), and it's otherwise optimal, we want to give a specific message. It should still approve, but add a message that Number(...) is preferred over unary +.

Which exercise

resistor-color-duo

Describe the improvement:

When the following main method is provided, the analyzer bails early:

export const value = arr => {
  return +(COLORS.indexOf(arr[0]) + "" + COLORS.indexOf(arr[1]));
};

Instead, it should be caught by hasDigitsString, and produce the same comment.

Which exercise

resistor-color-duo

Additional context

The ResistorColorDuoSolution has a method that checks if an exercise has a constructed string. It currently only detects a string template literal that looks like ${a}${b}, but we want to also capture the following:

`${a}` + `${b}`
a + "" + b
a + '' + b
""  + a + b
''  + a + b
a.toString() + b
a.toString() + b.toString()
a.toString().concat(b)

This issue is for discussion and assignment for the rna-transcription core exercise in the javascript track.

🔗 implementation | mentor-notes | problem-specification

This exercise focuses on

• String iteration (String#replace, String#split)
• Object/Map

Optimal solution

const TRANSCRIPTION = {
  C: 'G',
  G: 'C',
  A: 'U',
  T: 'A',
};

export function toRna(sequence) {
  return sequence
    .split('')
    .map(nucleotide => TRANSCRIPTION[nucleotide])
    .join('')
}

Variations include Set or Map with #get, which are valid!

Variations (approvable without comment)

String destructuring can also be used:

return [...sequence].map(/**/).join('')

String#replace can also be used:

return sequence.replace(/./g, (nucleotide) => /* */)

Variations include replacing only the "known" nucleotides:

sequence.replace(/[CGAT]g/, (nucleotide) => /* */)

Helper function variation

Instead of an anonymous function, a helper function may be used:

function transcribe(nucleotide) {
  return TRANSCRIPTION[nucleotide]
}

This also allows for a version without a mapping object:

function transcribe(nucleotide) {
  switch(nucleotide) {
    case 'C': { return 'G' }
    case 'G': { return 'C' }
    case 'A': { return 'U' }
    case 'T': { return 'A' }
  }
}

SHOULD comment and disapprove

Cases we SHOULD comment on with this analyzer:

• Use an Object to keep track of the mapping instead of conditionals.
• Use iteration via String#split or String#replace instead of using for/forEach with Array#push
• Discourage Array#reduce for this particular solution, because it creates a lot of intermediary strings (more than the split approach), except if the rest of the solution is correct (then you can mention it but approve). Using reduce requires more interpretation by the reader to follow, change and maintain.
• Discourage String#substring with foreach iteration, because character iteration via split('') is more idiomatic and maintainable than substring with 1. Using split('') requires less interpretation by the reader to follow, change and maintain.

Approach

The suggested approach is to:

• detect which type of solution it is (switch, map, or for/forEach)
• make sure the optimal solution is correctly handled. You can use the batch runner to generate output for all fixtures.
• go from there by adding paths to disapprove.