Удаление повторяющихся символов из строки

Ответ 1

Теперь мы также можем очистить вещи, используя метод фильтра:

function removeDuplicateCharacters(string) {
  return string
    .split('')
    .filter(function(item, pos, self) {
      return self.indexOf(item) == pos;
    })
    .join('');
}
console.log(removeDuplicateCharacters('baraban'));

Рабочий пример: https://jsfiddle.net/masterspambot/ppz6uec1/

Ответ 2

function find_unique_characters(str) {
  var unique = '';
  for (var i = 0; i < str.length; i++) {
    if (str.lastIndexOf(str[i]) == str.indexOf(str[i])) {
      unique += str[i];
    }
  }
  return unique;
}

console.log(find_unique_characters('baraban'));
console.log(find_unique_characters('anaconda'));

Ответ 3

Просто хотел добавить мое решение для удовольствия:

function removeDoubles(string) {
  var mapping = {};
  var newString = '';

  for (var i = 0; i < string.length; i++) {
    if (!(string[i] in mapping)) {
      newString += string[i];
      mapping[string[i]] = true;
    }
  }
  return newString;
}

Ответ 4

  //One simple way to remove redundecy of Char in String
       var char = "aaavsvvssff"; //Input string
       var rst=char.charAt(0);
       for(var i=1;i<char.length;i++){              
           var isExist = rst.search(char.charAt(i));
            isExist >=0 ?0:(rst +=  char.charAt(i) ); 
       }
       console.log(JSON.stringify(rst)); //output string : avsf

Ответ 5

DEMO

function find_unique_characters( string ){
    unique=[];
    while(string.length>0){
        var char = string.charAt(0);
        var re = new RegExp(char,"g");
        if (string.match(re).length===1) unique.push(char);
        string=string.replace(re,"");
    }        
    return unique.join("");
}
console.log(find_unique_characters('baraban')); // rn
console.log(find_unique_characters('anaconda')); //cod
​

Ответ 6

С lodash:

_.uniq('baraban').join(''); // returns 'barn'

Ответ 7

У меня есть FF/Chrome, на котором это работает:

var h={}; 
"anaconda".split("").
  map(function(c){h[c] |= 0; h[c]++; return c}).
  filter(function(c){return h[c] == 1}).
  join("")

Что вы можете использовать повторно, если вы пишете такую ​​функцию, как:

function nonRepeaters(s) {
  var h={}; 
  return s.split("").
    map(function(c){h[c] |= 0; h[c]++; return c}).
    filter(function(c){return h[c] == 1}).
    join("");
 }

Для старых браузеров, которым не хватает map, filter и т.д., я предполагаю, что он может быть эмулирован jQuery или прототипом...

Ответ 8

Еще один способ удалить все буквы, которые появляются более одного раза:

function find_unique_characters( string ) {
    var mapping = {};
    for(var i = 0; i < string.length; i++) {
        var letter = string[i].toString();
        mapping[letter] = mapping[letter] + 1 || 1;
    }
    var unique = '';
    for (var letter in mapping) {
        if (mapping[letter] === 1)
            unique += letter;
    }

    return unique;
}

Живой тест.

Объяснение: вы повторяете один раз поверх всех символов в строке, сопоставляя каждый символ с количеством раз, которое оно произошло в строке. Затем вы перебираете элементы (буквы, появившиеся в строке) и выбираете только те, которые появились только один раз.

Ответ 9

function removeDup(str) {
  var arOut = [];
  for (var i=0; i < str.length; i++) {
    var c = str.charAt(i);
    if (c === '_') continue;
    if (str.indexOf(c, i+1) === -1) {
      arOut.push(c);
    }
    else {
      var rx = new RegExp(c, "g");
      str = str.replace(rx, '_');
    }
  }
  return arOut.join('');
}

Ответ 10

Этот код работал у меня при удалении повторяющихся символов из строки (даже если ее слова разделены пробелом)

Ссылка: Рабочий пример JSFiddle

/* This assumes you have trim the string and checked if it empty */
function RemoveDuplicateChars(str) {
   var curr_index = 0;
   var curr_char;
   var strSplit;
   var found_first;
   while (curr_char != '') {
      curr_char = str.charAt(curr_index);
      /* Ignore spaces */
      if (curr_char == ' ') {
         curr_index++;
         continue;
      }
      strSplit = str.split('');
      found_first = false;
      for (var i=0;i<strSplit.length;i++) {
         if(str.charAt(i) == curr_char && !found_first) 
            found_first = true;
         else if (str.charAt(i) == curr_char && found_first) {
            /* Remove it from the string */
            str = setCharAt(str,i,'');
         }
      }
      curr_index++;
   }
   return str;
}
function setCharAt(str,index,chr) {
    if(index > str.length-1) return str;
    return str.substr(0,index) + chr + str.substr(index+1);
}

Ответ 11

Здесь я использовал - не проверял его для пробелов или специальных символов, но должен работать нормально для чистых строк:

function uniquereduce(instring){ 
    outstring = ''
    instringarray = instring.split('')
    used = {}
    for (var i = 0; i < instringarray.length; i++) {
        if(!used[instringarray[i]]){
            used[instringarray[i]] = true
            outstring += instringarray[i]
        }
    }
    return outstring
}

Ответ 12

Просто наткнулся на подобную проблему (найти дубликаты). По сути, используйте хеш для отслеживания количества совпадений символов и создайте новую строку с помощью "однохвостых чудес":

function oneHitWonders(input) {
    var a = input.split('');
    var l = a.length;
    var i = 0;
    var h = {};
    var r = "";

    while (i < l) {
        h[a[i]] = (h[a[i]] || 0) + 1;

        i += 1;
    }

    for (var c in h) {
        if (h[c] === 1) {
            r += c;
        }
    }

    return r;
}

Использование

var a = "anaconda";
var b = oneHitWonders(a); // b === "cod"

Ответ 13

Попробуйте этот код, он работает:)

var str="anaconda";
Array.prototype.map.call(str, 
 (obj,i)=>{
  if(str.indexOf(obj,i+1)==-1 && str.lastIndexOf(obj,i-1)==-1){
   return obj;
  }
 }
).join("");
//output: "cod"

Ответ 14

Это должно работать с использованием Regex;
ПРИМЕЧАНИЕ. На самом деле, я не знаю, как работает это регулярное выражение, но я знал его "стенографию", поэтому я бы лучше объяснил вам смысл этого /(.+)(?=.*?\1)/g;. это регулярное выражение возвращает мне только дублированный символ в массиве, поэтому я зациклился на нем, чтобы получить длину повторяющихся символов. Но это не работает для специальных символов, таких как "#" "_" "-",, но это дает вам ожидаемый результат; включая специальные символы if any

function removeDuplicates(str){
    var REPEATED_CHARS_REGEX = /(.+)(?=.*?\1)/g;
    var  res = str.match(REPEATED_CHARS_REGEX);
    var word = res.slice(0,1);
    var raw = res.slice(1);
    var together = new String (word+raw);
    var fer = together.toString();
    var length = fer.length;
    // my sorted duplicate;
      var result = '';
      for(var i = 0; i < str.length; i++) {
        if(result.indexOf(str[i]) < 0) {
          result += str[i];
        }
      }

      return {uniques: result,duplicates: length};
    } removeDuplicates('anaconda')

Регулярное выражение /([a-zA-Z])\1+$/ ищет:

([a-zA-Z]]) - письмо, которое оно фиксирует в первой группе; тогда \1+ - сразу после него одна или несколько копий этого письма; тогда $ - конец строки. Вместо этого вместо /([a-zA-Z]).*?\1/ выполняется поиск:

([a-zA-Z]) - письмо, которое оно фиксирует в первой группе; тогда .*? - ноль или более символов (символ "обозначает как можно меньше" ); до \1 - он находит повторение первого совпадающего символа.

Ответ 15

var str = 'anaconda'.split('');
var rmDup = str.filter(function(val, i, str){
     return str.lastIndexOf(val) === str.indexOf(val);
});
console.log(rmDup); //prints ["c", "o", "d"]

Пожалуйста, проверьте здесь: https://jsfiddle.net/jmgy8eg9/1/

Ответ 16

У меня есть 3 петлевых, однострочных подходов к этому.

Подход 1 - удаляет дубликаты и сохраняет исходный порядок символов:

var str = "anaconda";
var newstr = str.replace(new RegExp("[^"+str.split("").sort().join("").replace(/(.)\1+/g, "").replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&")+"]","g"),"");
//cod

Подход 2 - удаляет дубликаты, но НЕ сохраняет порядок символов, но может быть быстрее, чем Подход 1, потому что он использует меньше регулярных выражений:

var str = "anaconda";
var newstr = str.split("").sort().join("").replace(/(.)\1+/g, "");
//cdo

Подход 3 - удаляет дубликаты, но сохраняет уникальные значения (также не сохраняет порядок символов):

var str = "anaconda";
var newstr = str.split("").sort().join("").replace(/(.)(?=.*\1)/g, "");
//acdno

Ответ 17

Используя Set:

function removeDuplicates(str){
  return [...new Set(str.split(''))].join('');
}

Ответ 18

функция removeduplicate (str) {

let map = new Map();
// n 
for (let i = 0; i < str.length; i++) {
    if (map.has(str[i])) {
        map.set(str[i], map.get(str[i]) + 1);
    } else {
        map.set(str[i], 1);
    }

}


let res = '';

for (let i = 0; i < str.length; i++) {
    if (map.get(str[i]) === 1) {
        res += str[i];
    }
}

// o (2n) - > O(n)

// space o(n)

return res;

}

Ответ 19

1. Если вы хотите, чтобы ваша функция просто возвращала вам уникальный набор символов в вашем аргументе, этот фрагмент кода может пригодиться. Здесь вы также можете проверить наличие неуникальных значений, которые записываются в названный массив nonUnique:

   function remDups(str){
       if(!str.length)
           return '';
       var obj = {};
       var unique = [];
       var notUnique = [];
       for(var i = 0; i < str.length; i++){
           obj[str[i]] = (obj[str[i]] || 0) + 1;
       }
       Object.keys(obj).filter(function(el,ind){
           if(obj[el] === 1){
               unique+=el;
           }
           else if(obj[el] > 1){
               notUnique+=el;
           }
       });
   return unique;
   }
   console.log(remDups('anaconda')); //prints 'cod'
   

2. Если вы хотите вернуть набор символов с их единовременными вхождениями в переданной строке, может пригодиться следующий фрагмент кода:

   function remDups(str){
       if(!str.length)
           return '';
       var s = str.split('');
       var obj = {};
       for(var i = 0; i < s.length; i++){
           obj[s[i]] = (obj[s[i]] || 0) + 1;
       }
       return Object.keys(obj).join('');
   }
   console.log(remDups('anaconda')); //prints 'ancod'
   

Ответ 20

    function removeDuplicates(str) {
       var result = "";
       var freq = {};
       for(i=0;i<str.length;i++){
        let char = str[i];
        if(freq[char]) {
          freq[char]++;     
        } else {
           freq[char] =1
           result +=char;
       }
    }
  return result;
}

Ответ 21

Вы можете поместить символ в качестве параметра, который хотите удалить как уникальный

function find_unique_characters(str, char){
  return [...new Set(str.split(char))].join(char);
}

function find_unique_characters(str, char){
  return [...new Set(str.split(char))].join(char);
}

let result = find_unique_characters("aaaha ok yet?", "a");
console.log(result);

Ответ 22

    function RemDuplchar(str)
{
    var index={},uniq='',i=0;
    while(i<str.length)
    {
        if (!index[str[i]])
        {
         index[str[i]]=true;
         uniq=uniq+str[i];
        }
            i++;
    }
    return uniq;
} 

Ответ 23

Мы можем удалить дубликаты или аналогичные элементы в строке с помощью цикла for и извлечь строковые методы, такие как slice, substring, substr

Пример, если вы хотите удалить повторяющиеся элементы, такие как aababbafabbb:

var data = document.getElementById("id").value
for(var i = 0; i < data.length; i++)
{
    for(var j = i + 1; j < data.length; j++)
    {
        if(data.charAt(i)==data.charAt(j))
        {
            data = data.substring(0, j) + data.substring(j + 1);
            j = j - 1;
            console.log(data);
        }
    }
}

Пожалуйста, дайте мне знать, если вы хотите получить дополнительную информацию.