const
    codeFunctionForMapping = replacementMapping => (
      inputString => inputString.replace(/./g, c => replacementMapping[c] || c)
    ),
    encode = codeFunctionForMapping({a:1, e:2, i:3, o:4, u:5}),
    decode = codeFunctionForMapping({1:'a', 2:'e', 3:'i', 4:'o', 5:'u'})

> encode('hello')
< "h2ll4"

> decode('h2ll4')
< "hello"

> encode('Step 1: Create a function called encode() to replace all the lowercase vowels in a given string with numbers according to the following pattern:')
< "St2p 1: Cr21t2 1 f5nct34n c1ll2d 2nc4d2() t4 r2pl1c2 1ll th2 l4w2rc1s2 v4w2ls 3n 1 g3v2n str3ng w3th n5mb2rs 1cc4rd3ng t4 th2 f4ll4w3ng p1tt2rn:"

> decode('St2p 1: Cr21t2 1 f5nct34n c1ll2d 2nc4d2() t4 r2pl1c2 1ll th2 l4w2rc1s2 v4w2ls 3n 1 g3v2n str3ng w3th n5mb2rs 1cc4rd3ng t4 th2 f4ll4w3ng p1tt2rn:')
< "Step a: Create a function called encode() to replace all the lowercase vowels in a given string with numbers according to the following pattern:" 
    // Well, I prefer alpha bullets anyway :|

const letters = ['a', 'e' ,'i', 'o', 'u']
const letters_ex = /a|e|i|o|u/g
const numbers_ex = /[1-5]/g
// dirty coercion
const encode = str => str.replace(letters_ex, c => letters.indexOf(c) + 1)
const decode = str => str.replace(numbers_ex, c => letters[/*parseInt*/(c) - 1])

const letters = [/*undefined*/, 'a', 'e' ,'i', 'o', 'u']
const letters_ex = /a|e|i|o|u/g
const numbers_ex = /[1-5]/g

const encode = str => str.replace(letters_ex, c => letters.indexOf(c))
const decode = str => str.replace(numbers_ex, c => letters[c]) // oh yes, real life string indexing

const maek = (...letters) => {
  const len = letters.length;
  if (len < 1 || len > 9) throw "💩"
  const letters_ex = new RegExp(letters.join('|'), 'g')
  const numbers_ex =  new RegExp(`[1-${letters.length}]`, 'g')
  const l = [, ...letters]
  const encode = str => str.replace(letters_ex, c => l.indexOf(c))
  const decode = str => str.replace(numbers_ex, c => l[c])
  return {encode, decode}
}

const {encode, decode} = maek('a', 'e' ,'i', 'o', 'u')

const vowels = ['a', 'e' ,'i', 'o', 'u'];
const v4w2ls = ['1', '2', '3', '4', '5']; 

const encode = str => [...str].map(e => vowels.includes(e) ? e = vowels.indexOf(e) + 1 : e).join('');
const decode = str => [...str].map(e => v4w2ls.includes(e) ? e = vowels[v4w2ls.indexOf(e)] : e).join('');

def encode(st):
    encode_list = {
        'a': '1',
        'e': '2',
        'i': '3',
        'o': '4',
        'u': '5',
    }

    encoded_string = ""
    for char in st:
        if char in encode_list:
            encoded_string += encode_list[char]
        else:
            encoded_string += char

    return encoded_string

def decode(st):
    decode_list = {
        '1': 'a',
        '2': 'e',
        '3': 'i',
        '4': 'o',
        '5': 'u',
    }

    decoded_string = ""
    for char in st:
        if char in decode_list:
            decoded_string += decode_list[char]
        else:
            decoded_string += char

    return decoded_string

val toIndex = Map('a' -> '1', 'e' -> '2', 'i' -> '3', 'o' -> '4', 'u' -> '5')
val toVowel = toIndex map { _.swap }

def encode (str: String): String = str.map(ch => if (toIndex.contains(ch)) toIndex(ch) else ch).mkString
def decode (str: String): String = str.map(ch => if (toVowel.contains(ch)) toVowel(ch) else ch).mkString

scala> decode("h2ll4")
res2: String = hello

scala> encode("hello")
res3: String = h2ll4

scala> decode("h3 th2r2")
res4: String = hi there

scala> decode("h2ll4")
res5: String = hello

scala> encode("This is an encoding test.")
res6: String = Th3s 3s 1n 2nc4d3ng t2st.

scala> encode("How are you today?")
res7: String = H4w 1r2 y45 t4d1y?

(def e {\a 1 \e 2 \i 3 \o 4 \u 5})
(def d [\a\e\i\o\u])

(defn encode [s] (apply str (map #(get e % %) s)))
(defn decode [s] (apply str (map #(get d (- (int %) (int \1)) %) s)))

def encode(st):
    vowel_to_num = {'a': '1', 'e': '2', 'i': '3', 'o': '4', 'u': '5'}
    return ''.join(vowel_to_num.get(char, char) for char in st)

def decode(st):
    num_to_vowel = {'1': 'a', '2': 'e', '3': 'i', '4': 'o', '5': 'u'}
    return ''.join(num_to_vowel.get(char, char) for char in st)

var vowels = ['a', 'e', 'i', 'o', 'u'];

function encode(input) {
  return [...input].map(char => vowels.includes(char) ? vowels.indexOf(char)+1 : char).join('');
}

function decode(input) {
  return [...input].map(char => Number(char) ? vowels[Number(char)-1] : char).join('');
}