Question

我试图通过使用数组来解决这个问题。

var str="abcdefgh";
for (i=0;i<255;i++){
    arr[i]=false;
}
function check(){
    for (i=0;i<str.length;i++){
        if (arr[str.charCodeAt(i)]==true){
            return false;
        }
        arr[str.charCodeAt(i)]=true;
    }
    return true;
}

我正在初始化一个固定大小为256的数组，以获得布尔值false。然后我将字符串中字符的相应ASCII索引的值设置为true。如果我再次找到相同的角色，我将返回false。

在运行程序时，即使字符串没有任何重复字符，我也会返回false。

Answer 1

使用对象获得更快的结果

function is_unique(str) {
  var obj = {};
  for(var z=0;z<str.length;++z) {
    var ch = str[z];
    if(obj[ch]) return false; else obj[ch] = true;
  }
  return true;
}
// test:
console.log(is_unique("abcdefgh")); // true
console.log(is_unique("aa")); // false

Answer 2

使用所有字符填充Set并将其大小与字符串的长度进行比较：

function isUnique(str) {
  return new Set(str).size == str.length;
}

console.log(isUnique('abc'));    // true
console.log(isUnique('abcabc')); // false

Answer 3

为每个角色使用.match（）函数。使用长度计算出现次数。猜猜是的。

(str.match(/yourChar/g) || []).length

Answer 4

您使用arr[str.charCodeAt(i)]这是错误的。它应该是arr[str[i].charCodeAt(0)]

var arr = [];
var str="abcdefgh";
for (i=0;i<255;i++){
    arr[i]=false;
}
function check(){
    for (i=0;i<str.length;i++){
        if (arr[str[i].charCodeAt(0)]==true){
            return false;
        }
        arr[str[i].charCodeAt(0)]=true;
    }
    console.log(arr);
    return true;
}
check();

Answer 5

时间复杂度= O（n）空间复杂度= O（n）

const isUnique = (str) => {
      let charCount = {};
      for(let i = 0; i < str.length; i++) {
        if(charCount[str[i]]){
          return false;
        }

        charCount[str[i]] = true;
      }

      return true;
    }


    const isUniqueCheekyVersion = (str) => {
      return new Set(str).size === str.length;
    }

解决方案3：将字符串转换为chars数组，对其进行排序，然后遍历它们以检查相邻的元素，如果存在匹配项，则返回false否则为true

解决方案4：它与解决方案1类似，不同之处在于我们使用Set数据结构，该结构在javascript的最新版本中引入

Answer 6

Sub test5()

Dim Total As Long

Total = Application.Sum(Range("DEUX").Value, Sheet1.Range("D2").Value)

End Sub

Answer 7

使用对象作为映射器

function uniqueCharacterString(inputString) {
  const characterMap = {};

  let areCharactersUnique = true;

  inputString.trim().split("").map((ch)=>{
    if(characterMap[ch]===undefined) {
      characterMap[ch] = 1;
    } else {
      areCharactersUnique = false;
    }
  })
  return areCharactersUnique;
}

Answer 8

算法

* 1。步骤-第一个字符串是-> stack *

* 2。CharArray的逐步字符串隐藏*

3。步骤-在数组['s'，'t'，'a'，'c'，'k']中使用迭代

4。步骤-if（beginElement！== nextElement）{返回true}否则{return false}

实施代码

function uniqueChars(string){
var charArray = Array.from(string) //convert charArray
  for(var i=0;i<charArray.length;i++){
    if(charArray[i] !== charArray[i+1]){ 
      return true
    }
    else{
      return false
    }
  }

}
var string ="stack"
console.log(uniqueChars(string))

时间复杂度 O（nlogn）

Answer 9

我们也可以尝试使用indexOf和lastIndexOf方法

function stringIsUnique(input){
    for(i=0;i<input.length;i++){
        if(input.indexOf(input[i]) !== input.lastIndexOf(input[i])){
            return false;
        }
    }
    return true;
}

Answer 10

算法

计算字母的频率。例如'Mozilla' 将返回 Object{ M: 1, o: 1, z: 1, i: 1, l: 2, a: 1 }。请注意，-~undefined 上的按位非运算符 (~) 是 1，-~1 是 2，-~2 是3 等
当所有匹配项仅出现一次时返回 true。

实现代码

var isUnique = (str) => {
  const hash = {};
  for (const key of str) {
    hash[key] = -~hash[key];
  }
  return Object.values(hash).every((t) => t === 1);
};

console.log(isUnique('Mozilla'));
console.log(isUnique('Firefox'));

另一种选择可能是：

var isUnique = (str) => {
  const hash = {};
  for (const i in str) {
    if (hash[str[i]]) return false;
    hash[str[i]] = true;
  }
  return true;
};

console.log(isUnique('Mozilla'));
console.log(isUnique('Firefox'));

检查字符串中的字符是否都是唯一的

10 个答案: