将字符串作为排序块返回 - Codewars 挑战 - JavaScript

Question

I've been trying to solve this codewars challenge . The idea is to return the string, rearranged according to its hierarchy, or separated into chunks according to the repeating character.

---

You will receive a string consisting of lowercase letters, uppercase letters and digits as input. Your task is to return this string as blocks separated by dashes ("-"). The elements of a block should be sorted with respect to the hierarchy listed below, and each block cannot contain multiple instances of the same character.

The hierarchy is:

lowercase letters (a - z), in alphabetic order uppercase letters (A - Z), in alphabetic order digits (0 - 9), in ascending order Examples

"21AxBz" -> "xzAB12"

• since input does not contain repeating characters, you only need 1 block

"abacad" -> "abcd-aa"

• character "a" repeats 3 times, thus 3 blocks are needed

"" -> ""

• an empty input should result in an empty output

---

What I've tried actually works for the given test cases:

describe("Sample tests", () => {
  it("Tests", () => {
    assert.equal(blocks("21AxBz"), "xzAB12");
    assert.equal(blocks("abacad"), "abcd-a-a");
    assert.equal(blocks(""), "");
  });
});

But fails when there are any repeating characters, besides in the test cases:

 function repeatingChar(str){ const result = []; const strArr = str.toLowerCase().split("").sort().join("").match(/(.)\\1+/g); if (strArr != null) { strArr.forEach((elem) => { result.push(elem[0]); }); } return result; } function blocks(s) { if (s.length === 0) { return ''; } //if string does not contain repeating characters if (!/(.).*\\1/.test(s) === true) { let lower = s.match(/[az]/g).join(''); let upper = s.match(/[AZ]/g).join(''); let numbers = s.match(/[\\d]/g).sort().join(''); return lower + upper + numbers; } //if string contains repeating characters if (!/(.).*\\1/.test(s) === false) { let repeatChar = (repeatingChar(s)[0]); let repeatRegex = new RegExp(repeatingChar(s)[0]); let repeatCount = s.match(/[repeatRegex]/gi).length; let nonAChars = s.match(/[^a]/gi).join(''); function getPosition(string, subString, index) { return s.split(repeatChar, index).join(repeatChar).length; } let index = getPosition(s, repeatChar, 2); // console.log('indexxxxx', index); return s.slice(0, index) + nonAChars.slice(1) + ('-' + repeatChar).repeat(repeatCount - 1); } } console.log(blocks("abacad"));

And actually, I'm not sure what's wrong with it, because I don't know how to unlock any other tests on Codewars.

You can see that what I'm trying to do, is find the repeating character, get all characters that are not the repeating character, and slice the string from starting point up until the 2 instance of the repeating character, and then add on the remaining repeating characters at the end, separated by dashes.

Any other suggestions for how to do this?

Answer 1

The first obvious error I can see is let repeatCount = s.match(/[repeatRegex]/gi).length; . What you really want to do is:

  let repeatRegex = new RegExp(repeatingChar(s)[0], 'g');
  let repeatCount = s.match(repeatRegex).length;

The next is that you only look at one of the repeating characters, and not all of them, so you won't get blocks of the correct form, so you'll need to loop over them.

let repeatedChars = repeatingChar(s);
for(let c of repeatedChars)
{
  //figure out blocks
}

When you're building the block, you've decided to focus on everything that's not "a". I'm guessing that's not what you originally wrote, but some debugging code, to work on that one sample input.

If I understand your desire correctly, you want to take all the non-repeating characters and smoosh them together, then take the first instance of the first repeating character and stuff that on the front and then cram the remaining instances of the repeating character on the back, separated by - .

The problem here is that the first repeating character might not be the one that should be first in the result. Essentially you got lucky with the repeating character being a .

Fixing up your code, I would create an array and build the blocks up individually, then join them all together at the end.

let repeatedChars = repeatingChar(s);
let blocks = []
for(let c of repeatedChars)
{
  let repeatRegex = new RegExp(c, 'g');
  let repeatCount = s.match(repeatRegex).length;

  for(let i = 1; i <= repeatCount; i++)
  {
    if(blocks.length < i)
    {
      let newBlock = [c];
      blocks.push(newBlock);
    }
    else
    {
      block[i - 1].push(c);
    }
  }
}

let tailBlocks = blocks.map(block => block.join('')).join('-');

However, this leaves me with a problem of how to build the final string with the non-repeating characters included, all in the right order.

So, to start with, let's make the initial string. To do so we'll need a custom sort function (sorry, it's pretty verbose. If only we could use regular ASCII ordering):

function lowerUpperNumber(a, b)
{
  if(a.match(/[a-z]/) && b.match(/[A-Z0-9]/))
  {
      return -1; 
  } 
  else if(a.match(/[A-Z]/) && (b.match(/[0-9]/) || b.match(/[a-z]/)))
  {
    if(b.match(/[0-9]/))
    {
      return -1;
    } 
    else if(b.match(/[a-z]/))
    {
      return 1;
    }
  } 
  else if(a.match(/[0-9]/) && b.match(/[a-zA-Z]/))
  {
    return 1;
  }
  else if(a > b)
  {
    return 1;
  }
  else if(a < b)
  {
    return -1;
  }
  return 0;
}

Then create the head of the final output:

let firstBlock = [...(new Set(s))].sort(lowerUpperNumber);

The Set creates a set of unique elements, ie no repeats.

Because we've created the head string, when creating the blocks of repeated characters, we'll need one fewer than the above loop gives us, so we'll be using s.match(repeatRegex).length-1 .

I get the desire to short circuit the complicated bit and return quickly when there are no repeated characters, but I'm going to remove that bit for brevity, and also I don't want to deal with undefined values (for example try '123' as your input).

Let's put it all together:

 function lowerUpperNumber(a, b) { if(a.match(/[az]/) && b.match(/[A-Z0-9]/)) { return -1; } else if(a.match(/[AZ]/) && (b.match(/[0-9]/) || b.match(/[az]/))) { if(b.match(/[0-9]/)) { return -1; } else if(b.match(/[az]/)) { return 1; } } else if(a.match(/[0-9]/) && b.match(/[a-zA-Z]/)) { return 1; } else if(a > b) { return 1; } else if(a < b) { return -1; } return 0; } function makeBlocks(s) { if (s.length === 0) { return ''; } let firstBlock = [...(new Set(s))].sort(lowerUpperNumber); let firstString = firstBlock.join(''); let blocks = []; for(let c of firstString) { let repeatRegex = new RegExp(c, 'g'); let repeatCount = s.match(repeatRegex).length - 1; for(let i = 1; i <= repeatCount; i++) { if(blocks.length < i) { let newBlock = [c]; blocks.push(newBlock); } else { blocks[i - 1].push(c); } } } blocks.unshift(firstBlock); return blocks.map(block => block.join('')).join('-'); } console.log(makeBlocks('21AxBz')); console.log(makeBlocks('abacad')); console.log(makeBlocks('Any9Old4String22With7Numbers')); console.log(makeBlocks(''));

You'll see I've not bothered generating the characters that repeat, because I can just skip the ones that don't.

Answer 2

For funzies, here's how I would have approached the problem:

 const isLower = new RegExp('[az]'); const isUpper = new RegExp('[AZ]'); const isDigit = new RegExp('[0-9]'); const isDigitOrUpper = new RegExp('[0-9A-Z]'); const isDigitOrLower = new RegExp('[0-9a-z]'); const isLowerOrUpper = new RegExp('[a-zA-Z]'); function lowerUpperNumber(a, b) { if(isLower.test(a) && isDigitOrUpper.test(b)) { return -1; } else if(isUpper.test(a) && isDigitOrLower.test(b)) { if(isDigit.test(b)) { return -1; } else if(isLower.test(b)) { return 1; } } else if(isDigit.test(a) && isLowerOrUpper.test(b)) { return 1; } else if(a > b) { return 1; } else if(a < b) { return -1; } return 0; } function makeBlocks(input) { let sortedInput = input.split(''); sortedInput.sort(lowerUpperNumber); let output = ''; let blocks = []; for(let c of sortedInput) { let inserted = false; for(let block of blocks) { if(block.indexOf(c) === -1) { inserted = true; block.push(c); break; } } if(!inserted) { blocks.push([c]); } } output = blocks.map(block => block.join('')).join('-'); return output; } console.log(makeBlocks('21AxBz')); console.log(makeBlocks('abacad')); console.log(makeBlocks('Any9Old4String22With7Numbers')); console.log(makeBlocks(''));