Мне нужно сделать функцию в JavaScript, которая удаляет все повторяющиеся буквы в строке. До сих пор я мог это сделать: если у меня есть слово "анаконда", это показывает мне в результате "анаконду", когда она должна показывать "треску". Вот мой код:
function find_unique_characters( string ){
var unique='';
for(var i=0; i<string.length; i++){
if(unique.indexOf(string[i])==-1){
unique += string[i];
}
}
return unique;
}
console.log(find_unique_characters('baraban'));
Теперь мы также можем очистить вещи, используя метод фильтра:
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/
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'));Просто хотел добавить мое решение для удовольствия:
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;
}
//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
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
С lodash:
_.uniq('baraban').join(''); // returns 'barn'
У меня есть 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 или прототипом...
Еще один способ удалить все буквы, которые появляются более одного раза:
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;
}
Объяснение: вы повторяете один раз поверх всех символов в строке, сопоставляя каждый символ с количеством раз, которое оно произошло в строке. Затем вы перебираете элементы (буквы, появившиеся в строке) и выбираете только те, которые появились только один раз.
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('');
}
Этот код работал у меня при удалении повторяющихся символов из строки (даже если ее слова разделены пробелом)
Ссылка: Рабочий пример 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);
}
Здесь я использовал - не проверял его для пробелов или специальных символов, но должен работать нормально для чистых строк:
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
}
Просто наткнулся на подобную проблему (найти дубликаты). По сути, используйте хеш для отслеживания количества совпадений символов и создайте новую строку с помощью "однохвостых чудес":
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"
Попробуйте этот код, он работает:)
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"
Это должно работать с использованием 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 - он находит повторение первого совпадающего символа.
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/
У меня есть 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
Используя Set:
function removeDuplicates(str){
return [...new Set(str.split(''))].join('');
}
функция 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;
}
Если вы хотите, чтобы ваша функция просто возвращала вам уникальный набор символов в вашем аргументе, этот фрагмент кода может пригодиться. Здесь вы также можете проверить наличие неуникальных значений, которые записываются в названный массив 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'
Если вы хотите вернуть набор символов с их единовременными вхождениями в переданной строке, может пригодиться следующий фрагмент кода:
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'
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;
}
Вы можете поместить символ в качестве параметра, который хотите удалить как уникальный
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); 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;
}
Мы можем удалить дубликаты или аналогичные элементы в строке с помощью цикла 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);
}
}
}
Пожалуйста, дайте мне знать, если вы хотите получить дополнительную информацию.