Question

我想知道是否有办法在不使用双循环的情况下检查字符串中的重复字符。这可以用递归来完成吗？

使用双循环的代码示例（如果字符串中有重复的字符，则返回true或false）：

var charRepeats = function(str) {
    for(var i = 0; i <= str.length; i++) {
        for(var j = i+1; j <= str.length; j++) {
            if(str[j] == str[i]) {
                return false;
            }
        }
    }
    return true;
}

非常感谢提前！

Answer 1

（在此答案的最后可以找到递归解决方案。）

您可以使用javascript内置数组函数 some MDN some reference

 var text = "test".split("");
 text.some(function(v,i,a){
   return a.lastIndexOf(v)!=i;
 });

回调参数：
   v 迭代的当前值
   i 迭代的当前索引
   a 当前数组





.split（“”）从字符串中创建一个数组    .some（function（v，i，a）{...}）遍历数组，直到函数returns true，并且立即结束。（如果它之前找到匹配项，则不会遍历整个数组）





可以找到某些功能的详细信息here

测试，有几个字符串：

var texts = ["test", "rest", "why", "puss"];


for(var idx in texts){
    var text = texts[idx].split("");
    document.write(text + " -> " + text.some(function(v,i,a){return a.lastIndexOf(v)!=i;}) +"<br/>");
    
  }
  //tested on win7 in chrome 46+

如果需要递归。

递归更新：

//recursive function
function checkString(text,index){
    if((text.length - index)==0 ){ //stop condition
        return false; 
    }else{
        return checkString(text,index + 1) 
        || text.substr(0, index).indexOf(text[index])!=-1;
    }
}

// example Data to test
var texts = ["test", "rest", "why", "puss"];

for(var idx in texts){
    var txt = texts[idx];
    document.write( txt +  " ->" + checkString(txt,0) + "<br/>");
}
//tested on win7 in chrome 46+

Answer 2

您可以使用GT_Weekly_Run和.indexOf()来确定索引是否重复。意思是，如果第一次出现的角色也是最后一次出现，那么你知道它不会重复。如果不是，那么它会重复。

.lastIndexOf()

Answer 3

所提出的算法具有(1 + n - (1)) + (1 + n - (2)) + (1 + n - (3)) + ... + (1 + n - (n-1)) = (n-1)*(1 + n) - (n)(n-1)/2 = (n^2 + n - 2)/2的复杂度，即O（n ²）。

因此，最好使用一个对象来映射并记住字符以检查唯一性或重复。假设每个字符的最大数据大小，此过程将是O(n)算法。

function charUnique(s) {
  var r = {}, i, x;
  for (i=0; i<s.length; i++) {
    x = s[i];
    if (r[x])
      return false;
    r[x] = true;
  }
  return true;
}

在一个很小的测试用例中，该功能确实运行了几倍。

请注意，JavaScript字符串定义为16位无符号整数值的序列。 http://bclary.com/2004/11/07/#a-4.3.16

因此，我们仍然可以实现相同的基本算法，但使用更快的数组查找而不是对象查找。结果现在大约快了100倍。

var charRepeats = function(str) {
  for (var i = 0; i <= str.length; i++) {
    for (var j = i + 1; j <= str.length; j++) {
      if (str[j] == str[i]) {
        return false;
      }
    }
  }
  return true;
}

function charUnique(s) {
  var r = {},
    i, x;
  for (i = 0; i < s.length; i++) {
    x = s[i];
    if (r[x])
      return false;
    r[x] = true;
  }
  return true;
}

function charUnique2(s) {
  var r = {},
    i, x;
  for (i = s.length - 1; i > -1; i--) {
    x = s[i];
    if (r[x])
      return false;
    r[x] = true;
  }
  return true;
}

function charCodeUnique(s) {
  var r = [],
    i, x;
  for (i = s.length - 1; i > -1; i--) {
    x = s.charCodeAt(i);
    if (r[x])
      return false;
    r[x] = true;
  }
  return true;
}

function regExpWay(s) {
  return /(.).*\1/.test(s);
}


function timer(f) {
  var i;
  var t0;

  var string = [];
  for (i = 32; i < 127; i++)
    string[string.length] = String.fromCharCode(i);
  string = string.join('');
  t0 = new Date();
  for (i = 0; i < 10000; i++)
    f(string);
  return (new Date()) - t0;
}

document.write('O(n^2) = ',
  timer(charRepeats), ';<br>O(n) = ',
  timer(charUnique), ';<br>optimized O(n) = ',
  timer(charUnique2), ';<br>more optimized O(n) = ',
  timer(charCodeUnique), ';<br>regular expression way = ',
  timer(regExpWay));

Answer 4

这样做：

function isIsogram (str) {
    return !/(.).*\1/.test(str);
}

Answer 5

function chkRepeat(word) {
    var wordLower = word.toLowerCase();
    var wordSet = new Set(wordLower);
    var lenWord = wordLower.length;
    var lenWordSet =wordSet.size;

    if (lenWord === lenWordSet) {
        return "false"
    } else {
        return'true'
    }
}

Answer 6

使用lodash的另一种方法

var _ = require("lodash");
var inputString = "HelLoo world!"
var checkRepeatition = function(inputString) {
  let unique = _.uniq(inputString).join('');
  if(inputString.length !== unique.length) {
    return true; //duplicate characters present!
  }
  return false;
};
console.log(checkRepeatition(inputString.toLowerCase()));

Answer 7

您可以使用“设置对象”！

Set对象使您可以存储任何类型的唯一值，无论是否基本值或对象引用。它具有一些添加或检查对象中是否存在属性的方法。

Read more about Sets at MDN

这是我的用法：

 function isIsogram(str){
  let obj = new Set();

  for(let i = 0; i < str.length; i++){
    if(obj.has(str[i])){
      return false
    }else{
      obj.add(str[i])
    }
  }
  return true
}

isIsogram("Dermatoglyphics") // true
isIsogram("aba")// false

Answer 8

使用正则表达式解决=>

function isIsogram(str){
  return !/(\w).*\1/i.test(str);
}

console.log(isIsogram("isogram"), true );
console.log(isIsogram("aba"), false, "same chars may not be adjacent" );
console.log(isIsogram("moOse"), false, "same chars may not be same case" );
console.log(isIsogram("isIsogram"), false );
console.log(isIsogram(""), true, "an empty string is a valid isogram" );

Answer 9

 const str = "afewreociwddwjej";
  const repeatedChar=(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;
}
console.log(...repeatedChar(str));

也可以用下面的代码查找字符串中重复的字符

Answer 10

//Finds character which are repeating in a string
var sample = "success";
function repeatFinder(str) {
    let repeat="";
    for (let i = 0; i < str.length; i++) {
        for (let j = i + 1; j < str.length; j++) {
            if (str.charAt(i) == str.charAt(j) && repeat.indexOf(str.charAt(j)) == -1) {
                repeat += str.charAt(i);
            }
        }
    }
    return repeat;
}
console.log(repeatFinder(sample)); //output: sc

检查字符串Javascript中的重复字符

10 个答案: