Question

我当时在做代码战挑战，找不到解决方案，但是我真的很想知道我们如何解决这个问题。

所以我们得到两个整数，假设N和D，我们应该返回一个字符串，该字符串包含正好N个字母“ n”和正好D个字母d，且三个连续字母都不相同。

例如，如果我们得到N = 5和D = 3，我们应该返回“ nndnndnd”或“ nbnnbbnn”或任何其他正确答案

另一个示例，例如，如果我们得到N = 1 D = 4，则唯一可接受的答案应该是“ ddndd”

我所做的就是像这样创建一个辅助函数：

function generateArray (char,q){
let arr= []
for(let i=0; i<q; i++){
    arr.push(char)
}

return arr
}

及其主要功能内：

function solution(N, D) {
let arrayOfchar = generateArray('n',N)

    arrayOfchar.reduce((prev,current,index) => {
        for(let i=0; i<D; i++) {
        if(prev===current) {
            arrayOfchar.splice(index, 0, "d")
        }
    }
    })
}

但是我不知道我应该只在两个或更少的连续“ n”之后加上“ d”

有人知道吗？

Answer 1

我认为，与其一开始就创建相同字符的整个数组，不如逐个创建数组，直到N和D等于0，才有意义。

这是一种可能的实现。一般的想法是尝试推动较大的字符数，或者如果由于行三合一而导致不可能，则推动另一个字符，然后将适当的字符数减一。重复直到两个计数都为0：

function solution(n, d) {
  const arr = [];
  function canPush(char) {
    const { length } = arr;
    return (arr[length - 1] !== char || arr[length - 2] !== char);
  }
  function push(char) {
    arr.push(char);
    if (char === 'n') n--;
    else if (char === 'd') d--;
  }
  
  while (n > 0 || d > 0) {
    if (n > d) {
      if (canPush('n')) push('n');
      else if (d === 0) return console.log('Impossible');
      else push('d');
    } else if (d >= n) {
      if (canPush('d')) push('d');
      else if (n === 0) return console.log('Impossible');
      else push('n');
    }
  }
  console.log(JSON.stringify(arr));
  // return arr;
}
solution(5, 3);
solution(1, 4);
solution(1, 5);
solution(5, 1);
solution(2, 5);
solution(2, 6);
solution(2, 7);

Answer 2

这里是解决这个有趣问题的另一种方法。这个想法不是一个接一个地计算，而是找出哪个是较大的数字，然后对成对的字母进行排列，同时对较小的一个简单的数组进行排列，然后将它们彼此连在一起……所以您有了5和3 ... nn + d + nn + d + n 。 2对较大的，另加1对较小的，等等。

const fillArray = (length, letter, bigNumber) => {
   var arr = []
   for(var index=0; index < length; index++) {
      arr.push([letter, bigNumber%2 && index+1 === length ? null : letter])
   }
   return arr;
}
const getString = (n, d) => {
  var swtch = d > n, arr = [],
   bigger = {number: swtch ? d : n, letter: swtch ? 'd' : 'n', ceil: Math.ceil((swtch ? d : n)/2)},
   smaller = {number: swtch ? n : d, letter: swtch ? 'n' : 'd', ceil: Math.ceil((swtch ? n : d)/2)}

   if(Math.abs((bigger.number/2) - smaller.number >= 1.5)) {
     return 'Not possible with given parameters!'
   }

   var bigWorkArray = fillArray(bigger.ceil, bigger.letter, bigger.number)
   var smallWorkArray = n === d ? fillArray(smaller.ceil, smaller.letter, smaller.number) : Array(smaller.number).fill(smaller.letter)

   for(var i=0; i < bigWorkArray.length; i++) {
     arr.push(...bigWorkArray[i],...smallWorkArray[i] || '')
   }	
   return arr.join('');
}

console.log(getString(5,3))
console.log(getString(1,4))
console.log(getString(1,5))
console.log(getString(5,1))
console.log(getString(2,5))
console.log(getString(2,6))
console.log(getString(2,7))

Javascript |基于连续字母条件的字符动态数组

2 个答案: