Supprimer les doublons d'une chaîne en Java
J'essaie de parcourir une chaîne afin de supprimer les caractères en double.
Par exemple, String aabbccdef devrait devenir abcdef.__ et String abcdabcd devrait devenir abcd
Voici ce que j'ai jusqu'à présent:
public class test {
public static void main(String[] args) {
String input = new String("abbc");
String output = new String();
for (int i = 0; i < input.length(); i++) {
for (int j = 0; j < output.length(); j++) {
if (input.charAt(i) != output.charAt(j)) {
output = output + input.charAt(i);
}
}
}
System.out.println(output);
}
}
Quelle est la meilleure façon de procéder?
Convertissez la chaîne en un tableau de caractères et stockez-la dans une LinkedHashSet. Cela préservera votre commande et supprimera les doublons. Quelque chose comme:
String string = "aabbccdefatafaz";
char[] chars = string.toCharArray();
Set<Character> charSet = new LinkedHashSet<Character>();
for (char c : chars) {
charSet.add(c);
}
StringBuilder sb = new StringBuilder();
for (Character character : charSet) {
sb.append(character);
}
System.out.println(sb.toString());
Je voudrais utiliser l'aide de LinkedHashSet . Supprime les doublons (comme nous utilisons un ensemble, conserve l'ordre dans la mesure où nous utilisons une liste liée impl). C'est une sorte de solution sale. il pourrait même y avoir un meilleur moyen.
String s="aabbccdef";
Set<Character> set=new LinkedHashSet<Character>();
for(char c:s.toCharArray())
{
set.add(Character.valueOf(c));
}
Essayez cette solution simple:
public String removeDuplicates(String input){
String result = "";
for (int i = 0; i < input.length(); i++) {
if(!result.contains(String.valueOf(input.charAt(i)))) {
result += String.valueOf(input.charAt(i));
}
}
return result;
}
Utiliser Stream facilite les choses.
import Java.util.Arrays;
import Java.util.stream.Collectors;
public class MyClass {
public static String removeDuplicates(String myString) {
return Arrays.asList(myString.split(""))
.stream()
.distinct()
.collect(Collectors.joining());
}
}
Voici une documentation supplémentaire sur Stream et tout ce que vous pouvez faire avec il : https://docs.Oracle.com/javase/8/docs/api/Java/util/stream/package-summary.html
La partie "description" est très instructive sur les avantages de Streams.
Créez un StringWriter. Parcourez la chaîne d'origine en utilisant charAt (i) dans une boucle for. Conservez une variable de type char en conservant la dernière valeur charAt. Si vous effectuez une itération et que la valeur de charAt est égale à celle stockée dans cette variable, n'ajoutez pas à StringWriter. Enfin, utilisez la méthode StringWriter.toString () pour obtenir une chaîne et faites ce dont vous avez besoin.
public class RemoveRepeated4rmString {
public static void main(String[] args) {
String s = "harikrishna";
String s2 = "";
for (int i = 0; i < s.length(); i++) {
Boolean found = false;
for (int j = 0; j < s2.length(); j++) {
if (s.charAt(i) == s2.charAt(j)) {
found = true;
break; //don't need to iterate further
}
}
if (found == false) {
s2 = s2.concat(String.valueOf(s.charAt(i)));
}
}
System.out.println(s2);
}
}
Je pense que travailler de cette façon serait plus facile , Passez simplement une chaîne à cette fonction et le travail est terminé :).
private static void removeduplicate(String name)
{ char[] arr = name.toCharArray();
StringBuffer modified =new StringBuffer();
for(char a:arr)
{
if(!modified.contains(Character.toString(a)))
{
modified=modified.append(Character.toString(a)) ;
}
}
System.out.println(modified);
}
Voici une amélioration de la réponse de Dave .
Il utilise HashSet au lieu de LinkedHashSet un peu plus coûteux et réutilise le tampon chars pour le résultat, éliminant ainsi le besoin de StringBuilder.
String string = "aabbccdefatafaz";
char[] chars = string.toCharArray();
Set<Character> present = new HashSet<>();
int len = 0;
for (char c : chars)
if (present.add(c))
chars[len++] = c;
System.out.println(new String(chars, 0, len)); // abcdeftz
Pour moi, il semble que tout le monde essaie beaucoup trop pour accomplir cette tâche. Tout ce qui nous préoccupe, c’est qu’il copie 1 copie de chaque lettre si elle se répète. Ensuite, parce que nous ne nous inquiétons que si ces caractères se répètent les uns après les autres, les boucles imbriquées deviennent arbitraires, vous pouvez simplement comparer la position n à la position n + 1. Ensuite, parce que cela ne copie que les choses quand elles sont différentes, à résoudre pour la dernier caractère, vous pouvez soit ajouter un espace à la fin de la chaîne d'origine, soit simplement le faire copier le dernier caractère de la chaîne dans votre résultat.
String removeDuplicate (String s) {
String result = "";
for (int i = 0; i < s.length(); i++){
if (i + 1 < s.length() && s.charAt(i) != s.charAt(i+1)){
result = result + s.charAt(i);
}
if (i + 1 == s.length()){
result = result + s.charAt(i);
}
}
return result;
}
Code pour supprimer les caractères en double dans une chaîne sans utiliser de tampon supplémentaire. REMARQUE: Une ou deux variables supplémentaires suffisent. Un tableau supplémentaire n'est pas:
import Java.util.*;
public class Main{
public static char[] removeDupes(char[] arr){
if (arr == null || arr.length < 2)
return arr;
int len = arr.length;
int tail = 1;
for(int x = 1; x < len; x++){
int y;
for(y = 0; y < tail; y++){
if (arr[x] == arr[y]) break;
}
if (y == tail){
arr[tail] = arr[x];
tail++;
}
}
return Arrays.copyOfRange(arr, 0, tail);
}
public static char[] bigArr(int len){
char[] arr = new char[len];
Random r = new Random();
String alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()-=_+[]{}|;:',.<>/?`~";
for(int x = 0; x < len; x++){
arr[x] = alphabet.charAt(r.nextInt(alphabet.length()));
}
return arr;
}
public static void main(String args[]){
String result = new String(removeDupes(new char[]{'a', 'b', 'c', 'd', 'a'}));
assert "abcd".equals(result) : "abcda should return abcd but it returns: " + result;
result = new String(removeDupes(new char[]{'a', 'a', 'a', 'a'}));
assert "a".equals(result) : "aaaa should return a but it returns: " + result;
result = new String(removeDupes(new char[]{'a', 'b', 'c', 'a'}));
assert "abc".equals(result) : "abca should return abc but it returns: " + result;
result = new String(removeDupes(new char[]{'a', 'a', 'b', 'b'}));
assert "ab".equals(result) : "aabb should return ab but it returns: " + result;
result = new String(removeDupes(new char[]{'a'}));
assert "a".equals(result) : "a should return a but it returns: " + result;
result = new String(removeDupes(new char[]{'a', 'b', 'b', 'a'}));
assert "ab".equals(result) : "abba should return ab but it returns: " + result;
char[] arr = bigArr(5000000);
long startTime = System.nanoTime();
System.out.println("2: " + new String(removeDupes(arr)));
long endTime = System.nanoTime();
long duration = (endTime - startTime);
System.out.println("Program took: " + duration + " nanoseconds");
System.out.println("Program took: " + duration/1000000000 + " seconds");
}
}
Comment lire et parler du code ci-dessus:
- La méthode appelée removeDupes prend un tableau de caractères primitif appelé arr.
- arr est renvoyé sous la forme d'un tableau de caractères primitifs "par valeur". L'arr qui est passé est une ordure collectée à la fin de la méthode membre de Main, removeDupes.
- La complexité d'exécution de cet algorithme est O(n) ou plus précisément O (n + (petite constante)), la constante étant les caractères uniques dans l'ensemble du tableau de caractères primitifs.
- CopyOfRange n'augmente pas la complexité de l'exécution de manière significative car il ne copie qu'un petit nombre constant d'éléments. Le tableau de caractères appelé arr n'est pas détaillé.
- Si vous transmettez null dans removeDupes, la méthode renvoie null.
- Si vous transmettez un tableau vide de caractères primitifs ou un tableau contenant une valeur, ce tableau non modifié est renvoyé.
- La méthode removeDupes est aussi rapide que physiquement possible, en utilisant pleinement les caches L1 et L2, donc les redirections de branche sont réduites au minimum .
- Un ordinateur non chargé de version standard 2015 devrait pouvoir compléter cette méthode avec un tableau de caractères primitif contenant 500 millions de caractères entre 15 et 25 secondes.
Expliquez comment ce code fonctionne:
La première partie du tableau transmis est utilisée comme référentiel pour les caractères uniques qui sont finalement renvoyés. Au début de la fonction, la réponse est: "les caractères compris entre 0 et 1", entre 0 et la fin.
Nous définissons la variable y en dehors de la boucle car nous voulons trouver le premier emplacement où l'index de tableau que nous examinons a été dupliqué dans notre référentiel. Lorsqu'un doublon est trouvé, il se déclenche et se ferme, la queue y == renvoie false et le référentiel n'est pas alimenté.
lorsque l'index x que nous regardons n'est pas représenté dans notre référentiel, nous extrayons celui-ci et l'ajoutons à la fin de notre référentiel à la fin de l'index et à la fin de l'incrément.
A la fin, nous renvoyons le tableau entre les points 0 et tail, qui devrait être plus petit ou égal à la longueur du tableau d'origine.
Exercice de points de discussion pour les entretiens avec les codeurs:
Le programme se comportera-t-il différemment si vous modifiez le y ++ en ++ y? Pourquoi ou pourquoi pas.
Est-ce que la copie du tableau à la fin représente un autre 'N' passant par tout le tableau, ce qui rend la complexité d'exécution O (n * n) au lieu de O(n)? Pourquoi ou pourquoi pas.
Pouvez-vous remplacer les doubles égaux comparant les caractères primitifs avec un .equals? Pourquoi ou pourquoi pas?
Cette méthode peut-elle être modifiée pour effectuer les remplacements "par référence" au lieu de "tels qu'ils sont maintenant", "par valeur"? Pourquoi ou pourquoi pas?
Pouvez-vous augmenter l'efficacité de cet algorithme en triant le référentiel de valeurs uniques au début de 'arr'? Dans quelles circonstances serait-il plus efficace?
String input = "AAAB";
String output = "";
for (int index = 0; index < input.length(); index++) {
if (input.charAt(index % input.length()) != input
.charAt((index + 1) % input.length())) {
output += input.charAt(index);
}
}
System.out.println(output);
mais vous ne pouvez pas l'utiliser si l'entrée contient les mêmes éléments ou si elle est vide!
StringBuilder builderWord = new StringBuilder(Word);
for(int index=0; index < builderWord.length(); index++) {
for(int reverseIndex=builderWord.length()-1; reverseIndex > index;reverseIndex--) {
if (builderWord.charAt(reverseIndex) == builderWord.charAt(index)) {
builderWord.deleteCharAt(reverseIndex);
}
}
}
return builderWord.toString();
La solution simple consiste à parcourir la chaîne donnée et à placer chaque caractère unique dans une autre chaîne (dans ce cas, une variable résultat) si cette chaîne ne contient pas ce caractère particulier. Retourne finalement résultat chaîne en sortie.
L'extrait de code ci-dessous, en cours de fonctionnement et testé, permet de supprimer les caractères en double de la chaîne donnée dont la complexité temporelle est O(n).
private static String removeDuplicate(String s) {
String result="";
for (int i=0 ;i<s.length();i++) {
char ch = s.charAt(i);
if (!result.contains(""+ch)) {
result+=""+ch;
}
}
return result;
}
Si l'entrée est madame alors le résultat sera mad.
Si l'entrée est anagramme alors la sortie sera angrm _
J'espère que cela t'aides.
Merci
public static void main(String[] args) {
int i,j;
StringBuffer str=new StringBuffer();
Scanner in = new Scanner(System.in);
System.out.print("Enter string: ");
str.append(in.nextLine());
for (i=0;i<str.length()-1;i++)
{
for (j=1;j<str.length();j++)
{
if (str.charAt(i)==str.charAt(j))
str.deleteCharAt(j);
}
}
System.out.println("Removed String: " + str);
}
package com.core.interview.client;
importer Java.util.LinkedHashSet;
importer Java.util.Scanner;
importer Java.util.Set;
classe publique RemoveDuplicateFromString {
public static String DupRemoveFromString(String str){
char[] c1 =str.toCharArray();
Set<Character> charSet = new LinkedHashSet<Character>();
for(char c:c1){
charSet.add(c);
}
StringBuffer sb = new StringBuffer();
for (Character c2 : charSet) {
sb.append(c2);
}
return sb.toString();
}
public static void main(String[] args) {
System.out.println("Enter Your String: ");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
System.out.println(DupRemoveFromString(str));
}
}
J'espère que cela aidera.
public void RemoveDuplicates() {
String s = "Hello World!";
int l = s.length();
char ch;
String result = "";
for (int i = 0; i < l; i++) {
ch = s.charAt(i);
if (ch != ' ') {
result = result + ch;
}
// Replacing space in all occurrence of the current character
s = s.replace(ch, ' ');
}
System.out.println("After removing duplicate characters : " + result);
}
'ai un tableau pour savoir si un personnage a déjà été enregistré ou non; sinon, ajoutez cela au tampon de chaîne. Veuillez noter que je l’ai rendu sensible à la casse; avec le tableau int, vous pouvez toujours faire (vous n’avez pas fait cela dans ce code) pour retourner aussi le nombre d’occurrences.
private static String removeDuplicates(String s) {
int [] occurrences = new int[52];
Arrays.fill(occurrences,0);
StringBuffer deDupS = new StringBuffer();
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i) >= 97) {
if(occurrences[s.charAt(i) - 97] == 0) {
deDupS.append(s.charAt(i));
occurrences[s.charAt(i) - 97]++;
}
} else if(s.charAt(i) >= 65) {
if(occurrences[s.charAt(i) - 65 + 26] == 0) {
deDupS.append(s.charAt(i));
occurrences[s.charAt(i) - 65 + 26]++;
}
}
}
return deDupS.toString();
}
package com.st.removeduplicate;
public class RemoveDuplicate {
public static void main(String[] args) {
String str1="shushil",str2="";
for(int i=0; i<=str1.length()-1;i++) {
int count=0;
for(int j=0;j<=i;j++) {
if(str1.charAt(i)==str1.charAt(j))
count++;
if(count >1)
break;
}
if(count==1)
str2=str2+str1.charAt(i);
}
System.out.println(str2);
}
}
Une autre solution possible, dans le cas où une chaîne est une chaîne ASCII, consiste à maintenir un tableau de 256 éléments booléens pour indiquer l'apparence des caractères ASCII dans une chaîne. Si un personnage est apparu pour la première fois, nous le conservons et ajoutons au résultat. Sinon, sautez-le.
public String removeDuplicates(String input) {
boolean[] chars = new boolean[256];
StringBuilder resultStringBuilder = new StringBuilder();
for (Character c : input.toCharArray()) {
if (!chars[c]) {
resultStringBuilder.append(c);
chars[c] = true;
}
}
return resultStringBuilder.toString();
}
Cette approche fonctionnera également avec la chaîne Unicode. Vous devez simplement augmenter la taille chars.
public static void main(String a[]){
String name="Madan";
System.out.println(name);
StringBuilder sb=new StringBuilder(name);
for(int i=0;i<name.length();i++){
for(int j=i+1;j<name.length();j++){
if(name.charAt(i)==name.charAt(j)){
sb.deleteCharAt(j);
}
}
}
System.out.println("After deletion :"+sb+"");
}
import Java.util.Scanner;
public class dublicate {
public static void main(String... a) {
System.out.print("Enter the String");
Scanner Sc = new Scanner(System.in);
String st=Sc.nextLine();
StringBuilder sb=new StringBuilder();
boolean [] bc=new boolean[256];
for(int i=0;i<st.length();i++)
{
int index=st.charAt(i);
if(bc[index]==false)
{
sb.append(st.charAt(i));
bc[index]=true;
}
}
System.out.print(sb.toString());
}
}
import Java.io.BufferedReader;
import Java.io.IOException;
import Java.io.InputStreamReader;
public class RemoveDuplicacy
{
public static void main(String args[])throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter any Word : ");
String s = br.readLine();
int l = s.length();
char ch;
String ans=" ";
for(int i=0; i<l; i++)
{
ch = s.charAt(i);
if(ch!=' ')
ans = ans + ch;
s = s.replace(ch,' '); //Replacing all occurrence of the current character by a space
}
System.out.println("Word after removing duplicate characters : " + ans);
}
}
public String removeDuplicates(String dupCharsString){
StringBuffer buffer = new StringBuffer(dupCharsString);
int step = 0;
while(step <= buffer.length()){
for( int i = step + 1; i < buffer.length(); i++ ){
if( buffer.charAt(i) == buffer.charAt(step) ){
buffer.setCharAt(i, ' ');
}
}
step++;
}
return buffer.toString().replaceAll("\\s","");
}
Ceci est une amélioration de la solution suggérée par @Dave. Ici, je mets en œuvre en boucle simple seulement.
Utilisons réutilisons la méthode return of set.add (T item) et ajoutons-la simultanément dans StringBuffer si add est réussi.
Ceci est juste O (n). Pas besoin de refaire une boucle.
String string = "aabbccdefatafaz";
char[] chars = string.toCharArray();
StringBuilder sb = new StringBuilder();
Set<Character> charSet = new LinkedHashSet<Character>();
for (char c : chars) {
if(charSet.add(c) ){
sb.append(c);
}
}
System.out.println(sb.toString()); // abcdeftz
String str1[] ="Hi helloo helloo oooo this".split(" ");
Set<String> charSet = new LinkedHashSet<String>();
for (String c: str1)
{
charSet.add(c);
}
StringBuilder sb = new StringBuilder();
for (String character : charSet)
{
sb.append(character);
}
System.out.println(sb.toString());
public static void main (String[] args)
{
Scanner sc = new Scanner(System.in);
String s = sc.next();
String str = "";
char c;
for(int i = 0; i < s.length(); i++)
{
c = s.charAt(i);
str = str + c;
s = s.replace(c, ' ');
if(i == s.length() - 1)
{
System.out.println(str.replaceAll("\\s", ""));
}
}
}
Solution utilisant JDK7:
public static String removeDuplicateChars(final String str){
if (str == null || str.isEmpty()){
return str;
}
final char[] chArray = str.toCharArray();
final Set<Character> set = new LinkedHashSet<>();
for (char c : chArray) {
set.add(c);
}
final StringBuilder sb = new StringBuilder();
for (Character character : set) {
sb.append(character);
}
return sb.toString();
}
import Java.util.LinkedHashMap;
import Java.util.Map.Entry;
public class Sol {
public static void main(String[] args) {
char[] str = "bananas".toCharArray();
LinkedHashMap<Character,Integer> map = new LinkedHashMap<>();
StringBuffer s = new StringBuffer();
for(Character c : str){
if(map.containsKey(c))
map.put(c, map.get(c)+1);
else
map.put(c, 1);
}
for(Entry<Character,Integer> entry : map.entrySet()){
s.append(entry.getKey());
}
System.out.println(s);
}
}
Manière Oldschool (comme nous l’avons écrit dans Apple] [Basic, adapté à Java):
int i,j;
StringBuffer str=new StringBuffer();
Scanner in = new Scanner(System.in);
System.out.print("Enter string: ");
str.append(in.nextLine());
for (i=0;i<str.length()-1;i++){
for (j=i+1;j<str.length();j++){
if (str.charAt(i)==str.charAt(j))
str.deleteCharAt(j);
}
}
System.out.println("Removed non-unique symbols: " + str);
Tu ne peux pas. Vous pouvez créer une nouvelle chaîne dont les doublons ont été supprimés. Pourquoi n'utilisez-vous pas StringBuilder (ou StringBuffer, vraisemblablement)?
Vous pouvez parcourir la chaîne et stocker les caractères uniques dans un tableau char [], en gardant une trace du nombre de caractères uniques que vous avez vus. Vous pouvez ensuite créer une nouvelle chaîne à l'aide du constructeur String(char[], int, int).
De plus, le problème est un peu ambigu: «doublons» signifie-t-il des répétitions adjacentes? (En d'autres termes, que devrait-il se passer avec abcab?)
String str = "[email protected]";
char[] c = str.toCharArray();
String op = "";
for(int i=0; i<=c.length-1; i++){
if(!op.contains(c[i] + ""))
op = op + c[i];
}
System.out.println(op);
public static String removeDuplicateChar(String str){
char charArray[] = str.toCharArray();
StringBuilder stringBuilder= new StringBuilder();
for(int i=0;i<charArray.length;i++){
int index = stringBuilder.toString().indexOf(charArray[i]);
if(index <= -1){
stringBuilder.append(charArray[i]);
}
}
return stringBuilder.toString();
}
Voici une autre logique que je voudrais partager. Vous commencez à comparer à partir du milieu de la longueur de la chaîne et revenez en arrière.
Testez avec: Input = "azxxzy"; Output = "ay";
String removeMidway(String input){
cnt = cnt+1;
StringBuilder str = new StringBuilder(input);
int midlen = str.length()/2;
for(int i=midlen-1;i>0;i--){
for(int j=midlen;j<str.length()-1;j++){
if(str.charAt(i)==str.charAt(j)){
str.delete(i, j+1);
midlen = str.length()/2;
System.out.println("i="+i+",j="+j+ ",len="+ str.length() + ",midlen=" + midlen+ ", after deleted = " + str);
}
}
}
return str.toString();
}
Ok les gars, j'ai trouvé un meilleur moyen de le faire
public static void alpha(char[] finalname)
{
if (finalname == null)
{
return;
}
if (finalname.length <2)
{
return;
}
char empty = '\000';
for (int i=0; i<finalname.length-1; i++)
{
if (finalname[i] == finalname[i+1])
{
finalname[i] = empty;
}
}
String alphaname = String.valueOf(finalname);
alphaname = alphaname.replace("\000", "");
System.out.println(alphaname);
}
C'est une autre approche
void remove_duplicate (char* str, int len) {
unsigned int index = 0;
int c = 0;
int i = 0;
while (c < len) {
/* this is just example more check can be added for
capital letter, space and special chars */
int pos = str[c] - 'a';
if ((index & (1<<pos)) == 0) {
str[i++] = str[c];
index |= (1<<pos);
}
c++;
}
str[i] = 0;
}
Essayez cette solution simple en utilisant le concept de collection Set: String str = "aabbcdegg";
Set<Character>removeduplicates = new LinkedHashSet<>();
char strarray[]= str.toCharArray();
for(char c:strarray)
{
removeduplicates.add(c);
}
Iterator<Character> itr = removeduplicates.iterator();
while(itr.hasNext())
{
System.out.print(itr.next());
}
Pour la simplicité du code - j'ai pris une entrée hardcore, on peut aussi utiliser une classe de scanner
public class KillDuplicateCharInString {
public static void main(String args[]) {
String str= "aaaabccdde ";
char arr[]= str.toCharArray();
int n = arr.length;
String finalStr="";
for(int i=0;i<n;i++) {
if(i==n-1){
finalStr+=arr[i];
break;
}
if(arr[i]==arr[i+1]) {
continue;
}
else {
finalStr+=arr[i];
}
}
System.out.println(finalStr);
}
}