Algorithms - No Repeats Please. Update: now it's about approach, not task

Tell us what’s happening:
I am confused by this part of the task:

Assume that all characters in the provided string are each unique.

To me the above means, that str parameter should be:

'abc'
'abcde'

But not with duplicates of characters:

'aba'
'abcdea'

However, there are example and test cases:

'aab'
permAlone("aabb")
permAlone("aaa")

I don’t know, did I misunderstand instructions completely?

  **Your code so far**
function permAlone(str) {
return str;
}

permAlone('aab');
  **Your browser information:**

User Agent is: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36

Challenge: Algorithms - No Repeats Please

Link to the challenge:

I think the instructions mean to say “Treat all characters in the provided string as if they are each unique”.

1 Like

well, this way it’s more clear. Thanks.

I am trying to solve it with maths.

I guess I can find answer without actually building any permutations, just knowing number of repeating characters. I built object for in the code, I hope idea can be gathered from it’s structure.

I know that number of total permutations can be calculated with factorial.
But I am struugling to develop formula for this particular task, though I see some patterns.

I did some tests, from that it should be clear where I am in solving this right now.

Note: I know how to solve it by brute force: built array af all perms (I did that recursively in Python some time ago). Then filter it, checking every element for not having repeats. But that would be heavy stuff.

const factorial = (num) => {
  let mult = num - 1;
  while (mult > 0) {
    num *= mult;
    mult--;
  }
  return num;
}

function permAlone(str) {
  
  const len = str.length;
  let charOccurances = {};
  
  for (let i = 0; i < len; i++) {
    if (charOccurances.hasOwnProperty(str[i])) {
      charOccurances[str[i]] += 1;
    }
    else {
      charOccurances[str[i]] = 1;
    }
  }
  
  console.log('Checking occurances of chars for string ', str);
  console.log(charOccurances);
  
  const allPossiblePerms = factorial(len);
  
  console.log('logging number of all perms ', allPossiblePerms);
  
  return str;
}

const testCases = [
  ["aab", 2],
  ["aaa", 0],
  ["aabb", 8],
  ["abcdefa", 3600],
  ["abfdefa", 2640],
  ["zzzzzzzz", 0],
  ["a", 1],
  ["aaab", 0],
  ["aaabb", 12],
  ];
  
for (test of testCases) {
  console.log('TEST CASE ', test[0]);
  console.log('result: ', permAlone(test[0]));
  console.log('no repeats perms, expected: ', test[1]);
  console.log('---------------')
}

/* TESTS OUTPUT
Output:

TEST CASE  aab
Checking occurances of chars for string  aab
{ a: 2, b: 1 }
logging number of all perms  6
result:  aab
no repeats perms, expected:  2
---------------
TEST CASE  aaa
Checking occurances of chars for string  aaa
{ a: 3 }
logging number of all perms  6
result:  aaa
no repeats perms, expected:  0
---------------
TEST CASE  aabb
Checking occurances of chars for string  aabb
{ a: 2, b: 2 }
logging number of all perms  24
result:  aabb
no repeats perms, expected:  8
---------------
TEST CASE  abcdefa
Checking occurances of chars for string  abcdefa
{ a: 2, b: 1, c: 1, d: 1, e: 1, f: 1 }
logging number of all perms  5040
result:  abcdefa
no repeats perms, expected:  3600
---------------
TEST CASE  abfdefa
Checking occurances of chars for string  abfdefa
{ a: 2, b: 1, f: 2, d: 1, e: 1 }
logging number of all perms  5040
result:  abfdefa
no repeats perms, expected:  2640
---------------
TEST CASE  zzzzzzzz
Checking occurances of chars for string  zzzzzzzz
{ z: 8 }
logging number of all perms  40320
result:  zzzzzzzz
no repeats perms, expected:  0
---------------
TEST CASE  a
Checking occurances of chars for string  a
{ a: 1 }
logging number of all perms  1
result:  a
no repeats perms, expected:  1
---------------
TEST CASE  aaab
Checking occurances of chars for string  aaab
{ a: 3, b: 1 }
logging number of all perms  24
result:  aaab
no repeats perms, expected:  0
---------------
TEST CASE  aaabb
Checking occurances of chars for string  aaabb
{ a: 3, b: 2 }
logging number of all perms  120
result:  aaabb
no repeats perms, expected:  12
---------------
*/

I solved it by creating unique combinations of indexes. I looked up the suggested solutions and I still like my approach better lol

I just pushed my solution here below, but I don’t like it.
repo on git hub
I believe it can be solved by good mathematician and calculator without any building at all. Edit. Well, maybe it will be long process with just calculator, but I thnik there are formulas that can be useful here.
I looked up solutions, they are all building something also as far as I figured.