Check if a string contains all unique characters

Here given code implementation process.

// C Program for
// Check if a string contains all unique characters
#include <stdio.h>
#include <string.h>

void isUniqueCharacters(char *text)
{
	int n = strlen(text);

	if(n == 0)
	{
		// Empty String
		return;
	}
	int characters[255];
	// Set initial frequency
	for (int i = 0; i < 255; ++i)
	{
		characters[i] = 0;
	}

	printf("\n Given text  : %s ", text);
	
	// Count frequency of character element
	for (int i = 0; i < n; ++i)
	{

		characters[text[i]-'0'] ++;

		if(characters[text[i]-'0'] > 1)
		{
			// When characters are repeated
			printf("\n  No ");
			return;
		}
	}
	// When all characters unique 
	printf("\n  Yes ");

}
int main(int argc, char const *argv[])
{
	// Test
	isUniqueCharacters("xyzklsadfl");
	isUniqueCharacters("3424789dfkj");
	isUniqueCharacters("kalicodes");
	isUniqueCharacters("908");
	return 0;
}

Output

 Given text  : xyzklsadfl
  No
 Given text  : 3424789dfkj
  No
 Given text  : kalicodes
  Yes
 Given text  : 908
  Yes

// Java program for
// Check if a string contains all unique characters
public class UniqueCharacters
{
	public void isUniqueCharacters(String text)
	{
		int n = text.length();
		if (n == 0)
		{
			// Empty String
			return;
		}
		boolean[] characters = new boolean[255];
		// Set initial frequency
		for (int i = 0; i < 255; ++i)
		{
			characters[i] = false;
		}
		System.out.print("\n Given text : " + text);
		// Count frequency of character element
		for (int i = 0; i < n; ++i)
		{
			if (characters[text.charAt(i) - '0'] == true)
			{
				// When characters are repeated
				System.out.print("\n No ");
				return;
			}
			else
			{
				characters[text.charAt(i) - '0'] = true;
			}
		}
		// When all characters unique 
		System.out.print("\n Yes ");
	}
	public static void main(String[] args)
	{
		UniqueCharacters task = new UniqueCharacters();
		// Test
		task.isUniqueCharacters("xyzklsadfl");
		task.isUniqueCharacters("3424789dfkj");
		task.isUniqueCharacters("kalicodes");
		task.isUniqueCharacters("908");
	}
}

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

// Include header file
#include <iostream>
#include <string>

using namespace std;
// C++ program for
// Check if a string contains all unique characters
class UniqueCharacters
{
	public: void isUniqueCharacters(string text)
	{
		int n = text.length();
		if (n == 0)
		{
			// Empty String
			return;
		}
		bool characters[255];
		// Set initial frequency
		for (int i = 0; i < 255; ++i)
		{
			characters[i] = false;
		}
		cout << "\n Given text : " << text;
		// Count frequency of character element
		for (int i = 0; i < n; ++i)
		{
			if (characters[text[i] - '0'] == true)
			{
				// When characters are repeated
				cout << "\n No ";
				return;
			}
			else
			{
				characters[text[i] - '0'] = true;
			}
		}
		// When all characters unique 
		cout << "\n Yes ";
	}
};
int main()
{
	UniqueCharacters *task = new UniqueCharacters();
	// Test
	task->isUniqueCharacters("xyzklsadfl");
	task->isUniqueCharacters("3424789dfkj");
	task->isUniqueCharacters("kalicodes");
	task->isUniqueCharacters("908");
	return 0;
}

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

package main
import "fmt"
// Go program for
// Check if a string contains all unique characters
type UniqueCharacters struct {}
func getUniqueCharacters() * UniqueCharacters {
	var me *UniqueCharacters = &UniqueCharacters {}
	return me
}
func(this UniqueCharacters) isUniqueCharacters(text string) {
	var n int = len(text)
	if n == 0 {
		// Empty String
		return
	}
	var characters = make([] bool, 255)
	// Set initial frequency
	for i := 0 ; i < 255 ; i++ {
		characters[i] = false
	}
	fmt.Print("\n Given text : ", text)
	// Count frequency of character element
	for i := 0 ; i < n ; i++ {
		if characters[text[i] - '0'] == true {
			// When characters are repeated
			fmt.Print("\n No ")
			return
		} else {
			characters[text[i] - '0'] = true
		}
	}
	// When all characters unique 
	fmt.Print("\n Yes ")
}
func main() {
	var task * UniqueCharacters = getUniqueCharacters()
	// Test
	task.isUniqueCharacters("xyzklsadfl")
	task.isUniqueCharacters("3424789dfkj")
	task.isUniqueCharacters("kalicodes")
	task.isUniqueCharacters("908")
}

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

// Include namespace system
using System;
// Csharp program for
// Check if a string contains all unique characters
public class UniqueCharacters
{
	public void isUniqueCharacters(String text)
	{
		int n = text.Length;
		if (n == 0)
		{
			// Empty String
			return;
		}
		Boolean[] characters = new Boolean[255];
		// Set initial frequency
		for (int i = 0; i < 255; ++i)
		{
			characters[i] = false;
		}
		Console.Write("\n Given text : " + text);
		// Count frequency of character element
		for (int i = 0; i < n; ++i)
		{
			if (characters[text[i] - '0'] == true)
			{
				// When characters are repeated
				Console.Write("\n No ");
				return;
			}
			else
			{
				characters[text[i] - '0'] = true;
			}
		}
		// When all characters unique 
		Console.Write("\n Yes ");
	}
	public static void Main(String[] args)
	{
		UniqueCharacters task = new UniqueCharacters();
		// Test
		task.isUniqueCharacters("xyzklsadfl");
		task.isUniqueCharacters("3424789dfkj");
		task.isUniqueCharacters("kalicodes");
		task.isUniqueCharacters("908");
	}
}

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

<?php
// Php program for
// Check if a string contains all unique characters
class UniqueCharacters
{
	public	function isUniqueCharacters($text)
	{
		$n = strlen($text);
		if ($n == 0)
		{
			// Empty String
			return;
		}
		$characters = array_fill(0, 255, false);
		echo("\n Given text : ".$text);
		// Count frequency of character element
		for ($i = 0; $i < $n; ++$i)
		{
			if ($characters[ord($text[$i]) - ord('0')] == true)
			{
				// When characters are repeated
				echo("\n No ");
				return;
			}
			else
			{
				$characters[ord($text[$i]) - ord('0')] = true;
			}
		}
		// When all characters unique 
		echo("\n Yes ");
	}
}

function main()
{
	$task = new UniqueCharacters();
	// Test
	$task->isUniqueCharacters("xyzklsadfl");
	$task->isUniqueCharacters("3424789dfkj");
	$task->isUniqueCharacters("kalicodes");
	$task->isUniqueCharacters("908");
}
main();

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

// Node JS program for
// Check if a string contains all unique characters
class UniqueCharacters
{
	isUniqueCharacters(text)
	{
		var n = text.length;
		if (n == 0)
		{
			// Empty String
			return;
		}
		var characters = Array(255).fill(false);
		process.stdout.write("\n Given text : " + text);
		// Count frequency of character element
		for (var i = 0; i < n; ++i)
		{
			if (characters[text.charCodeAt(i) - '0'.charCodeAt(0)] == true)
			{
				// When characters are repeated
				process.stdout.write("\n No ");
				return;
			}
			else
			{
				characters[text.charCodeAt(i) - '0'.charCodeAt(0)] = true;
			}
		}
		// When all characters unique 
		process.stdout.write("\n Yes ");
	}
}

function main()
{
	var task = new UniqueCharacters();
	// Test
	task.isUniqueCharacters("xyzklsadfl");
	task.isUniqueCharacters("3424789dfkj");
	task.isUniqueCharacters("kalicodes");
	task.isUniqueCharacters("908");
}
main();

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

#  Python 3 program for
#  Check if a string contains all unique characters
class UniqueCharacters :
	def isUniqueCharacters(self, text) :
		n = len(text)
		if (n == 0) :
			#  Empty String
			return
		
		characters = [False] * (255)
		print("\n Given text : ", text, end = "")
		i = 0
		#  Count frequency of character element
		while (i < n) :
			if (characters[ord(text[i]) - ord('0')] == True) :
				#  When characters are repeated
				print("\n No ", end = "")
				return
			else :
				characters[ord(text[i]) - ord('0')] = True
			
			i += 1
		
		#  When all characters unique 
		print("\n Yes ", end = "")
	

def main() :
	task = UniqueCharacters()
	#  Test
	task.isUniqueCharacters("xyzklsadfl")
	task.isUniqueCharacters("3424789dfkj")
	task.isUniqueCharacters("kalicodes")
	task.isUniqueCharacters("908")

if __name__ == "__main__": main()

Output

 Given text :  xyzklsadfl
 No
 Given text :  3424789dfkj
 No
 Given text :  kalicodes
 Yes
 Given text :  908
 Yes

#  Ruby program for
#  Check if a string contains all unique characters
class UniqueCharacters 
	def isUniqueCharacters(text) 
		n = text.length
		if (n == 0) 
			#  Empty String
			return
		end

		characters = Array.new(255) {false}
		print("\n Given text : ", text)
		i = 0
		#  Count frequency of character element
		while (i < n) 
			if (characters[text[i].ord - '0'.ord] == true) 
				#  When characters are repeated
				print("\n No ")
				return
			else
 
				characters[text[i].ord - '0'.ord] = true
			end

			i += 1
		end

		#  When all characters unique 
		print("\n Yes ")
	end

end

def main() 
	task = UniqueCharacters.new()
	#  Test
	task.isUniqueCharacters("xyzklsadfl")
	task.isUniqueCharacters("3424789dfkj")
	task.isUniqueCharacters("kalicodes")
	task.isUniqueCharacters("908")
end

main()

Output

 Given text : xyzklsadfl
 No 
 Given text : 3424789dfkj
 No 
 Given text : kalicodes
 Yes 
 Given text : 908
 Yes

import scala.collection.mutable._;
// Scala program for
// Check if a string contains all unique characters
class UniqueCharacters()
{
	def isUniqueCharacters(text: String): Unit = {
		var n: Int = text.length();
		if (n == 0)
		{
			// Empty String
			return;
		}
		var characters: Array[Boolean] = Array.fill[Boolean](255)(false);
		print("\n Given text : " + text);
		var i: Int = 0;
		// Count frequency of character element
		while (i < n)
		{
			if (characters(text.charAt(i).toInt - '0'.toInt) == true)
			{
				// When characters are repeated
				print("\n No ");
				return;
			}
			else
			{
				characters(text.charAt(i).toInt - '0'.toInt) = true;
			}
			i += 1;
		}
		// When all characters unique 
		print("\n Yes ");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: UniqueCharacters = new UniqueCharacters();
		// Test
		task.isUniqueCharacters("xyzklsadfl");
		task.isUniqueCharacters("3424789dfkj");
		task.isUniqueCharacters("kalicodes");
		task.isUniqueCharacters("908");
	}
}

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

import Foundation;
// Swift 4 program for
// Check if a string contains all unique characters
class UniqueCharacters
{
	func isUniqueCharacters(_ data: String)
	{
      	let text = Array(data);
		let n: Int = text.count;
		if (n == 0)
		{
			// Empty String
			return;
		}
		var characters: [Bool] = Array(repeating: false, count: 255);
		print("\n Given text : ", data, terminator: "");
		var i: Int = 0;
		// Count frequency of character element
		while (i < n)
		{
			if (characters[Int(UnicodeScalar(String(text[i]))!.value) -
                           Int(UnicodeScalar(String("0"))!.value)] == true)
			{
				// When characters are repeated
				print("\n No ", terminator: "");
				return;
			}
			else
			{
				characters[Int(UnicodeScalar(String(text[i]))!.value) - 
                           Int(UnicodeScalar(String("0"))!.value)] = true;
			}
			i += 1;
		}
		// When all characters unique 
		print("\n Yes ", terminator: "");
	}
}
func main()
{
	let task: UniqueCharacters = UniqueCharacters();
	// Test
	task.isUniqueCharacters("xyzklsadfl");
	task.isUniqueCharacters("3424789dfkj");
	task.isUniqueCharacters("kalicodes");
	task.isUniqueCharacters("908");
}
main();

Output

 Given text :  xyzklsadfl
 No
 Given text :  3424789dfkj
 No
 Given text :  kalicodes
 Yes
 Given text :  908
 Yes

// Kotlin program for
// Check if a string contains all unique characters
class UniqueCharacters
{
	fun isUniqueCharacters(text: String): Unit
	{
		val n: Int = text.length;
		if (n == 0)
		{
			// Empty String
			return;
		}
		val characters: Array < Boolean > = Array(255)
		{
			false
		};
		print("\n Given text : " + text);
		var i: Int = 0;
		// Count frequency of character element
		while (i < n)
		{
			if (characters[text.get(i).toInt() - '0'.toInt()] == true)
			{
				// When characters are repeated
				print("\n No ");
				return;
			}
			else
			{
				characters[text.get(i).toInt() - '0'.toInt()] = true;
			}
			i += 1;
		}
		// When all characters unique 
		print("\n Yes ");
	}
}
fun main(args: Array < String > ): Unit
{
	val task: UniqueCharacters = UniqueCharacters();
	// Test
	task.isUniqueCharacters("xyzklsadfl");
	task.isUniqueCharacters("3424789dfkj");
	task.isUniqueCharacters("kalicodes");
	task.isUniqueCharacters("908");
}

Output

 Given text : xyzklsadfl
 No
 Given text : 3424789dfkj
 No
 Given text : kalicodes
 Yes
 Given text : 908
 Yes

« Previous Next »

String

Display all True Boolean expression

Display all palindromic substring by max length

Display palindrome in rotated string

Swap characters in string

Count special characters in string

Count number of vowels in a string

Camel Case Program

Capitalize each word in string

Capitalize first letter in word

Sum of digits in a string

Sum of numbers in string

Sum of two string numbers

Sum of two binary strings

Multiply two string numbers

Remove vowels from a string

Remove numbers from string

Remove consecutive vowels from string

Remove spaces from a given string

Remove extra spaces from a string

Remove specific word from string

Reverse alternate k characters in a string

Remove consecutive duplicate characters in a string

Count number of words in a string

Move all spaces at beginning of string

Move all spaces at the middle of string

Move all spaces at end of string

Transform string character to opposite case

Check if two given strings are isomorphic

Check if a string is substring of another string

Check if a string is suffix of another string

Check if a number is divisible by 4

Check if one string is a subsequence of another string

Check pangrams in given string

Check if two strings are equal

Print all substrings of a given string

Print all rotations in string

Find longest substring of unique characters

Find largest number in string

Find and replace given pattern by given character

Find longest substring with repeating characters

Find number of uppercase and lowercase letters in a string

Find longest word in string

Transform string to url slug

Find the length of longest word in string

Replace substring with a another string

Reverse the string elements

Reverse words in a given string

Rotate each words in a string

Left and right rotation of string

Convert string to number

Calculate the Hamming distance between two strings

Minimum add to make parentheses valid

Difference between two large numbers

Find out distance between similar characters in a string

Find 2s complement of a binary string

Find the first non-repeating character of string

Check if any permutation of string is palindrome

Longest subsequence with different adjacent characters

Random character selection from string

Perform string shifts by intervals

Check if two strings differ by one character

Toggle alphabet characters in a string

Reverse a string without affecting special characters

Kth non repeating character in a string

Print alphabets from A to Z

Minimum number of append character needed to make a string palindrome

Minimum number of perpend character needed to Make a string palindrome

Minimum number of characters to be removed to make a string alternate

Number of flips to make binary string alternate

Caesar Cipher

Split string by word

Split the string into N equal parts

Return most occurring character in an input string

Addition of binary strings

Find 1s complement of a binary string

Find if a string is interleaved of two other strings

Remove recurring digits in a given number

Calculate sum of all numbers present in a string

Length of the longest substring without repeating characters

Lexicographic rank of a string

Check if a given string is a cyclic palindrome

Find unique character in a string

Count number of unique characters in a string

Find the second most frequent character in a given string

Lexicographically minimum string rotation

Check if a string is an interleaving of two other strings

Transform one string to another using minimum number of operation

Longest palindromic substring solution

Run length encoding

Print duplicate characters from string

Check whether one string is rotation of another

Shortest window that include all characters of another string

Divide a string into n equal parts

Check if a given string is a valid number

Longest Uncommon Subsequence

Interleaving of two given strings with no common characters

Check if permutation of a number is same to other number

Check whether given string contains all the digits from 0 to 9

Check if string contains only digits

Check if a string contains all unique characters

Check if a string contains only alphabets

Remove all characters in a string except alphabet

Reduce the string by removing k consecutive identical characters

Check if a character is present in a string

Remove 3 or more consecutive characters from a string

Check if string contains only 0 and 1

Remove consecutive alphabets which are in same type

Print last character of every word in a string

Remove characters that appear more than k times

Remove characters from a string that appears exactly K times

Remove all frequencies less than k characters from string

Capitalize the first and last letter of each word of a String

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment

Name