# Determine if a string has all Unique Characters

• Difficulty Level : Easy
• Last Updated : 25 Apr, 2022

Given a string, determine if the string has all unique characters.

Examples :

```Input : abcd10jk
Output : true

Input : hutg9mnd!nk9
Output : false```

Approach 1 – Brute Force technique: Run 2 loops with variable i and j. Compare str[i] and str[j]. If they become equal at any point, return false.
Time Complexity: O(n2

## C++

 `// C++ program to illustrate string``// with unique characters using``// brute force technique``#include ``using` `namespace` `std;` `bool` `uniqueCharacters(string str)``{` `    ``// If at any time we encounter 2``    ``// same characters, return false``    ``for` `(``int` `i = 0; i < str.length() - 1; i++) {``        ``for` `(``int` `j = i + 1; j < str.length(); j++) {``            ``if` `(str[i] == str[j]) {``                ``return` `false``;``            ``}``        ``}``    ``}` `    ``// If no duplicate characters encountered,``    ``// return true``    ``return` `true``;``}` `// driver code``int` `main()``{``    ``string str = ``"GeeksforGeeks"``;` `    ``if` `(uniqueCharacters(str)) {``        ``cout << ``"The String "` `<< str``             ``<< ``" has all unique characters\n"``;``    ``}``    ``else` `{``        ``cout << ``"The String "` `<< str``             ``<< ``" has duplicate characters\n"``;``    ``}``    ``return` `0;``}``// This code is contributed by Divyam Madaan`

## Java

 `// Java program to illustrate string with``// unique characters using brute force technique``import` `java.util.*;` `class` `GfG {``    ``boolean` `uniqueCharacters(String str)``    ``{``        ``// If at any time we encounter 2 same``        ``// characters, return false``        ``for` `(``int` `i = ``0``; i < str.length(); i++)``            ``for` `(``int` `j = i + ``1``; j < str.length(); j++)``                ``if` `(str.charAt(i) == str.charAt(j))``                    ``return` `false``;` `        ``// If no duplicate characters encountered,``        ``// return true``        ``return` `true``;``    ``}` `    ``public` `static` `void` `main(String args[])``    ``{``        ``GfG obj = ``new` `GfG();``        ``String input = ``"GeeksforGeeks"``;` `        ``if` `(obj.uniqueCharacters(input))``            ``System.out.println(``"The String "` `+ input + ``" has all unique characters"``);``        ``else``            ``System.out.println(``"The String "` `+ input + ``" has duplicate characters"``);``    ``}``}`

## Python3

 `# Python program to illustrate string``# with unique characters using``# brute force technique` `def` `uniqueCharacters(``str``):``    ` `    ``# If at any time we encounter 2``    ``# same characters, return false``    ``for` `i ``in` `range``(``len``(``str``)):``        ``for` `j ``in` `range``(i ``+` `1``,``len``(``str``)):``            ``if``(``str``[i] ``=``=` `str``[j]):``                ``return` `False``;` `    ``# If no duplicate characters``    ``# encountered, return true``    ``return` `True``;`  `# Driver Code``str` `=` `"GeeksforGeeks"``;` `if``(uniqueCharacters(``str``)):``    ``print``(``"The String "``, ``str``,``" has all unique characters"``);``else``:``    ``print``(``"The String "``, ``str``, ``" has duplicate characters"``);` `# This code contributed by PrinciRaj1992`

## C#

 `// C# program to illustrate string with``// unique characters using brute force``// technique``using` `System;` `public` `class` `GFG {` `    ``static` `bool` `uniqueCharacters(String str)``    ``{` `        ``// If at any time we encounter 2``        ``// same characters, return false``        ``for` `(``int` `i = 0; i < str.Length; i++)``            ``for` `(``int` `j = i + 1; j < str.Length; j++)``                ``if` `(str[i] == str[j])``                    ``return` `false``;` `        ``// If no duplicate characters``        ``// encountered, return true``        ``return` `true``;``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``string` `input = ``"GeeksforGeeks"``;` `        ``if` `(uniqueCharacters(input) == ``true``)``            ``Console.WriteLine(``"The String "` `+ input``                              ``+ ``" has all unique characters"``);``        ``else``            ``Console.WriteLine(``"The String "` `+ input``                              ``+ ``" has duplicate characters"``);``    ``}``}` `// This code is contributed by shiv_bhakt.`

## PHP

 ``

## Javascript

 ``

Output :

`The String GeeksforGeeks has duplicate characters`

Note: Please note that the program is case-sensitive.

Approach 2 – Sorting: Using sorting based on ASCII values of characters
Time Complexity: O(n log n)

## C++

 `// C++ program to illustrate string``// with unique characters using``// brute force technique``#include ``using` `namespace` `std;` `bool` `uniqueCharacters(string str)``{` `    ``// Using sorting``    ``sort(str.begin(), str.end());` `    ``for` `(``int` `i = 0; i < str.length()-1; i++) {` `        ``// if at any time, 2 adjacent``        ``// elements become equal,``        ``// return false``        ``if` `(str[i] == str[i + 1]) {``            ``return` `false``;``        ``}``    ``}``    ``return` `true``;``}` `// driver code``int` `main()``{` `    ``string str = ``"GeeksforGeeks"``;` `    ``if` `(uniqueCharacters(str)) {``        ``cout << ``"The String "` `<< str``             ``<< ``" has all unique characters\n"``;``    ``}``    ``else` `{` `        ``cout << ``"The String "` `<< str``             ``<< ``" has duplicate characters\n"``;``    ``}``    ``return` `0;``}``// This code is contributed by Divyam Madaan`

## Java

 `// Java program to check string with unique``// characters using sorting technique``import` `java.util.*;` `class` `GfG {``    ``/* Convert the string to character array``       ``for sorting */``    ``boolean` `uniqueCharacters(String str)``    ``{``        ``char``[] chArray = str.toCharArray();` `        ``// Using sorting``        ``// Arrays.sort() uses binarySort in the background``        ``// for non-primitives which is of O(nlogn) time complexity``        ``Arrays.sort(chArray);` `        ``for` `(``int` `i = ``0``; i < chArray.length - ``1``; i++) {``            ``// if the adjacent elements are not``            ``// equal, move to next element``            ``if` `(chArray[i] != chArray[i + ``1``])``                ``continue``;` `            ``// if at any time, 2 adjacent elements``            ``// become equal, return false``            ``else``                ``return` `false``;``        ``}``        ``return` `true``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``GfG obj = ``new` `GfG();``        ``String input = ``"GeeksforGeeks"``;` `        ``if` `(obj.uniqueCharacters(input))``            ``System.out.println(``"The String "` `+ input``                               ``+ ``" has all unique characters"``);``        ``else``            ``System.out.println(``"The String "` `+ input``                               ``+ ``" has duplicate characters"``);``    ``}``}`

## Python3

 `# Python3 program to illustrate string``# with unique characters using``# brute force technique``def` `uniqueCharacters(st):` `    ``# Using sorting``    ``st ``=` `sorted``(st)` `    ``for` `i ``in` `range``(``len``(st)``-``1``):` `        ``# if at any time, 2 adjacent``        ``# elements become equal,``        ``# return false``        ``if` `(st[i] ``=``=` `st[i ``+` `1``]) :``            ``return` `False``            ` `    ``return` `True` `# Driver code``if` `__name__``=``=``'__main__'``:` `    ``st ``=` `"GeeksforGeeks"` `    ``if` `(uniqueCharacters(st)) :``        ``print``(``"The String"``,st,``"has all unique characters\n"``)``    ` `    ``else` `:``        ``print``(``"The String"``,st,``"has duplicate characters\n"``)``    `  `# This code is contributed by AbhiThakur`

## C#

 `// C# program to check string with unique``// characters using sorting technique``using` `System;` `public` `class` `GFG {` `    ``/* Convert the string to character array``    ``for sorting */``    ``static` `bool` `uniqueCharacters(String str)``    ``{``        ``char``[] chArray = str.ToCharArray();` `        ``// Using sorting``        ``Array.Sort(chArray);` `        ``for` `(``int` `i = 0; i < chArray.Length - 1; i++) {` `            ``// if the adjacent elements are not``            ``// equal, move to next element``            ``if` `(chArray[i] != chArray[i + 1])``                ``continue``;` `            ``// if at any time, 2 adjacent elements``            ``// become equal, return false``            ``else``                ``return` `false``;``        ``}` `        ``return` `true``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``string` `input = ``"GeeksforGeeks"``;` `        ``if` `(uniqueCharacters(input) == ``true``)``            ``Console.WriteLine(``"The String "` `+ input``                              ``+ ``" has all unique characters"``);``        ``else``            ``Console.WriteLine(``"The String "` `+ input``                              ``+ ``" has duplicate characters"``);``    ``}``}` `// This code is contributed by shiv_bhakt.`

## Javascript

 ``

Output:

`The String GeeksforGeeks has duplicate characters`

Approach 3 – Use of Extra Data Structure: This approach assumes ASCII char set(8 bits). The idea is to maintain a boolean array for the characters. The 256 indices represent 256 characters. All the array elements are initially set to false. As we iterate over the string, set true at the index equal to the int value of the character. If at any time, we encounter that the array value is already true, it means the character with that int value is repeated.

Time Complexity: O(n)

## C++

 `#include ``#include ``using` `namespace` `std;` `const` `int` `MAX_CHAR = 256;` `bool` `uniqueCharacters(string str)``{` `    ``// If length is greater than 265,``    ``// some characters must have been repeated``    ``if` `(str.length() > MAX_CHAR)``        ``return` `false``;` `    ``bool` `chars[MAX_CHAR] = { 0 };``    ``for` `(``int` `i = 0; i < str.length(); i++) {``        ``if` `(chars[``int``(str[i])] == ``true``)``            ``return` `false``;` `        ``chars[``int``(str[i])] = ``true``;``    ``}``    ``return` `true``;``}` `// driver code``int` `main()``{``    ``string str = ``"GeeksforGeeks"``;` `    ``if` `(uniqueCharacters(str)) {``        ``cout << ``"The String "` `<< str``             ``<< ``" has all unique characters\n"``;``    ``}``    ``else` `{` `        ``cout << ``"The String "` `<< str``             ``<< ``" has duplicate characters\n"``;``    ``}``    ``return` `0;``}``// This code is contributed by Divyam Madaan`

## Java

 `// Java program to illustrate String With``// Unique Characters using data structure``import` `java.util.*;` `class` `GfG {``    ``int` `MAX_CHAR = ``256``;` `    ``boolean` `uniqueCharacters(String str)``    ``{``        ``// If length is greater than 256,``        ``// some characters must have been repeated``        ``if` `(str.length() > MAX_CHAR)``            ``return` `false``;` `        ``boolean``[] chars = ``new` `boolean``[MAX_CHAR];``        ``Arrays.fill(chars, ``false``);` `        ``for` `(``int` `i = ``0``; i < str.length(); i++) {``            ``int` `index = (``int``)str.charAt(i);` `            ``/* If the value is already true, string``               ``has duplicate characters, return false */``            ``if` `(chars[index] == ``true``)``                ``return` `false``;` `            ``chars[index] = ``true``;``        ``}` `        ``/* No duplicates encountered, return true */``        ``return` `true``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``GfG obj = ``new` `GfG();``        ``String input = ``"GeeksforGeeks"``;` `        ``if` `(obj.uniqueCharacters(input))``            ``System.out.println(``"The String "` `+ input``                               ``+ ``" has all unique characters"``);``        ``else``            ``System.out.println(``"The String "` `+ input``                               ``+ ``" has duplicate characters"``);``    ``}``}`

## Python3

 `# Python program to illustrate``# string with unique characters``# using data structure``MAX_CHAR ``=` `256``;` `def` `uniqueCharacters(string):``    ``n ``=` `len``(string)``    ` `    ``# If length is greater than 256,``    ``# some characters must have``    ``# been repeated``    ``if` `n > MAX_CHAR:``        ``return` `False` `    ``chars ``=` `[``False``] ``*` `MAX_CHAR` `    ``for` `i ``in` `range``(n):``        ``index ``=` `ord``(string[i])` `        ``'''``         ``* If the value is already True,``         ``string has duplicate characters,``         ``return False'''``        ``if` `(chars[index] ``=``=` `True``):``            ``return` `False` `        ``chars[index] ``=` `True` `    ``''' No duplicates encountered,``        ``return True '''``    ``return` `True` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``input` `=` `"GeeksforGeeks"``    ``if` `(uniqueCharacters(``input``)):``        ``print``(``"The String"``, ``input``,``              ``"has all unique characters"``)``    ``else``:``        ``print``(``"The String"``, ``input``,``              ``"has duplicate characters"``)` `# This code is contributed by shikhasingrajput`

## C#

 `// C# program to illustrate String With``// Unique Characters using data structure``using` `System;` `class` `GfG {``    ``static` `int` `MAX_CHAR = 256;` `    ``bool` `uniqueCharacters(String str)``    ``{``        ``// If length is greater than 256,``        ``// some characters must have been repeated``        ``if` `(str.Length > MAX_CHAR)``            ``return` `false``;` `        ``bool``[] chars = ``new` `bool``[MAX_CHAR];``        ``for` `(``int` `i = 0; i < MAX_CHAR; i++) {``            ``chars[i] = ``false``;``        ``}``        ``for` `(``int` `i = 0; i < str.Length; i++) {``            ``int` `index = (``int``)str[i];` `            ``/* If the value is already true, string``            ``has duplicate characters, return false */``            ``if` `(chars[index] == ``true``)``                ``return` `false``;` `            ``chars[index] = ``true``;``        ``}` `        ``/* No duplicates encountered, return true */``        ``return` `true``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``GfG obj = ``new` `GfG();``        ``String input = ``"GeeksforGeeks"``;` `        ``if` `(obj.uniqueCharacters(input))``            ``Console.WriteLine(``"The String "` `+ input``                              ``+ ``" has all unique characters"``);``        ``else``            ``Console.WriteLine(``"The String "` `+ input``                              ``+ ``" has duplicate characters"``);``    ``}``}` `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output:

`The String GeeksforGeeks has duplicate characters`

Approach 4 – Without Extra Data Structure: The approach is valid for strings having alphabet as a-z. This approach is a little tricky. Instead of maintaining a boolean array, we maintain an integer value called checker(32 bits). As we iterate over the string, we find the int value of the character with respect to ‘a’ with the statement int bitAtIndex = str.charAt(i)-‘a’;
Then the bit at that int value is set to 1 with the statement 1 << bitAtIndex
Now, if this bit is already set in the checker, the bit AND operation would make the checker > 0. Return false in this case.
Else Update checker to make the bit 1 at that index with the statement checker = checker | (1 <<bitAtIndex);

Time Complexity: O(n)

## C++

 `// C++ program to illustrate string``// with unique characters using``// brute force technique``#include ``using` `namespace` `std;` `bool` `uniqueCharacters(string str)``{` `    ``// Assuming string can have characters``    ``// a-z, this has 32 bits set to 0``    ``int` `checker = 0;` `    ``for` `(``int` `i = 0; i < str.length(); i++) {` `        ``int` `bitAtIndex = str[i] - ``'a'``;` `        ``// if that bit is already set in``        ``// checker, return false``        ``if` `((checker & (1 << bitAtIndex)) > 0) {``            ``return` `false``;``        ``}` `        ``// otherwise update and continue by``        ``// setting that bit in the checker``        ``checker = checker | (1 << bitAtIndex);``    ``}` `    ``// no duplicates encountered, return true``    ``return` `true``;``}` `// driver code``int` `main()``{` `    ``string str = ``"geeksforgeeks"``;` `    ``if` `(uniqueCharacters(str)) {``        ``cout << ``"The String "` `<< str``             ``<< ``" has all unique characters\n"``;``    ``}``    ``else` `{``        ``cout << ``"The String "` `<< str``             ``<< ``" has duplicate characters\n"``;``    ``}``    ``return` `0;``}``// This code is contributed by Divyam Madaan`

## Java

 `// Java program to illustrate String with unique``// characters without using any data structure``import` `java.util.*;` `class` `GfG {``    ``boolean` `uniqueCharacters(String str)``    ``{``        ``// Assuming string can have characters a-z``        ``// this has 32 bits set to 0``        ``int` `checker = ``0``;` `        ``for` `(``int` `i = ``0``; i < str.length(); i++) {``            ``int` `bitAtIndex = str.charAt(i) - ``'a'``;` `            ``// if that bit is already set in checker,``            ``// return false``            ``if` `((checker & (``1` `<< bitAtIndex)) > ``0``)``                ``return` `false``;` `            ``// otherwise update and continue by``            ``// setting that bit in the checker``            ``checker = checker | (``1` `<< bitAtIndex);``        ``}` `        ``// no duplicates encountered, return true``        ``return` `true``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``GfG obj = ``new` `GfG();``        ``String input = ``"geekforgeeks"``;` `        ``if` `(obj.uniqueCharacters(input))``            ``System.out.println(``"The String "` `+ input``                               ``+ ``" has all unique characters"``);``        ``else``            ``System.out.println(``"The String "` `+ input``                               ``+ ``" has duplicate characters"``);``    ``}``}`

## Python3

 `# Python3 program to illustrate String with unique``# characters without using any data structure``import` `math` `def` `uniqueCharacters(string):``    ` `    ``# Assuming string can have characters``    ``# a-z this has 32 bits set to 0``    ``checker ``=` `0``    ` `    ``for` `i ``in` `range``(``len``(string)):``        ``bitAtIndex ``=` `ord``(string[i]) ``-` `ord``(``'a'``)` `        ``# If that bit is already set in``        ``# checker, return False``        ``if` `((bitAtIndex) > ``0``):``            ``if` `((checker & ((``1` `<< bitAtIndex))) > ``0``):``                ``return` `False``                ` `            ``# Otherwise update and continue by``            ``# setting that bit in the checker``            ``checker ``=` `checker | (``1` `<< bitAtIndex)` `    ``# No duplicates encountered, return True``    ``return` `True` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``input` `=` `"geekforgeeks"` `    ``if` `(uniqueCharacters(``input``)):``        ``print``(``"The String "` `+` `input` `+``              ``" has all unique characters"``)``    ``else``:``        ``print``(``"The String "` `+` `input` `+``              ``" has duplicate characters"``)` `# This code is contributed by Princi Singh`

## C#

 `// C# program to illustrate String``// with unique characters without``// using any data structure``using` `System;` `class` `GFG {``    ``public` `virtual` `bool` `uniqueCharacters(``string` `str)``    ``{``        ``// Assuming string can have``        ``// characters a-z this has``        ``// 32 bits set to 0``        ``int` `checker = 0;` `        ``for` `(``int` `i = 0; i < str.Length; i++) {``            ``int` `bitAtIndex = str[i] - ``'a'``;` `            ``// if that bit is already set``            ``// in checker, return false``            ``if` `((checker & (1 << bitAtIndex)) > 0) {``                ``return` `false``;``            ``}` `            ``// otherwise update and continue by``            ``// setting that bit in the checker``            ``checker = checker | (1 << bitAtIndex);``        ``}` `        ``// no duplicates encountered,``        ``// return true``        ``return` `true``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``GFG obj = ``new` `GFG();``        ``string` `input = ``"geekforgeeks"``;` `        ``if` `(obj.uniqueCharacters(input)) {``            ``Console.WriteLine(``"The String "` `+ input + ``" has all unique characters"``);``        ``}``        ``else` `{``            ``Console.WriteLine(``"The String "` `+ input + ``" has duplicate characters"``);``        ``}``    ``}``}` `// This code is contributed by Shrikant13`

## PHP

 ` 0)``        ``{``            ``return` `false;``        ``}``        ` `    ``// otherwise update and continue by``    ``// setting that bit in the checker``    ``\$checker` `= ``\$checker` `|``               ``(1 << ``\$bitAtIndex``);``    ``}``    ` `    ``// no duplicates encountered,``    ``// return true``    ``return` `true;``}` `// Driver Code``\$str` `= ``"geeksforgeeks"``;` `if``(uniqueCharacters(``\$str``))``{``    ``echo` `"The String "``, ``\$str``,``         ``" has all unique characters\n"``;``}``else``{``    ``echo` `"The String "``, ``\$str``,``         ``" has duplicate characters\n"``;``}` `// This code is contributed by ajit``?>`

## Javascript

 ``

Output :

`The String GeekforGeeks has duplicate characters`

Exercise: Above program is case insensitive, you can try making the same program that is case sensitive i.e Geeks and GEeks both give different output.

Using Java Stream

## Java

 `import` `java.util.Collections;``import` `java.util.stream.Collectors;``class` `GfG {``    ``boolean` `uniqueCharacters(String s)``    ``{``        ``// If at any character more than once create another stream``        ``// stream count more than 0, return false``        ``return` `s.chars().filter(e-> Collections.frequency(s.chars().boxed().collect(Collectors.toList()), e) > ``1``).count() > ``1` `? ``false``: ``true``;``    ``}`` ` `    ``public` `static` `void` `main(String args[])``    ``{``        ``GfG obj = ``new` `GfG();``        ``String input = ``"GeeksforGeeks"``;`` ` `        ``if` `(obj.uniqueCharacters(input))``            ``System.out.println(``"The String "` `+ input + ``" has all unique characters"``);``        ``else``            ``System.out.println(``"The String "` `+ input + ``" has duplicate characters"``);``    ``}``}` `//Write Java code here`

Reference:
Cracking the Coding Interview by Gayle

Approach 5: Using sets() function:

• Convert the string to set.
• If the length of set is equal to the length of the string then return True else False.

Below is the implementation of the above approach

## C++

 `// C++ program to illustrate String with unique``// characters using set data structure``#include ``using` `namespace` `std;` `bool` `uniqueCharacters(string str)``{``    ``set<``char``> char_set;` `    ``// Inserting character of string into set``    ``for``(``char` `c : str)``    ``{``        ``char_set.insert(c);``    ``}` `    ``// If length of set is equal to len of string``    ``// then it will have unique characters``    ``return` `char_set.size() == str.size();``}` `// Driver code``int` `main()``{``    ``string str = ``"GeeksforGeeks"``;` `    ``if` `(uniqueCharacters(str))``    ``{``        ``cout << ``"The String "` `<< str``             ``<< ``" has all unique characters\n"``;``    ``}``    ``else``    ``{``        ``cout << ``"The String "` `<< str``             ``<< ``" has duplicate characters\n"``;``    ``}``    ``return` `0;``}` `// This code is contributed by abhishekjha558498`

## Java

 `// Java program to illustrate String with unique``// characters using set data structure``import` `java.util.*;` `class` `GFG{` `static` `boolean` `uniqueCharacters(String str)``{``    ``HashSet char_set = ``new` `HashSet<>();` `    ``// Inserting character of String into set``    ``for``(``int` `c  = ``0``; c< str.length();c++)``    ``{``        ``char_set.add(str.charAt(c));``    ``}` `    ``// If length of set is equal to len of String``    ``// then it will have unique characters``    ``return` `char_set.size() == str.length();``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``String str = ``"GeeksforGeeks"``;` `    ``if` `(uniqueCharacters(str))``    ``{``        ``System.out.print(``"The String "` `+  str``            ``+ ``" has all unique characters\n"``);``    ``}``    ``else``    ``{``        ``System.out.print(``"The String "` `+  str``            ``+ ``" has duplicate characters\n"``);``    ``}``}``}`  `// This code contributed by umadevi9616`

## Python3

 `# Python3 program to illustrate String with unique``# characters``def` `uniqueCharacters(``str``):``  ` `    ``# Converting string to set``    ``setstring ``=` `set``(``str``)``    ` `    ``# If length of set is equal to len of string``    ``# then it will have unique characters``    ``if``(``len``(setstring) ``=``=` `len``(``str``)):``        ``return` `True``      ` `    ``return` `False`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``input` `=` `"GeeksforGeeks"` `    ``if` `(uniqueCharacters(``input``)):``        ``print``(``"The String "` `+` `input` `+``              ``" has all unique characters"``)``    ``else``:``        ``print``(``"The String "` `+` `input` `+``              ``" has duplicate characters"``)` `# This code is contributed by vikkycirus`

## C#

 `// C# program to illustrate String with unique``// characters using set data structure``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `    ``static` `bool` `uniquechars(String str)``    ``{``        ``HashSet<``char``> char_set = ``new` `HashSet<``char``>();` `        ``// Inserting character of String into set``        ``for` `(``int` `c = 0; c < str.Length; c++) {``            ``char_set.Add(str);``        ``}` `        ``// If length of set is equal to len of String``        ``// then it will have unique characters``        ``if` `(char_set.Count == str.Length) {``            ``return` `true``;``        ``}``        ``else` `{``            ``return` `false``;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String str = ``"GeeksforGeeks"``;` `        ``if` `(uniquechars(str)) {``            ``Console.Write(``"The String "` `+ str``                          ``+ ``" has all unique characters\n"``);``        ``}``        ``else` `{``            ``Console.Write(``"The String "` `+ str``                          ``+ ``" has duplicate characters\n"``);``        ``}``    ``}``}` `// This code is contributed by umadevi9616`

## Javascript

 ``

Output:

`The String GeeksforGeeks has duplicate characters`

Time Complexity: O(nlogn)

Auxiliary Space: O(n)

This article is contributed by Saloni Baweja. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.