C++
// CPP program to remove duplicate character
// from character array and print in sorted
// order
#include <bits/stdc++.h>
using namespace std;
char *removeDuplicate(char str[], int n)
{
// create a set using string characters
// excluding '\0'
unordered_set<char>s (str, str+n-1);
// print content of the set
int i = 0;
for (auto x : s)
str[i++] = x;
str[i] = '\0';
return str;
}
// Driver code
int main()
{
char str[]= "geeksforgeeks";
int n = sizeof(str) / sizeof(str[0]);
cout << removeDuplicate(str, n);
return 0;
}
Java
// Java program to remove duplicate character
// from character array and print in sorted
// order
import java.util.*;
class GFG {
static void removeDuplicate(char str[], int n)
{
// Create a set using String characters
// excluding '\0'
HashSet<Character> s = new LinkedHashSet<>(n - 1);
// HashSet doesn't allow repetition of elements
for (char x : str)
s.add(x);
// Print content of the set
for (char x : s)
System.out.print(x);
}
// Driver code
public static void main(String[] args)
{
char str[] = "geeksforgeeks".toCharArray();
int n = str.length;
removeDuplicate(str, n);
}
}
// This code is contributed by todaysgaurav
Python3
# Python program to remove duplicate character # from character array and print in sorted # order def removeDuplicate(str, n): s = set() # Create a set using String characters for i in str: s.add(i) # Print content of the set st = "" for i in s: st = st+i return st # Driver code str = "geeksforgeeks" n = len(str) print(removeDuplicate(list(str), n)) # This code is contributed by rajsanghavi9.
C#
// C# program to remove duplicate character
// from character array and print in sorted
// order
using System;
using System.Collections.Generic;
public class GFG{
static char []removeDuplicate(char []str, int n)
{
// Create a set using String characters
// excluding '\0'
HashSet<char>s = new HashSet<char>(n - 1);
foreach(char x in str)
s.Add(x);
char[] st = new char[s.Count];
// Print content of the set
int i = 0;
foreach(char x in s)
st[i++] = x;
return st;
}
// Driver code
public static void Main(String[] args)
{
char []str= "geeksforgeeks".ToCharArray();
int n = str.Length;
Console.Write(removeDuplicate(str, n));
}
}
// This code contributed by gauravrajput1
Javascript
<script>
// javascript program to remove duplicate character
// from character array and print in sorted
// order
function removeDuplicate( str , n)
{
// Create a set using String characters
// excluding '\0'
var s = new Set();
// HashSet doesn't allow repetition of elements
for (var i = 0;i<n;i++)
s.add(str[i]);
// Print content of the set
for (const v of s) {
document.write(v);
}
}
// Driver code
var str = "geeksforgeeks";
var n = str.length;
removeDuplicate(str, n);
// This code is contributed by umadevi9616
</script>
Dada una string S , la tarea es eliminar todos los duplicados en la string dada.
A continuación se muestran los diferentes métodos para eliminar duplicados en una string.
MÉTODO 1 (Simple)
C++
// CPP program to remove duplicate character
// from character array and print in sorted
// order
#include <bits/stdc++.h>
using namespace std;
char *removeDuplicate(char str[], int n)
{
// Used as index in the modified string
int index = 0;
// Traverse through all characters
for (int i=0; i<n; i++) {
// Check if str[i] is present before it
int j;
for (j=0; j<i; j++)
if (str[i] == str[j])
break;
// If not present, then add it to
// result.
if (j == i)
str[index++] = str[i];
}
return str;
}
// Driver code
int main()
{
char str[]= "geeksforgeeks";
int n = sizeof(str) / sizeof(str[0]);
cout << removeDuplicate(str, n);
return 0;
}
Java
// Java program to remove duplicate character
// from character array and print in sorted
// order
import java.util.*;
class GFG
{
static String removeDuplicate(char str[], int n)
{
// Used as index in the modified string
int index = 0;
// Traverse through all characters
for (int i = 0; i < n; i++)
{
// Check if str[i] is present before it
int j;
for (j = 0; j < i; j++)
{
if (str[i] == str[j])
{
break;
}
}
// If not present, then add it to
// result.
if (j == i)
{
str[index++] = str[i];
}
}
return String.valueOf(Arrays.copyOf(str, index));
}
// Driver code
public static void main(String[] args)
{
char str[] = "geeksforgeeks".toCharArray();
int n = str.length;
System.out.println(removeDuplicate(str, n));
}
}
// This code is contributed by Rajput-Ji
Python3
string="geeksforgeeks"
p=""
for char in string:
if char not in p:
p=p+char
print(p)
k=list("geeksforgeeks")
C#
// C# program to remove duplicate character
// from character array and print in sorted
// order
using System;
using System.Collections.Generic;
class GFG
{
static String removeDuplicate(char []str, int n)
{
// Used as index in the modified string
int index = 0;
// Traverse through all characters
for (int i = 0; i < n; i++)
{
// Check if str[i] is present before it
int j;
for (j = 0; j < i; j++)
{
if (str[i] == str[j])
{
break;
}
}
// If not present, then add it to
// result.
if (j == i)
{
str[index++] = str[i];
}
}
char [] ans = new char[index];
Array.Copy(str, ans, index);
return String.Join("", ans);
}
// Driver code
public static void Main(String[] args)
{
char []str = "geeksforgeeks".ToCharArray();
int n = str.Length;
Console.WriteLine(removeDuplicate(str, n));
}
}
// This code is contributed by PrinciRaj1992
Javascript
<script>
// JavaScript program to remove duplicate character
// from character array and print in sorted
// order
function removeDuplicate(str, n)
{
// Used as index in the modified string
var index = 0;
// Traverse through all characters
for (var i = 0; i < n; i++)
{
// Check if str[i] is present before it
var j;
for (j = 0; j < i; j++)
{
if (str[i] == str[j])
{
break;
}
}
// If not present, then add it to
// result.
if (j == i)
{
str[index++] = str[i];
}
}
return str.join("").slice(str, index);
}
// Driver code
var str = "geeksforgeeks".split("");
var n = str.length;
document.write(removeDuplicate(str, n));
// This code is contributed by shivanisinghss2110
</script>
Producción:
geksfor
Complejidad de tiempo: O(n * n)
Espacio auxiliar: O(1)
Mantiene el orden de los elementos igual que la entrada.
MÉTODO 2 (usando set)
Use set para almacenar solo una instancia de cualquier valor.
C++
// CPP program to remove duplicate character
// from character array and print in sorted
// order
#include <bits/stdc++.h>
using namespace std;
char *removeDuplicate(char str[], int n)
{
// create a set using string characters
// excluding '\0'
unordered_set<char>s (str, str+n-1);
// print content of the set
int i = 0;
for (auto x : s)
str[i++] = x;
str[i] = '\0';
return str;
}
// Driver code
int main()
{
char str[]= "geeksforgeeks";
int n = sizeof(str) / sizeof(str[0]);
cout << removeDuplicate(str, n);
return 0;
}
Java
// Java program to remove duplicate character
// from character array and print in sorted
// order
import java.util.*;
class GFG {
static void removeDuplicate(char str[], int n)
{
// Create a set using String characters
// excluding '\0'
HashSet<Character> s = new LinkedHashSet<>(n - 1);
// HashSet doesn't allow repetition of elements
for (char x : str)
s.add(x);
// Print content of the set
for (char x : s)
System.out.print(x);
}
// Driver code
public static void main(String[] args)
{
char str[] = "geeksforgeeks".toCharArray();
int n = str.length;
removeDuplicate(str, n);
}
}
// This code is contributed by todaysgaurav
Python3
# Python program to remove duplicate character # from character array and print in sorted # order def removeDuplicate(str, n): s = set() # Create a set using String characters for i in str: s.add(i) # Print content of the set st = "" for i in s: st = st+i return st # Driver code str = "geeksforgeeks" n = len(str) print(removeDuplicate(list(str), n)) # This code is contributed by rajsanghavi9.
C#
// C# program to remove duplicate character
// from character array and print in sorted
// order
using System;
using System.Collections.Generic;
public class GFG{
static char []removeDuplicate(char []str, int n)
{
// Create a set using String characters
// excluding '\0'
HashSet<char>s = new HashSet<char>(n - 1);
foreach(char x in str)
s.Add(x);
char[] st = new char[s.Count];
// Print content of the set
int i = 0;
foreach(char x in s)
st[i++] = x;
return st;
}
// Driver code
public static void Main(String[] args)
{
char []str= "geeksforgeeks".ToCharArray();
int n = str.Length;
Console.Write(removeDuplicate(str, n));
}
}
// This code contributed by gauravrajput1
Javascript
<script>
// javascript program to remove duplicate character
// from character array and print in sorted
// order
function removeDuplicate( str , n)
{
// Create a set using String characters
// excluding '\0'
var s = new Set();
// HashSet doesn't allow repetition of elements
for (var i = 0;i<n;i++)
s.add(str[i]);
// Print content of the set
for (const v of s) {
document.write(v);
}
}
// Driver code
var str = "geeksforgeeks";
var n = str.length;
removeDuplicate(str, n);
// This code is contributed by umadevi9616
</script>
Producción:
efgkors
Tiempo Complejidad : O(n)
Espacio Auxiliar : O(n)
Gracias a Anivesh Tiwari por sugerir este enfoque.
No mantiene el orden de los elementos igual que la entrada, sino que los imprime ordenados.
MÉTODO 3 (Uso de clasificación)
Algoritmo:
1) Sort the elements.
2) Now in a loop, remove duplicates by comparing the
current character with previous character.
3) Remove extra characters at the end of the resultant string.
Ejemplo:
Input string: geeksforgeeks
1) Sort the characters
eeeefggkkorss
2) Remove duplicates
efgkorskkorss
3) Remove extra characters
efgkors
Tenga en cuenta que este método no mantiene el orden original de la string de entrada. Por ejemplo, si vamos a eliminar los duplicados de geeksforgeeks y mantener el mismo orden de los caracteres, la salida debería ser geksfor, pero la función anterior devuelve efgkos. Podemos modificar este método almacenando el pedido original.
Implementación:
C++
// C++ program to remove duplicates, the order of
// characters is not maintained in this program
#include<bits/stdc++.h>
using namespace std;
/* Function to remove duplicates in a sorted array */
char *removeDupsSorted(char *str)
{
int res_ind = 1, ip_ind = 1;
/* In place removal of duplicate characters*/
while (*(str + ip_ind))
{
if (*(str + ip_ind) != *(str + ip_ind - 1))
{
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}
/* After above step string is efgkorskkorss.
Removing extra kkorss after string*/
*(str + res_ind) = '\0';
return str;
}
/* Function removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
int n = strlen(str);
// Sort the character array
sort(str, str+n);
// Remove duplicates from sorted
return removeDupsSorted(str);
}
/* Driver program to test removeDups */
int main()
{
char str[] = "geeksforgeeks";
cout << removeDups(str);
return 0;
}
C
// C program to remove duplicates, the order of
// characters is not maintained in this program
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
/* Function to remove duplicates in a sorted array */
char *removeDupsSorted(char *str);
/* Utility function to sort array A[] */
void quickSort(char A[], int si, int ei);
/* Function removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
int len = strlen(str);
quickSort(str, 0, len-1);
return removeDupsSorted(str);
}
/* Function to remove duplicates in a sorted array */
char *removeDupsSorted(char *str)
{
int res_ind = 1, ip_ind = 1;
/* In place removal of duplicate characters*/
while (*(str + ip_ind))
{
if (*(str + ip_ind) != *(str + ip_ind - 1))
{
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}
/* After above step string is efgkorskkorss.
Removing extra kkorss after string*/
*(str + res_ind) = '\0';
return str;
}
/* Driver program to test removeDups */
int main()
{
char str[] = "geeksforgeeks";
printf("%s", removeDups(str));
getchar();
return 0;
}
/* FOLLOWING FUNCTIONS ARE ONLY FOR SORTING
PURPOSE */
void exchange(char *a, char *b)
{
char temp;
temp = *a;
*a = *b;
*b = temp;
}
int partition(char A[], int si, int ei)
{
char x = A[ei];
int i = (si - 1);
int j;
for (j = si; j <= ei - 1; j++)
{
if (A[j] <= x)
{
i++;
exchange(&A[i], &A[j]);
}
}
exchange (&A[i + 1], &A[ei]);
return (i + 1);
}
/* Implementation of Quick Sort
A[] --> Array to be sorted
si --> Starting index
ei --> Ending index
*/
void quickSort(char A[], int si, int ei)
{
int pi; /* Partitioning index */
if (si < ei)
{
pi = partition(A, si, ei);
quickSort(A, si, pi - 1);
quickSort(A, pi + 1, ei);
}
}
Java
// Java program to remove duplicates, the order of
// characters is not maintained in this program
import java.util.Arrays;
public class GFG
{
/* Method to remove duplicates in a sorted array */
static String removeDupsSorted(String str)
{
int res_ind = 1, ip_ind = 1;
// Character array for removal of duplicate characters
char arr[] = str.toCharArray();
/* In place removal of duplicate characters*/
while (ip_ind != arr.length)
{
if(arr[ip_ind] != arr[ip_ind-1])
{
arr[res_ind] = arr[ip_ind];
res_ind++;
}
ip_ind++;
}
str = new String(arr);
return str.substring(0,res_ind);
}
/* Method removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
static String removeDups(String str)
{
// Sort the character array
char temp[] = str.toCharArray();
Arrays.sort(temp);
str = new String(temp);
// Remove duplicates from sorted
return removeDupsSorted(str);
}
// Driver Method
public static void main(String[] args)
{
String str = "geeksforgeeks";
System.out.println(removeDups(str));
}
}
Python3
# Python3 program to remove duplicates, the order of # characters is not maintained in this program # Utility function to convert string to list def toMutable(string): temp = [] for x in string: temp.append(x) return temp # Utility function to convert string to list def toString(List): return ''.join(List) # Function to remove duplicates in a sorted array def removeDupsSorted(List): res_ind = 1 ip_ind = 1 # In place removal of duplicate characters while ip_ind != len(List): if List[ip_ind] != List[ip_ind-1]: List[res_ind] = List[ip_ind] res_ind += 1 ip_ind+=1 # After above step string is efgkorskkorss. # Removing extra kkorss after string string = toString(List[0:res_ind]) return string # Function removes duplicate characters from the string # This function work in-place and fills null characters # in the extra space left def removeDups(string): # Convert string to list List = toMutable(string) # Sort the character list List.sort() # Remove duplicates from sorted return removeDupsSorted(List) # Driver program to test the above functions string = "geeksforgeeks" print(removeDups(string)) # This code is contributed by Bhavya Jain
C#
// C# program to remove duplicates, the order of
// characters is not maintained in this program
using System;
class GFG
{
/* Method to remove duplicates in a sorted array */
static String removeDupsSorted(String str)
{
int res_ind = 1, ip_ind = 1;
// Character array for removal of duplicate characters
char []arr = str.ToCharArray();
/* In place removal of duplicate characters*/
while (ip_ind != arr.Length)
{
if(arr[ip_ind] != arr[ip_ind-1])
{
arr[res_ind] = arr[ip_ind];
res_ind++;
}
ip_ind++;
}
str = new String(arr);
return str.Substring(0,res_ind);
}
/* Method removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
static String removeDups(String str)
{
// Sort the character array
char []temp = str.ToCharArray();
Array.Sort(temp);
str = String.Join("",temp);
// Remove duplicates from sorted
return removeDupsSorted(str);
}
// Driver Method
public static void Main(String[] args)
{
String str = "geeksforgeeks";
Console.WriteLine(removeDups(str));
}
}
// This code is contributed by 29AjayKumar
Javascript
<script>
function removeDuplicate(string)
{
return string.split('')
.filter(function(item, pos, self)
{
return self.indexOf(item) == pos;
}
).join('');
}
var str = "geeksforgeeks";
document.write( " "+removeDuplicate(str));
//This code is contributed by SoumikMondal
</script>
Producción:
efgkors
Complejidad de tiempo: O (n log n) Si usamos algún algoritmo de clasificación nlogn en lugar de quicksort.
Espacio Auxiliar: O(1)
MÉTODO 4 (Usar hash)
Algoritmo:
1: Initialize:
str = "test string" /* input string */
ip_ind = 0 /* index to keep track of location of next
character in input string */
res_ind = 0 /* index to keep track of location of
next character in the resultant string */
bin_hash[0..255] = {0,0, ….} /* Binary hash to see if character is
already processed or not */
2: Do following for each character *(str + ip_ind) in input string:
(a) if bin_hash is not set for *(str + ip_ind) then
// if program sees the character *(str + ip_ind) first time
(i) Set bin_hash for *(str + ip_ind)
(ii) Move *(str + ip_ind) to the resultant string.
This is done in-place.
(iii) res_ind++
(b) ip_ind++
/* String obtained after this step is "the stringing" */
3: Remove extra characters at the end of the resultant string.
/* String obtained after this step is "te string" */
Implementación:
C++
#include <bits/stdc++.h>
using namespace std;
# define NO_OF_CHARS 256
# define bool int
/* Function removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
char *removeDups(char str[])
{
bool bin_hash[NO_OF_CHARS] = {0};
int ip_ind = 0, res_ind = 0;
char temp;
/* In place removal of duplicate characters*/
while (*(str + ip_ind))
{
temp = *(str + ip_ind);
if (bin_hash[temp] == 0)
{
bin_hash[temp] = 1;
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}
/* After above step string is stringiittg.
Removing extra iittg after string*/
*(str+res_ind) = '\0';
return str;
}
/* Driver code */
int main()
{
char str[] = "geeksforgeeks";
cout << removeDups(str);
return 0;
}
// This code is contributed by rathbhupendra
C
# include <stdio.h>
# include <stdlib.h>
# define NO_OF_CHARS 256
# define bool int
/* Function removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
bool bin_hash[NO_OF_CHARS] = {0};
int ip_ind = 0, res_ind = 0;
char temp;
/* In place removal of duplicate characters*/
while (*(str + ip_ind))
{
temp = *(str + ip_ind);
if (bin_hash[temp] == 0)
{
bin_hash[temp] = 1;
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}
/* After above step string is stringiittg.
Removing extra iittg after string*/
*(str+res_ind) = '\0';
return str;
}
/* Driver program to test removeDups */
int main()
{
char str[] = "geeksforgeeks";
printf("%s", removeDups(str));
getchar();
return 0;
}
Java
// Java program to remove duplicates
import java.util.*;
class RemoveDuplicates
{
/* Function removes duplicate characters from the string
This function work in-place */
void removeDuplicates(String str)
{
LinkedHashSet<Character> lhs = new LinkedHashSet<>();
for(int i=0;i<str.length();i++)
lhs.add(str.charAt(i));
// print string after deleting duplicate elements
for(Character ch : lhs)
System.out.print(ch);
}
/* Driver program to test removeDuplicates */
public static void main(String args[])
{
String str = "geeksforgeeks";
RemoveDuplicates r = new RemoveDuplicates();
r.removeDuplicates(str);
}
}
// This code has been contributed by Amit Khandelwal (Amit Khandelwal 1)
Python3
# Python3 program to remove duplicate characters from an # input string NO_OF_CHARS = 256 # Since strings in Python are immutable and cannot be changed # This utility function will convert the string to list def toMutable(string): List = [] for i in string: List.append(i) return List # Utility function that changes list to string def toString(List): return ''.join(List) # Function removes duplicate characters from the string # This function work in-place and fills null characters # in the extra space left def removeDups(string): bin_hash = [0] * NO_OF_CHARS ip_ind = 0 res_ind = 0 temp = '' mutableString = toMutable(string) # In place removal of duplicate characters while ip_ind != len(mutableString): temp = mutableString[ip_ind] if bin_hash[ord(temp)] == 0: bin_hash[ord(temp)] = 1 mutableString[res_ind] = mutableString[ip_ind] res_ind+=1 ip_ind+=1 # After above step string is stringiittg. # Removing extra iittg after string return toString(mutableString[0:res_ind]) # Driver program to test the above functions string = "geeksforgeeks" print(removeDups(string)) # A shorter version for this program is as follows # import collections # print ''.join(collections.OrderedDict.fromkeys(string)) # This code is contributed by Bhavya Jain
C#
// C# program to remove duplicates
using System;
using System.Collections.Generic;
class GFG
{
/* Function removes duplicate characters
from the string. This function work in-place */
void removeDuplicates(String str)
{
HashSet<char> lhs = new HashSet<char>();
for(int i = 0; i < str.Length; i++)
lhs.Add(str[i]);
// print string after deleting
// duplicate elements
foreach(char ch in lhs)
Console.Write(ch);
}
// Driver Code
public static void Main(String []args)
{
String str = "geeksforgeeks";
GFG r = new GFG();
r.removeDuplicates(str);
}
}
// This code is contributed by Rajput-Ji
Javascript
<script>
// javascript program to remove duplicates
/*
* Function removes duplicate characters from the string This function work
* in-place
*/
function removeDuplicates( str) {
var lhs = new Set();
for (var i = 0; i < str.length; i++)
lhs.add(str[i]);
// print string after deleting duplicate elements
for (var ch of lhs)
document.write(ch);
}
/* Driver program to test removeDuplicates */
var str = "geeksforgeeks";
removeDuplicates(str);
// This code is contributed by umadevi9616
</script>
Producción:
geksfor
Complejidad de tiempo: O(n)
Espacio Auxiliar : O(1)
Puntos importantes:
- El método 2 no mantiene los caracteres como strings originales, pero el método 4 sí.
- Se supone que el número de caracteres posibles en la string de entrada es 256. NO_OF_CHARS debe cambiarse en consecuencia.
- calloc() se usa en lugar de malloc() para las asignaciones de memoria de una array de conteo (recuento) para inicializar la memoria asignada a ‘\0’. También se puede usar malloc() seguido de memset().
- El algoritmo anterior también funciona para entradas de array de enteros si se proporciona el rango de los enteros en la array. Un problema de ejemplo es encontrar el número máximo que ocurre en una array de entrada dado que la array de entrada contiene números enteros solo entre 1000 y 1100
Método 5 (usando el método IndexOf() ):
requisito previo: método Java IndexOf()
C++
// C++ program to create a unique string
#include <bits/stdc++.h>
using namespace std;
// Function to make the string unique
string unique(string s)
{
string str;
int len = s.length();
// loop to traverse the string and
// check for repeating chars using
// IndexOf() method in Java
for(int i = 0; i < len; i++)
{
// character at i'th index of s
char c = s[i];
// If c is present in str, it returns
// the index of c, else it returns npos
auto found = str.find(c);
if (found == std::string::npos)
{
// Adding c to str if npos is returned
str += c;
}
}
return str;
}
// Driver code
int main()
{
// Input string with repeating chars
string s = "geeksforgeeks";
cout << unique(s) << endl;
}
// This code is contributed by nirajgusain5
Java
// Java program to create a unique string
import java.util.*;
class IndexOf {
// Function to make the string unique
public static String unique(String s)
{
String str = new String();
int len = s.length();
// loop to traverse the string and
// check for repeating chars using
// IndexOf() method in Java
for (int i = 0; i < len; i++)
{
// character at i'th index of s
char c = s.charAt(i);
// if c is present in str, it returns
// the index of c, else it returns -1
if (str.indexOf(c) < 0)
{
// adding c to str if -1 is returned
str += c;
}
}
return str;
}
// Driver code
public static void main(String[] args)
{
// Input string with repeating chars
String s = "geeksforgeeks";
System.out.println(unique(s));
}
}
Python3
# Python 3 program to create a unique string # Function to make the string unique def unique(s): st = "" length = len(s) # loop to traverse the string and # check for repeating chars using # IndexOf() method in Java for i in range(length): # character at i'th index of s c = s[i] # if c is present in str, it returns # the index of c, else it returns - 1 # print(st.index(c)) if c not in st: # adding c to str if -1 is returned st += c return st # Driver code if __name__ == "__main__": # Input string with repeating chars s = "geeksforgeeks" print(unique(s)) # This code is contributed by ukasp.
C#
// C# program to create a unique string
using System;
public class IndexOf
{
// Function to make the string unique
public static String unique(String s)
{
String str = "";
int len = s.Length;
// loop to traverse the string and
// check for repeating chars using
// IndexOf() method in Java
for (int i = 0; i < len; i++)
{
// character at i'th index of s
char c = s[i];
// if c is present in str, it returns
// the index of c, else it returns -1
if (str.IndexOf(c) < 0)
{
// adding c to str if -1 is returned
str += c;
}
}
return str;
}
// Driver code
public static void Main(String[] args)
{
// Input string with repeating chars
String s = "geeksforgeeks";
Console.WriteLine(unique(s));
}
}
// This code is contributed by Princi Singh
Javascript
<script>
// JavaScript program to create a unique string
// Function to make the string unique
function unique(s)
{
let str = "";
let len = s.length;
// loop to traverse the string and
// check for repeating chars using
// IndexOf() method in Java
for (let i = 0; i < len; i++)
{
// character at i'th index of s
let c = s[i];
// if c is present in str, it returns
// the index of c, else it returns -1
if (str.indexOf(c) < 0)
{
// adding c to str if -1 is returned
str += c;
}
}
return str;
}
// Input string with repeating chars
let s = "geeksforgeeks";
document.write(unique(s));
</script>
Producción:
geksfor
Complejidad de tiempo: -O(n)
Gracias debjitdbb por sugerir este enfoque.
Método 6 (usando el método STL unordered_map ):
Requisito previo: método C++ unordered_map STL
C++
// C++ program to create a unique string using unordered_map
/* access time in unordered_map on is O(1) generally if no collisions occur
and therefore it helps us check if an element exists in a string in O(1)
time complexity with constant space. */
#include <bits/stdc++.h>
using namespace std;
char* removeDuplicates(char *s,int n){
unordered_map<char,int> exists;
int index = 0;
for(int i=0;i<n;i++){
if(exists[s[i]]==0)
{
s[index++] = s[i];
exists[s[i]]++;
}
}
return s;
}
//driver code
int main(){
char s[] = "geeksforgeeks";
int n = sizeof(s)/sizeof(s[0]);
cout<<removeDuplicates(s,n)<<endl;
return 0;
}
Java
// Java program to create a unique String using unordered_map
/* access time in unordered_map on is O(1) generally if no collisions occur
and therefore it helps us check if an element exists in a String in O(1)
time complexity with constant space. */
import java.util.*;
class GFG{
static char[] removeDuplicates(char []s,int n){
Map<Character,Integer> exists = new HashMap<>();
String st = "";
for(int i = 0; i < n; i++){
if(!exists.containsKey(s[i]))
{
st += s[i];
exists.put(s[i], 1);
}
}
return st.toCharArray();
}
// driver code
public static void main(String[] args){
char s[] = "geeksforgeeks".toCharArray();
int n = s.length;
System.out.print(removeDuplicates(s,n));
}
}
Python3
# Python program to create a unique string using unordered_map
# access time in unordered_map on is O(1) generally if no collisions occur
# and therefore it helps us check if an element exists in a string in O(1)
# time complexity with constant space.
def removeDuplicates(s, n):
exists = {}
index = 0
ans = ""
for i in range(0, n):
if s[i] not in exists or exists[s[i]] == 0:
s[index] = s[i]
print(s[index], end='')
index += 1
exists[s[i]] = 1
# driver code
s = "geeksforgeeks"
s1 = list(s)
n = len(s1)
removeDuplicates(s1, n)
C#
// C# program to create a unique String using unordered_map
/* access time in unordered_map on is O(1) generally if no collisions occur
and therefore it helps us check if an element exists in a String in O(1)
time complexity with constant space. */
using System;
using System.Collections.Generic;
public class GFG{
static char[] removeDuplicates(char []s,int n){
Dictionary<char,int> exists = new Dictionary<char, int>();
String st = "";
for(int i = 0; i < n; i++){
if(!exists.ContainsKey(s[i]))
{
st += s[i];
exists.Add(s[i], 1);
}
}
return st.ToCharArray();
}
// driver code
public static void Main(String[] args){
char []s = "geeksforgeeks".ToCharArray();
int n = s.Length;
Console.Write(removeDuplicates(s,n));
}
}
Javascript
<script>
// javascript program to create a unique String using unordered_map
/* access time in unordered_map on is O(1) generally if no collisions occur
and therefore it helps us check if an element exists in a String in O(1)
time complexity with constant space. */
function removeDuplicates( s , n) {
var exists = new Map();
var st = "";
for (var i = 0; i < n; i++) {
if (!exists.has(s[i])) {
st += s[i];
exists.set(s[i], 1);
}
}
return st;
}
// driver code
var s = "geeksforgeeks";
var n = s.length;
document.write(removeDuplicates(s, n));
</script>
Producción:
geksfor
Complejidad de tiempo: O(n), Espacio auxiliar: O(n)
Gracias, Allen James Vinoy por sugerir este enfoque.
MÉTODO 7 (Simple)
C++
#include <iostream>
using namespace std;
int main()
{
string s = "abcdabd";
string temp = "";
temp += s.at(0);
for (int i = 1; i < s.length(); i++) {
if (!(temp.find(s.at(i)) < temp.length()))
temp = temp + s.at(i);
}
cout << temp;
return 0;
}
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
String s = "abcdabd";
String temp = "" + s.charAt(0);
for (int i = 1; i < s.length(); i++) {
if (!temp.contains(String.valueOf(s.charAt(i))))
temp = temp + s.charAt(i);
}
System.out.println(temp);
}
}
Python3
# Python code for the above Approach s = "abcdabd" temp = "" + s[0] for i in range(1,len(s)): if (s[i] not in temp): temp = temp + s[i] # Printing the Result print(temp)
C#
using System;
public class GFG{
static public void Main (){
string s = "abcdabd";
string temp = "";
temp += s[0];
for (int i = 1; i < s.Length; i++) {
if (temp.IndexOf(s[i]) == -1)
temp = temp + s[i];
}
System.Console.WriteLine(temp);
}
}
// This code is contributed by akashish__
Javascript
<script>
// JavaScript code for the above Approach
let s = "abcdabd"
let temp = "" + s[0]
for(let i=1;i<s.length;i++){
if (temp.indexOf(s[i]) == -1)
temp = temp + s[i]
}
// Printing the Result
document.write(temp,"</br>")
</script>
Producción
abcd
Complejidad de tiempo : O(n), Espacio auxiliar: O(n)
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA