Can you solve this interview problem?

function permutate(arr) {
    if (arr.length == 1) return [arr];

    return arr.map((item, i) => {
        var rest = [...arr];
        rest.splice(i, 1);
        return permutate(rest).map(x => [item, ...x])
    }).flat();
}

permutate(JSON.parse(url))
  .map(x => atob(x.join('')))
  .map(x => { try { return new URL(x).toString() } catch { return null } })
  .filter(Boolean);

https://dev.xn--tocommen%7C1414%20-oqa05ipa4v8fnd624dn60pha/1je1m
https://dev.tocomment/1je1m%C3%B2%C3%B3%076%C2%87Wf%C3%B3
https://dev.to/0shuvo0/comment/1je1m
https://dev.to/0shuvo0-%0B%C3%8CZ%C2%99L[%7D%C2%8D%C2%BD%C2%B5%C2%B5%C2%95%C2%B9

import itertools, base64

originalarray = ["6Ly9kZXYudG", "9jb21tZW5", "8vMHNodXZvMC", "aHR0cHM", "0LzFqZTFt"]     # this is the input 

for i in itertools.permutations(originalarray, len(originalarray)):  # getting all possible combinations
    tmpdecodedstring = ""
    for k in i:     # iterate over each strng in the array and add it to the string
        tmpdecodedstring += str(k)
    try:
        print("URL is: " + str(str(base64.b64decode(tmpdecodedstring)).decode()))  # decode the string finally
    except:
        pass # only proper base64 string dont raise an error. If there is a error, that means that the string is incorrect and we try another permutation.

const permutator = (inputArr) => {
    let result = [];

    const permute = (arr, m = []) => {
        if (arr.length === 0) {
            result.push(m);
        } else {
            for (let i = 0; i < arr.length; i++) {
                const curr = arr.slice();
                const next = curr.splice(i, 1);
                permute(curr.slice(), m.concat(next));
            }
        }
    }

    permute(inputArr);

    return result;
}

const isValidUrl = (candidateUrl) => {
    return /^https:\/\/dev.to\/([\w0-9]+\/?)+$/i.test(candidateUrl);
}

const array = url.replace(/[\[ \]"]/g, '').split(',')
const correctUrl = permutator(array)
    .map(p => p.join(''))
    .map(s => Buffer.from(s, 'base64').toString())
    .filter(isValidUrl)
    .pop();

console.log(correctUrl);

let url = ["aHR0cHM", "6Ly9kZXYudG", "8vMHNodXZvMC",  "9jb21tZW5",  "0LzFqZTFt" ]
var joinedUrl = url.join()
console.log(joinedUrl)

var result = joinedUrl.replace(/,/g, "")
var decoded = atob(result)
console.log(decoded)

[LOG]: "https://dev.to/0shuvo0/comment/1je1m" 

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

use MIME::Base64 qw{ decode_base64 };
use List::Util qw{ shuffle };

my $cipher = '[ "6Ly9kZXYudG", "9jb21tZW5", "8vMHNodXZvMC", "aHR0cHM", "0LzFqZTFt" ]';

my @strings = $cipher =~ /"([^"]+)"/g;

my $string = "";
until ($string =~ /^[ -~]+$/) {
    @strings = shuffle(@strings);
    $string = decode_base64(join "", @strings);
}
say $string;

let url = [ "6Ly9kZXYudG", "9jb21tZW5", "8vMHNodXZvMC", "aHR0cHM", "0LzFqZTFt" ]

function testUrl(testUrl) {
  return/^[\x00-\x7F]*$/.test(testUrl);
}

function test(segments, currentString) {
  //console.log("try(segments: " + segments + " currentString: " + currentString)
  if (segments.length == 0) {
    let decoded = atob(currentString)
    if (decoded.startsWith("https://") && testUrl(decoded)) {
      console.log("Encoded: " + currentString)
      console.log("Decoded: " + decoded);
    }
  } else {
    for (let i=0; i<segments.length; i++) {
      let newString = currentString + segments[i];
      let remainingSegments = segments.slice(0, i).concat(segments.slice(i+1, segments.length))

      test(remainingSegments, newString)
    }
  }
}

test(url, "")

Encoded: aHR0cHM6Ly9kZXYudG8vMHNodXZvMC9jb21tZW50LzFqZTFt
Decoded: https://dev.to/0shuvo0/comment/1je1m