删除多余的字符得到字典序最小的字符串

string=input()
for i in string:
    counts = string.count(i)
    if counts>1:
        string =string.replace(i,'',counts-1)
print(string)

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

#define MAXLEN 100001

char *removeDuplicateLetter(char *str) {
    int map[26], len = (int) strlen(str);
    char *res = (char *) malloc(len + 1);
    memset(map, 0, sizeof(int) * 26);
    for (int i = 0; i < len; i++) {
        map[str[i] - 'a']++;
    }
    int l = 0, r = 0, index = 0;
    while (r < len) {
        if (map[str[r] - 'a'] == -1 ||
            --map[str[r] - 'a'] > 0) {
            r++;
            continue;
        }
        int pick = -1;
        for (int i = l; i <= r; i++) {
            if (map[str[i] - 'a'] != -1 &&
                (pick == -1 || str[i] < str[pick]))
                pick = i;
        }
        res[index++] = str[pick];
        for (int i = pick + 1; i <= r; i++) {
            if (map[str[i] - 'a'] != -1)
                map[str[i] - 'a']++;
        }
        map[str[pick] - 'a'] = -1;
        l = pick + 1;
        r = l;
    }
    res[index] = '\0';
    return res;
}

int main(void) {
    char str[MAXLEN], *res;
    scanf("%s", str);
    res = removeDuplicateLetter(str);
    printf("%s", res);
    free(res);
    return 0;
}

#获得输入的字符串
str = input()
#使用集合去重
str_set = set(str)
#sorted函数返回列表
out = sorted(str_set)
# "".join(out)列表转字符串  out.split(" ")反转
print("".join(out))

#include <bits/stdc++.h>
using namespace std;

int main(){
    string s;
    cin>>s;
    int n = s.length();
    map<char, int> mp;
    for(int i=0;i<n;i++)
        mp[s[i]]++;
    for(auto &c: mp)
        printf("%c", c.first);
    return 0;
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String  s = in.nextLine();
        System.out.println(deal(s));
    }
    public static String deal(String s) {
        int n = s.length();
        HashMap<Character, Integer> map = new HashMap<>();
        boolean[] visited = new boolean[128];
        char[] cs = s.toCharArray();
        Stack<Character> stack = new Stack<>();
        //统计数字
        for (int i = 0; i < n; i++) {
            map.put(cs[i], map.getOrDefault(cs[i], 0) + 1);
        }
        for (int i = 0; i < n; i++) {
            char c = cs[i];
            map.put(c, map.get(c) - 1);
            if (visited[c]) continue;
            //没访问过的
            while (!stack.isEmpty() && stack.peek() > c && map.get(stack.peek()) > 0) {
                visited[stack.pop()] = false;
            }
            //当前字符计进入
            stack.push(c);
            visited[c] = true;
        }
        StringBuilder sb = new StringBuilder();
        while (!stack.isEmpty()) {
            sb.insert(0, stack.pop());
        }
        return sb.toString();
    }
}

# 寻找字符串中字典序最小的字符
def getChar(string):
    string_length = len(string)
    if string_length == 0:
        return ''
    else:
        result = string[0]
        for i in range(1, string_length):
            if string[i] < result:
                result = string[i]
    return result


# 构建字符串的词频表
def getCharCount(string):
    result = {}
    for i in string:
        if i not in result.keys():
            result[i] = 1
        else:
            result[i] += 1
    return result


# 删除掉字符串中某个指定的字符
def deleteChar(string, char):
    result = ''
    for i in string:
        if i == char:
            continue
        else:
            result += i
    return str(result)


# 输入字符串
string = input()
# 获取字符串词频分布表
char_count = getCharCount(string)
char_count_length = len(char_count.keys())
result = []
while len(result) != char_count_length:
    # 当前遍历位置
    i = 0
    # 当前字符串长度
    string_length = len(string)
    # 遍历字符串
    for i in range(string_length):
        char_count[string[i]] -= 1
        # 需要进行选择的位置
        if char_count[string[i]] == 0:
            break
    # 如果当前位置是字符串最后一个位置
    if i + 1 == string_length:
        result_char = getChar(string)
        result.append(result_char)
        string = deleteChar(string, result_char)
    else:
        result_char = getChar(string[:i + 1])
        result.append(result_char)
        string = deleteChar(string[i:], result_char)

    # 重新构建词频表
    char_count = getCharCount(string)
print(''.join(result))

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
             String str=sc.nextLine();
             solve(str,"");
        }
       
        sc.close();
    }
    public static void solve(String str,String res) {
		if(str.isEmpty()) {
			System.out.println(res);
			return;
		}
		String s=str.substring(0,1);
		if(res.contains(s)) {
			String tmp=res.replace(s, "").concat(s);
			if(tmp.compareTo(res)>0) {
				str=str.replace(s, "");
			}else {
				res=tmp;
				str=str.substring(1);
			}
		}else {
			res=res.concat(s);
			str=str.substring(1);
		}
		solve(str,res);
	}
}

#data_in = input()
data_in = "cbbcbbcbcca"

def drawer(data_in):
    """用一个抽屉有序保存检测到的字母"""
    dr = [""]*26
    for i in data_in:
        index = ord(i) - ord("a")
        if not dr[index]:
            dr[index] = chr(ord("a")+index)
    print("".join(dr))

drawer(data_in)

#include<iostream>
#include<string.h>
using namespace std;
int main(){
    string str;
    while(cin>>str){
        string ans="";
        int count[26]={0};
        for(auto ch:str)
            count[ch-'a']++;
        for(int i=0;i<26;i++)
            if(count[i]>=1)
                ans+='a'+i;
        cout<<ans<<endl;
    }
}

if __name__ == '__main__':
    test_data = input()
    # test_data = 'dbcacbca'
    
    output = ''
    visual = [0, ] * 256
    record = [0, ] * 256
    
    # build record
    for vl in test_data:
        record[ord(vl)] = record[ord(vl)] + 1
        
    # filter    
    for vl in test_data:
        record[ord(vl)] = record[ord(vl)] - 1
        
        if visual[ord(vl)] == 1:
            continue
        
        while len(output) > 0 and output[-1] > vl and record[ord(output[-1])] > 0:
            visual[ord(output[-1])] = 0
            output = output[:-1]
        
        output  = output + vl
        visual[ord(vl)] = 1
        
    print(output)    

public static String RemoveDup(String s){
        if (s.length() < 2) {
            return s;
        }
        Map<Character,Integer> m = new HashMap<Character,Integer>();
        char[] chs = s.toCharArray();
        List<Integer> list = new ArrayList<Integer>();
        int tmp = -1;
        ll:
        for(int i = chs.length-1; i >= 0; i--){
            if (m.containsKey(chs[i])){
                if (chs[i] >= tmp){
                    list.add(i);
                    continue ll;
                }else{
                    list.add(m.get(chs[i]));
                    m.put(chs[i], i);
                    tmp = (int)chs[i];
                    continue ll;
                }
            }
            m.put(chs[i], i);
            tmp = chs[i];
        }
        for (Integer num : list) {
            chs[num] = '-';
        }
        String str = new String(chs);
        return str.replaceAll("-", "");
    }

#include<stdio.h>
int main(){
    int d[201]={0};
    char c;
    while(scanf("%c",&c)!=EOF){
        int k=c;
        d[k]=1;
    }
    int i;
    for(i=97;i<201;i++){
        if(d[i]!=0) printf("%c",i);
    }printf("\n");
    return 0;
}