在Python中删除字符串中的重复项

删除字符串中所有重复项的有效算法是什么

例如：aaaabbbccdbdbcd

---

所需结果：abcd

使用哈希表存储当前发现的密钥（访问O（1）），然后在数组中循环。如果哈希表中有字符，则丢弃它。如果不是，则将其添加到哈希表和结果字符串中

总体：O（n）时间（和空间）

最简单的解决方案是在处理每个字符串时搜索结果字符串中的字符。O（n2）

保留一个256个“可见”布尔值的数组，每个可能的字符对应一个。 流你的字符串。如果您以前没有见过该角色，请输出它并为该角色设置“已看到”标志

  string newString = new string("aaaaabbbbccccdddddd".ToCharArray().Distinct().ToArray());   

或

char[]characters=“aaaabbbccddd”.ToCharArray（）；
字符串结果=string.Empty；
foreach（字符c）
{
if（结果索引f（c）<0）
结果+=c.ToString（）；
}

在Python中

>>> ''.join(set("aaaabbbccdbdbcd"))
'acbd'

如果需要保留订单

>>> q="aaaabbbccdbdbcd"                    # this one is not
>>> ''.join(sorted(set(q),key=q.index))    # so efficient
'abcd'

或

或

在python3.1中

>>> from collections import OrderedDict
>>> ''.join(list(OrderedDict((c,0) for c in "aaaabbbccdbdbcd").keys()))
'abcd'

---

这与以下问题密切相关：

根据您的输入，哈希表方法可能不是最优的哈希表有一定的开销（存储桶、条目对象）。与实际存储的字符相比，这是巨大的开销。（如果您的目标环境是Java，则情况更糟，因为HashMap的类型为

Map

）由于冲突，Hashtable访问的最糟运行时为O（n）

---

您只需8kb即可表示普通位集中的所有2字节unicode字符。如果您的输入字符集受到更严格的限制，或者使用压缩位集（只要您有稀疏位集），则可以对其进行优化。当位集为O（1）时，运行时性能将有利于位集 STD:：SET：

std::string input("aaaabbbccddd");
std::set<char> unique_chars(input.begin(), input.end());

std:：字符串输入（“aaaabbbccddd”）；
设置唯一字符（input.begin（），input.end（））；

---

理论上，您可以使用

std:：unordered_set

而不是

std:：set

，这将给出O（N）预期的总体复杂度（尽管O（N2）最坏情况），其中这一个是O（N lgm）（其中N=总字符数，M=唯一字符数）。除非您有包含许多唯一字符的长字符串，否则此版本可能会更快。

您可以对字符串进行排序，然后删除重复字符

#include <iostream>
#include <algorithm>
#include <string>

int main()
{
    std::string s = "aaaabbbccdbdbcd";

    std::sort(s.begin(), s.end());
    s.erase(std::unique(s.begin(), s.end()), s.end());

    std::cout << s << std::endl;
}

#包括
#包括
#包括
int main（）
{
std:：string s=“aaaabbbccdbdbcd”；
std:：sort（s.begin（），s.end（））；
s、 擦除（std:：unique（s.begin（）、s.end（）、s.end（））；
std：：cout这听起来像是对自动机的完美使用。
C++-O（n）时间，O（1）空间，输出被排序

std::string characters = "aaaabbbccddd";
std::vector<bool> seen(std::numeric_limits<char>::max()-std::numeric_limits<char>::min());

for(std::string::iterator it = characters.begin(), endIt = characters.end(); it != endIt; ++it) {
  seen[(*it)-std::numeric_limits<char>::min()] = true;
}

characters = "";
for(char ch = std::numeric_limits<char>::min(); ch != std::numeric_limits<char>::max(); ++ch) {
  if( seen[ch-std::numeric_limits<char>::min()] ) {
    characters += ch;
  }
}

std:：string characters=“aaaabbbccddd”；
std:：vector seen（std:：numeric_limits:：max（）-std:：numeric_limits:：min（））；
对于（std:：string:：iterator it=characters.begin（），endIt=characters.end（）；it！=endIt；++it）{
看到[（*it）-std:：numeric_limits:：min（）]=true；
}
字符=”；
对于（char ch=std:：numeric_limits:：min（）；ch！=std:：numeric_limits:：max（）；++ch）{
如果（参见[ch std:：numeric_limits:：min（）]）{
字符+=ch；
}
}
在C中，我就是这样做的：O（n）及时，因为我们只有一个for循环

void remDup(char *str)
{
    int flags[256] = { 0 };

    for(int i=0; i<(int)strlen(str); i++) {
        if( flags[str[i]] == 0 )
            printf("%c", str[i]);

        flags[str[i]] = 1;
    }
}

void remDup（char*str）
{
int标志[256]={0}；
对于（int i=0；iPHP算法-O（n）：

函数删除重复字符（$str）{
如果（2>$len=strlen（$str））{
返回$str；
}
$flags=数组填充（0256，false）；
$flags[ord（$str[0]）]=true；
$j=1；
对于（$i=1；$i
import java.util.HashSet；
移除公共类{
公共静态字符串重复（）
{
HashSet h=新的HashSet（）；
字符串值=新字符串（“aaaabbbccdbdbcd”）；
字符串finalString=新字符串（）；
int stringLength=value.length（）；
对于（int i=0；i获取前26个素数的列表。。
现在您可以将每个字符（a、b、c、d等）映射到每个素数..（按字母顺序排列，如a=2、b=3、c=5等..或者根据字符的相对丰度，如最常用的低素数字母，如e=2、r=3、a=5等..）将该映射存储在整数数组中
整数素数[26]

遍历字符串的所有字符

i=0;
int product = 1;
while(char[i] != null){
   if(product % prime[i] == 0)
      the character is already present delete it
   else
      product = product*prime[i];
}

该算法将在O（n）时间内工作，并且需要O（1）空间
当字符串中的不同字符数较少时，它将很好地工作……其他明智的产品将超过“int”范围，我们必须正确处理这种情况
#include <iostream>
#include<string>
using namespace std;
#define MAX_SIZE 256

int main()
{
    bool arr[MAX_SIZE] = {false};

    string s;
    cin>>s;
    int k = 0;

    for(int i = 0; i < s.length(); i++)
    {
        while(arr[s[i]] == true && i < s.length())
        {
            i++;
        }
        if(i < s.length())
        {
            s[k]    = s[i];
            arr[s[k]] = true;
            k++;
        }
    }
    s.resize(k);

    cout << s<< endl; 

    return 0;
}

#包括
使用名称空间std；
#定义最大尺寸256
int main（）
{
bool arr[MAX_SIZE]={false}；
字符串s；
cin>>s；
int k=0；
对于（int i=0；i
void removeDuplicates（char*str）
{
int len=strlen（str）；//获取字符串的长度
int count[256]={0}；//将所有元素初始化为零
int i；
对于（i=0；i
int main（）
{    
std:：string s=“aaacabbccdbdbcd”；
std：：set set1；
set1.插入（s.begin（），s.end（））；
for（set:：iterator it=set1.begin（）；it！=set1.end（）；++it）
标准：：coutO（n）溶液：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void removeDuplicates(char *);

void removeDuplicates(char *inp)
{
        int i=0, j=0, FLAG=0, repeat=0;

     while(inp[i]!='\0')
    {
        if(FLAG==1)
        {
                inp[i-repeat]=inp[i];
        }
        if(j==(j | 1<<(inp[i]-'\0')))
        {
                repeat++;
                FLAG=1;
        }
                j= j | 1<<(inp[i]-'\0');
                i++;
    }

     inp[i-repeat]='\0';
}

int main()
{
     char inp[100] = "aaAABCCDdefgccc";
    //char inp[100] = "ccccc";
    //char inp[100] = "\0";
    //char *inp = (char *)malloc(sizeof(char)*100);

    printf (" INPUT STRING : %s\n", inp);

     removeDuplicates(inp);

    printf (" OUTPUT STRING : %s:\n", inp);
    return 1;
}

#包括
#包括
#包括
移除的无效副本（字符*）；
已删除无效副本（字符*inp）
{
int i=0，j=0，FLAG=0，repeat=0；
while（inp[i]！='\0'）
{
如果（标志==1）
{
inp[i-重复]=inp[i]；
}
如果（j==（j | 1可能是使用内置Python函数
import java.util.HashSet;

public class RemoveDup {

    public static String Duplicate()
    {
        HashSet h = new HashSet();
        String value = new String("aaaabbbccdbdbcd");
        String finalString = new String();
        int stringLength = value.length();
        for (int i=0;i<=stringLength-1;i++)
        {
            if(h.add(value.charAt(i)))
            {
                finalString = finalString + (value.charAt(i));
            }


        }
        return finalString;

    }
public static void main(String[] args) {


        System.out.println(Duplicate());
    }
}

i=0;
int product = 1;
while(char[i] != null){
   if(product % prime[i] == 0)
      the character is already present delete it
   else
      product = product*prime[i];
}

#include <iostream>
#include<string>
using namespace std;
#define MAX_SIZE 256

int main()
{
    bool arr[MAX_SIZE] = {false};

    string s;
    cin>>s;
    int k = 0;

    for(int i = 0; i < s.length(); i++)
    {
        while(arr[s[i]] == true && i < s.length())
        {
            i++;
        }
        if(i < s.length())
        {
            s[k]    = s[i];
            arr[s[k]] = true;
            k++;
        }
    }
    s.resize(k);

    cout << s<< endl; 

    return 0;
}

void removeDuplicates(char *str)
{
 int len = strlen(str); //Gets the length of the String
 int count[256] = {0};  //initializes all elements as zero
 int i;
     for(i=0;i<len;i++)
     {
        count[str[i]]++;  
        if(count[str[i]] == 1)
          printf("%c",str[i]);                  
     }     
}

int main()    
{    
    std::string s = "aaacabbbccdbdbcd";

    std::set<char> set1;
    set1.insert(s.begin(), s.end());

    for(set<char>::iterator it = set1.begin(); it!= set1.end(); ++it)
    std::cout << *it;

    return 0;
}

std::set takes O(log n) to insert 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void removeDuplicates(char *);

void removeDuplicates(char *inp)
{
        int i=0, j=0, FLAG=0, repeat=0;

     while(inp[i]!='\0')
    {
        if(FLAG==1)
        {
                inp[i-repeat]=inp[i];
        }
        if(j==(j | 1<<(inp[i]-'\0')))
        {
                repeat++;
                FLAG=1;
        }
                j= j | 1<<(inp[i]-'\0');
                i++;
    }

     inp[i-repeat]='\0';
}

int main()
{
     char inp[100] = "aaAABCCDdefgccc";
    //char inp[100] = "ccccc";
    //char inp[100] = "\0";
    //char *inp = (char *)malloc(sizeof(char)*100);

    printf (" INPUT STRING : %s\n", inp);

     removeDuplicates(inp);

    printf (" OUTPUT STRING : %s:\n", inp);
    return 1;
}

string = "aaabbbccc"

product = reduce((lambda x,y: x if (y in x) else x+y), string)

print product

abc

string = "aaabssabcdsdwa"

str_uniq = ''.join(set(string))

print str_uniq

acbdsw

# by using python
def cleantext(word):
    if(len(word)==1):

        return word
    if word[0]==word[1]:

        return cleantext(word[1:])

return word[0]+ cleantext(word[1:])
print(cleantext(word))