Find shortest unique prefix for every word in a given list

Here given code implementation process.

/*
  Java program
  Find shortest unique prefix for every word in a given list
*/
class TreeNode
{
    // Indicates end of string
    public boolean last;
    public TreeNode[] children;
    public int count;
    public TreeNode()
    {
        this.last = false;
        this.children = new TreeNode[26];
        this.count = 1;
    }
}
public class Trie
{
    public TreeNode root;
    public Trie()
    {
        this.root = new TreeNode();
    }
    public void insert(String text)
    {
        // First get the length of text
        int length = text.length();
        // This variable are used to task find the index location of character
        int index = 0;
        // Get the root node
        TreeNode head = this.root;
        for (int level = 0; level < length; level++)
        {
            // Get the index
            index = text.charAt(level) - 'a';
            if (head.children[index] == null)
            {
                // When need to add new Node
                head.children[index] = new TreeNode();
            }
            else
            {
                head.children[index].count++;
            }
            head = head.children[index];
        }
        if (head != null)
        {
            // indicates end of string
            head.last = true;
        }
    }
    public void shortestPrefix(TreeNode head, String output)
    {
        if (head != null)
        {
            for (int i = 0; i < 26; ++i)
            {
                if (head.children[i] != null)
                {
                    if (head.children[i].count == 1)
                    {
                        // Display Result
                        System.out.println(output + ((char)(i + 97)));
                    }
                    else
                    {
                        // Find short prefix
                        shortestPrefix(head.children[i], output + ((char)(i + 97)));
                    }
                }
            }
        }
    }
    public static void main(String[] args)
    {
        // Make Tree
        Trie task = new Trie();
        // Add word
        task.insert("bring");
        task.insert("workout");
        task.insert("break");
        task.insert("word");
        task.insert("works");
        task.insert("wordlike");
        task.insert("bress");


        // Test
        // ----
        // ➀ ["bring","break","bress"] this start with "br"
        //   Scan "br"
        //  "bring"
        //   --
        //      
        //  "break"  
        //   --│    
        //     ↓      
        //  "bress"   unique["bri", "brea","bres"]
        //   --       Note "bre" common in ["break","bress"]
        // ------------------------------------------------------
        //                    -      -      -
        // ➁ ["word","wordlike",workout","works"] this start with "wor"
        //  Scan "wor"
        //  "word" 
        //   ---│
        //      ↓
        //  "wordlike"
        //            Common in both is "word" unique ["wordl"]
        //            Note not taken "word" because after d no character
        //  "workout"
        //   ---│
        //      ↓
        //  "works"
        //        Common in both is "work" unique ["worko","works"]   
        // ------------------------------------------------------
        // Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
        task.shortestPrefix(task.root, "");
    }
}

Output

brea
bres
bri
wordl
worko
works

// Include header file
#include <iostream>
#include <string>
using namespace std;
/*
  C++ program
  Find shortest unique prefix for every word in a given list
*/
class TreeNode
{
	public:
	// Indicates end of string
	bool last;
    TreeNode *children[26];
	int count;
    TreeNode()
    {
        this->last = false;
        for (int i = 0; i < 26; ++i)
        {
            this->children[i] = NULL;
        }
      	this->count = 1;
    }
};
class Trie
{
	public: TreeNode *root;
	Trie()
	{
		this->root = new TreeNode();
	}
	void insert(string text)
	{
		// First get the length of text
		int length = text.length();
		// This variable are used to task find the index location of character
		int index = 0;
		// Get the root node
		TreeNode *head = this->root;
		for (int level = 0; level < length; level++)
		{
			// Get the index
			index = text[level] - 'a';
			if (head->children[index] == NULL)
			{
				// When need to add new Node
				head->children[index] = new TreeNode();
			}
			else
			{
				head->children[index]->count++;
			}
			head = head->children[index];
		}
		if (head != NULL)
		{
			// indicates end of string
			head->last = true;
		}
	}
	void shortestPrefix(TreeNode *head, string output)
	{
		if (head != NULL)
		{
			for (int i = 0; i < 26; ++i)
			{
				if (head->children[i] != NULL)
				{
					if (head->children[i]->count == 1)
					{
						// Display Result
						cout << output + ((char)(i + 97)) << endl;
					}
					else
					{
						// Find short prefix
						this->shortestPrefix(
                          head->children[i], output  +  
                          (((char)(i + 97))));
					}
				}
			}
		}
	}
};
int main()
{
	// Make Tree
	Trie *task = new Trie();
	// Add word
	task->insert("bring");
	task->insert("workout");
	task->insert("break");
	task->insert("word");
	task->insert("works");
	task->insert("wordlike");
	task->insert("bress");
	// Test
	// ----
	// ➀ ["bring","break","bress"] this start with "br"
	//   Scan "br"
	//  "bring"
	//   --
	//      
	//  "break"  
	//   --│    
	//     ↓      
	//  "bress"   unique["bri", "brea","bres"]
	//   --       Note "bre" common in ["break","bress"]
	// ------------------------------------------------------
	//                    -      -      -
	// ➁ ["word","wordlike",workout","works"] this start with "wor"
	//  Scan "wor"
	//  "word" 
	//   ---│
	//      ↓
	//  "wordlike"
	//            Common in both is "word" unique ["wordl"]
	//            Note not taken "word" because after d no character
	//  "workout"
	//   ---│
	//      ↓
	//  "works"
	//        Common in both is "work" unique ["worko","works"]   
	// ------------------------------------------------------
	// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	task->shortestPrefix(task->root, "");
	return 0;
}

Output

brea
bres
bri
wordl
worko
works

package main
import "fmt"
/*
  Go program
  Find shortest unique prefix for every word in a given list
*/
type TreeNode struct {
	// Indicates end of string
	last bool
	children [] *TreeNode 
	count int
}
func getTreeNode() * TreeNode {
	var me *TreeNode = &TreeNode {}
	me.last = false
	me.children = make([] *TreeNode, 26)
	me.count = 1
	return me
}
type Trie struct {
	root * TreeNode
}
func getTrie() * Trie {
	var me *Trie = &Trie {}
	me.root = getTreeNode()
	return me
}
func(this Trie) insert(text string) {
	// First get the length of text
	var length int = len(text)
	// This variable are used to task find the index location of character
	var index int = 0
	// Get the root node
	var head * TreeNode = this.root
	for level := 0 ; level < length ; level++ {
		// Get the index
		index = int(text[level]) - int('a')
		if head.children[index] == nil {
			// When need to add new Node
			head.children[index] = getTreeNode()
		} else {
			head.children[index].count++
		}
		head = head.children[index]
	}
	if head != nil {
		// indicates end of string
		head.last = true
	}
}
func(this Trie) shortestPrefix(head * TreeNode, output string) {
	if head != nil {
		for i := 0 ; i < 26 ; i++ {
			if head.children[i] != nil {
				if head.children[i].count == 1 {
					// Display Result
					fmt.Println(output+string(byte((i + 97))))
				} else {
					// Find short prefix
					this.shortestPrefix(head.children[i], 
						output + string((byte((i + 97)))))
				}
			}
		}
	}
}
func main() {
	// Make Tree
	var task * Trie = getTrie()
	// Add word
	task.insert("bring")
	task.insert("workout")
	task.insert("break")
	task.insert("word")
	task.insert("works")
	task.insert("wordlike")
	task.insert("bress")
	// Test
	// ----
	// ➀ ["bring","break","bress"] this start with "br"
	//   Scan "br"
	//  "bring"
	//   --
	//      
	//  "break"  
	//   --│    
	//     ↓      
	//  "bress"   unique["bri", "brea","bres"]
	//   --       Note "bre" common in ["break","bress"]
	// ------------------------------------------------------
	//                    -      -      -
	// ➁ ["word","wordlike",workout","works"] this start with "wor"
	//  Scan "wor"
	//  "word" 
	//   ---│
	//      ↓
	//  "wordlike"
	//            Common in both is "word" unique ["wordl"]
	//            Note not taken "word" because after d no character
	//  "workout"
	//   ---│
	//      ↓
	//  "works"
	//        Common in both is "work" unique ["worko","works"]   
	// ------------------------------------------------------
	// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	task.shortestPrefix(task.root, "")
}

Output

brea
bres
bri
wordl
worko
works

// Include namespace system
using System;
/*
  Csharp program
  Find shortest unique prefix for every word in a given list
*/
public class TreeNode
{
	// Indicates end of string
	public Boolean last;
	public TreeNode[] children;
	public int count;
	public TreeNode()
	{
		this.last = false;
		this.children = new TreeNode[26];
		this.count = 1;
	}
}
public class Trie
{
	public TreeNode root;
	public Trie()
	{
		this.root = new TreeNode();
	}
	public void insert(String text)
	{
		// First get the length of text
		int length = text.Length;
		// This variable are used to task find the index location of character
		int index = 0;
		// Get the root node
		TreeNode head = this.root;
		for (int level = 0; level < length; level++)
		{
			// Get the index
			index = text[level] - 'a';
			if (head.children[index] == null)
			{
				// When need to add new Node
				head.children[index] = new TreeNode();
			}
			else
			{
				head.children[index].count++;
			}
			head = head.children[index];
		}
		if (head != null)
		{
			// indicates end of string
			head.last = true;
		}
	}
	public void shortestPrefix(TreeNode head, String output)
	{
		if (head != null)
		{
			for (int i = 0; i < 26; ++i)
			{
				if (head.children[i] != null)
				{
					if (head.children[i].count == 1)
					{
						// Display Result
						Console.WriteLine(output + ((char)(i + 97)));
					}
					else
					{
						// Find short prefix
						this.shortestPrefix(head.children[i], 
                                            output + ((char)(i + 97)));
					}
				}
			}
		}
	}
	public static void Main(String[] args)
	{
		// Make Tree
		Trie task = new Trie();
		// Add word
		task.insert("bring");
		task.insert("workout");
		task.insert("break");
		task.insert("word");
		task.insert("works");
		task.insert("wordlike");
		task.insert("bress");
		// Test
		// ----
		// ➀ ["bring","break","bress"] this start with "br"
		//   Scan "br"
		//  "bring"
		//   --
		//      
		//  "break"  
		//   --│    
		//     ↓      
		//  "bress"   unique["bri", "brea","bres"]
		//   --       Note "bre" common in ["break","bress"]
		// ------------------------------------------------------
		//                    -      -      -
		// ➁ ["word","wordlike",workout","works"] this start with "wor"
		//  Scan "wor"
		//  "word" 
		//   ---│
		//      ↓
		//  "wordlike"
		//            Common in both is "word" unique ["wordl"]
		//            Note not taken "word" because after d no character
		//  "workout"
		//   ---│
		//      ↓
		//  "works"
		//        Common in both is "work" unique ["worko","works"]   
		// ------------------------------------------------------
		// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
		task.shortestPrefix(task.root, "");
	}
}

Output

brea
bres
bri
wordl
worko
works

<?php
/*
  Php program
  Find shortest unique prefix for every word in a given list
*/
class TreeNode
{
	// Indicates end of string
	public $last;
	public $children;
	public $count;
	public	function __construct()
	{
		$this->last = false;
		$this->children = array_fill(0, 26, NULL);
		$this->count = 1;
	}
}
class Trie
{
	public $root;
	public	function __construct()
	{
		$this->root = new TreeNode();
	}
	public	function insert($text)
	{
		// First get the length of text
		$length = strlen($text);
		// This variable are used to task find the index location of character
		$index = 0;
		// Get the root node
		$head = $this->root;
		for ($level = 0; $level < $length; $level++)
		{
			// Get the index
			$index = ord($text[$level]) - ord('a');
			if ($head->children[$index] == NULL)
			{
				// When need to add new Node
				$head->children[$index] = new TreeNode();
			}
			else
			{
				$head->children[$index]->count++;
			}
			$head = $head->children[$index];
		}
		if ($head != NULL)
		{
			// indicates end of string
			$head->last = true;
		}
	}
	public	function shortestPrefix($head, $output)
	{
		if ($head != NULL)
		{
			for ($i = 0; $i < 26; ++$i)
			{
				if ($head->children[$i] != NULL)
				{
					if ($head->children[$i]->count == 1)
					{
						// Display Result
						echo($output.(chr(($i + 97))).
							"\n");
					}
					else
					{
						// Find short prefix
						$this->shortestPrefix($head->children[$i],
                                              $output.strval((chr(($i + 97)))));
					}
				}
			}
		}
	}
}

function main()
{
	// Make Tree
	$task = new Trie();
	// Add word
	$task->insert("bring");
	$task->insert("workout");
	$task->insert("break");
	$task->insert("word");
	$task->insert("works");
	$task->insert("wordlike");
	$task->insert("bress");
	// Test
	// ----
	// ➀ ["bring","break","bress"] this start with "br"
	//   Scan "br"
	//  "bring"
	//   --
	//      
	//  "break"  
	//   --│    
	//     ↓      
	//  "bress"   unique["bri", "brea","bres"]
	//   --       Note "bre" common in ["break","bress"]
	// ------------------------------------------------------
	//                    -      -      -
	// ➁ ["word","wordlike",workout","works"] this start with "wor"
	//  Scan "wor"
	//  "word" 
	//   ---│
	//      ↓
	//  "wordlike"
	//            Common in both is "word" unique ["wordl"]
	//            Note not taken "word" because after d no character
	//  "workout"
	//   ---│
	//      ↓
	//  "works"
	//        Common in both is "work" unique ["worko","works"]   
	// ------------------------------------------------------
	// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	$task->shortestPrefix($task->root, "");
}
main();

Output

brea
bres
bri
wordl
worko
works

/*
  Node JS program
  Find shortest unique prefix for every word in a given list
*/
class TreeNode
{
	constructor()
	{
		this.last = false;
		this.children = Array(26).fill(null);
		this.count = 1;
	}
}
class Trie
{
	constructor()
	{
		this.root = new TreeNode();
	}
	insert(text)
	{
		// First get the length of text
		var length = text.length;
		// This variable are used to task find the index location of character
		var index = 0;
		// Get the root node
		var head = this.root;
		for (var level = 0; level < length; level++)
		{
			// Get the index
			index = text.charAt(level).charCodeAt(0) - 'a'.charCodeAt(0);
			if (head.children[index] == null)
			{
				// When need to add new Node
				head.children[index] = new TreeNode();
			}
			else
			{
				head.children[index].count++;
			}
			head = head.children[index];
		}
		if (head != null)
		{
			// indicates end of string
			head.last = true;
		}
	}
	shortestPrefix(head, output)
	{
		if (head != null)
		{
			for (var i = 0; i < 26; ++i)
			{
				if (head.children[i] != null)
				{
					if (head.children[i].count == 1)
					{
						// Display Result
						console.log(output + (String.fromCharCode((i + 97))));
					}
					else
					{
						// Find short prefix
						this.shortestPrefix(head.children[i], 
                               output + (String.fromCharCode((i + 97))));
					}
				}
			}
		}
	}
}

function main()
{
	// Make Tree
	var task = new Trie();
	// Add word
	task.insert("bring");
	task.insert("workout");
	task.insert("break");
	task.insert("word");
	task.insert("works");
	task.insert("wordlike");
	task.insert("bress");
	// Test
	// ----
	// ➀ ["bring","break","bress"] this start with "br"
	//   Scan "br"
	//  "bring"
	//   --
	//      
	//  "break"  
	//   --│    
	//     ↓      
	//  "bress"   unique["bri", "brea","bres"]
	//   --       Note "bre" common in ["break","bress"]
	// ------------------------------------------------------
	//                    -      -      -
	// ➁ ["word","wordlike",workout","works"] this start with "wor"
	//  Scan "wor"
	//  "word" 
	//   ---│
	//      ↓
	//  "wordlike"
	//            Common in both is "word" unique ["wordl"]
	//            Note not taken "word" because after d no character
	//  "workout"
	//   ---│
	//      ↓
	//  "works"
	//        Common in both is "work" unique ["worko","works"]   
	// ------------------------------------------------------
	// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	task.shortestPrefix(task.root, "");
}
main();

Output

brea
bres
bri
wordl
worko
works

#  Python 3 program
#  Find shortest unique prefix for every word in a given list
class TreeNode :
	
	def __init__(self) :
    	#  Indicates end of string
		self.last = False
		self.children = [None] * (26)
		self.count = 1
	

class Trie :
	def __init__(self) :
		self.root = TreeNode()
	
	def insert(self, text) :
		#  First get the length of text
		length = len(text)
		#  This variable are used to task find the index location of character
		index = 0
		#  Get the root node
		head = self.root
		level = 0
		while (level < length) :
			#  Get the index
			index = ord(text[level]) - ord('a')
			if (head.children[index] == None) :
				#  When need to add new Node
				head.children[index] = TreeNode()
			else :
				head.children[index].count += 1
			
			head = head.children[index]
			level += 1
		
		if (head != None) :
			#  indicates end of string
			head.last = True
		
	
	def shortestPrefix(self, head, output) :
		if (head != None) :
			i = 0
			while (i < 26) :
				if (head.children[i] != None) :
					if (head.children[i].count == 1) :
						#  Display Result
						print(output + (chr((i + 97))))
					else :
						#  Find short prefix
						self.shortestPrefix(head.children[i], 
                             output + str((chr((i + 97)))))
					
				
				i += 1
			
		
	

def main() :
	#  Make Tree
	task = Trie()
	#  Add word
	task.insert("bring")
	task.insert("workout")
	task.insert("break")
	task.insert("word")
	task.insert("works")
	task.insert("wordlike")
	task.insert("bress")
	#  Test
	#  ----
	#  ➀ ["bring","break","bress"] this start with "br"
	#    Scan "br"
	#   "bring"
	#    --
	#   "break"  
	#    --│    
	#      ↓      
	#   "bress"   unique["bri", "brea","bres"]
	#    --       Note "bre" common in ["break","bress"]
	#  ------------------------------------------------------
	#                     -      -      -
	#  ➁ ["word","wordlike",workout","works"] this start with "wor"
	#   Scan "wor"
	#   "word" 
	#    ---│
	#       ↓
	#   "wordlike"
	#             Common in both is "word" unique ["wordl"]
	#             Note not taken "word" because after d no character
	#   "workout"
	#    ---│
	#       ↓
	#   "works"
	#         Common in both is "work" unique ["worko","works"]   
	#  ------------------------------------------------------
	#  Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	task.shortestPrefix(task.root, "")

if __name__ == "__main__": main()

Output

brea
bres
bri
wordl
worko
works

#  Ruby program
#  Find shortest unique prefix for every word in a given list
class TreeNode 
	# Define the accessor and reader of class TreeNode
	attr_reader :last, :children, :count
	attr_accessor :last, :children, :count
	#  Indicates end of string
	Array.new() {nil}
	def initialize() 
		self.last = false
		self.children = Array.new(26) {nil}
		self.count = 1
	end

end

class Trie 
	# Define the accessor and reader of class Trie
	attr_reader :root
	attr_accessor :root
	def initialize() 
		self.root = TreeNode.new()
	end

	def insert(text) 
		#  First get the length of text
		length = text.length
		#  This variable are used to task find the index location of character
		index = 0
		#  Get the root node
		head = self.root
		level = 0
		while (level < length) 
			#  Get the index
			index = text[level].ord - 'a'.ord
			if (head.children[index] == nil) 
				#  When need to add new Node
				head.children[index] = TreeNode.new()
			else
				head.children[index].count += 1
			end

			head = head.children[index]
			level += 1
		end

		if (head != nil) 
			#  indicates end of string
			head.last = true
		end

	end

	def shortestPrefix(head, output) 
		if (head != nil) 
			i = 0
			while (i < 26) 
				if (head.children[i] != nil) 
					if (head.children[i].count == 1) 
						#  Display Result
						print(output + (((i + 97)).chr), "\n")
					else
 
						#  Find short prefix
						self.shortestPrefix(head.children[i], 
                                 output +(((i + 97)).chr).to_s)
					end

				end

				i += 1
			end

		end

	end

end

def main() 
	#  Make Tree
	task = Trie.new()
	#  Add word
	task.insert("bring")
	task.insert("workout")
	task.insert("break")
	task.insert("word")
	task.insert("works")
	task.insert("wordlike")
	task.insert("bress")
	#  Test
	#  ----
	#  ➀ ["bring","break","bress"] this start with "br"
	#    Scan "br"
	#   "bring"
	#    --
	#   "break"  
	#    --│    
	#      ↓      
	#   "bress"   unique["bri", "brea","bres"]
	#    --       Note "bre" common in ["break","bress"]
	#  ------------------------------------------------------
	#                     -      -      -
	#  ➁ ["word","wordlike",workout","works"] this start with "wor"
	#   Scan "wor"
	#   "word" 
	#    ---│
	#       ↓
	#   "wordlike"
	#             Common in both is "word" unique ["wordl"]
	#             Note not taken "word" because after d no character
	#   "workout"
	#    ---│
	#       ↓
	#   "works"
	#         Common in both is "work" unique ["worko","works"]   
	#  ------------------------------------------------------
	#  Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	task.shortestPrefix(task.root, "")
end

main()

Output

brea
bres
bri
wordl
worko
works

import scala.collection.mutable._;
/*
  Scala program
  Find shortest unique prefix for every word in a given list
*/
class TreeNode(
	// Indicates end of string
	var last: Boolean,
		var children: Array[TreeNode],
			var count: Int)
{
	def this()
	{
		this(false, Array.fill[TreeNode](26)(null), 1);
	}
}
class Trie(var root: TreeNode)
{
	def this()
	{
		this(new TreeNode());
	}
	def insert(text: String): Unit = {
		// First get the length of text
		var length: Int = text.length();
		// This variable are used to task find the index location of character
		var index: Int = 0;
		// Get the root node
		var head: TreeNode = this.root;
		var level: Int = 0;
		while (level < length)
		{
			// Get the index
			index = text.charAt(level).toInt - 'a'.toInt;
			if (head.children(index) == null)
			{
				// When need to add new Node
				head.children(index) = new TreeNode();
			}
			else
			{
				head.children(index).count += 1;
			}
			head = head.children(index);
			level += 1;
		}
		if (head != null)
		{
			// indicates end of string
			head.last = true;
		}
	}
	def shortestPrefix(head: TreeNode, output: String): Unit = {
		if (head != null)
		{
			var i: Int = 0;
			while (i < 26)
			{
				if (head.children(i) != null)
				{
					if (head.children(i).count == 1)
					{
						// Display Result
						println(output + ((i + 97).toChar));
					}
					else
					{
						// Find short prefix
						shortestPrefix(head.children(i), 
                        output + ((i + 97).toChar).toString());
					}
				}
				i += 1;
			}
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		// Make Tree
		var task: Trie = new Trie();
		// Add word
		task.insert("bring");
		task.insert("workout");
		task.insert("break");
		task.insert("word");
		task.insert("works");
		task.insert("wordlike");
		task.insert("bress");
		// Test
		// ----
		// ➀ ["bring","break","bress"] this start with "br"
		//   Scan "br"
		//  "bring"
		//   --
		//      
		//  "break"  
		//   --│    
		//     ↓      
		//  "bress"   unique["bri", "brea","bres"]
		//   --       Note "bre" common in ["break","bress"]
		// ------------------------------------------------------
		//                    -      -      -
		// ➁ ["word","wordlike",workout","works"] this start with "wor"
		//  Scan "wor"
		//  "word" 
		//   ---│
		//      ↓
		//  "wordlike"
		//            Common in both is "word" unique ["wordl"]
		//            Note not taken "word" because after d no character
		//  "workout"
		//   ---│
		//      ↓
		//  "works"
		//        Common in both is "work" unique ["worko","works"]   
		// ------------------------------------------------------
		// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
		task.shortestPrefix(task.root, "");
	}
}

Output

brea
bres
bri
wordl
worko
works

import Foundation;
/*
  Swift 4 program
  Find shortest unique prefix for every word in a given list
*/
class TreeNode
{
	// Indicates end of string
	var last: Bool;
	var children: [TreeNode?];
	var count: Int;
	init()
	{
		self.last = false;
		self.children = Array(repeating: nil, count: 26);
		self.count = 1;
	}
}
class Trie
{
	var root: TreeNode? ;
	init()
	{
		self.root = TreeNode();
	}
	func insert(_ data: String)
	{
      	let text = Array(data);
		// First get the length of text
		let length: Int = text.count;
		// This variable are used to task find the index location of character
		var index: Int = 0;
		// Get the root node
		var head: TreeNode? = self.root;
		var level: Int = 0;
		while (level < length)
		{
			// Get the index
			index = Int(
              UnicodeScalar(String(text[level]))!.value) - 
              Int(UnicodeScalar(String("a"))!.value
            );
			if (head!.children[index] == nil)
			{
				// When need to add new Node
				head!.children[index] = TreeNode();
			}
			else
			{
				head!.children[index]!.count += 1;
			}
			head = head!.children[index];
			level += 1;
		}
		if (head  != nil)
		{
			// indicates end of string
			head!.last = true;
		}
	}
	func shortestPrefix(_ head: TreeNode? , _ output : String)
	{
		if (head  != nil)
		{
          	let startingValue = Int(("a" as UnicodeScalar).value); //97
			var i: Int = 0;
			while (i < 26)
			{
				if (head!.children[i]  != nil)
				{
					if (head!.children[i]!.count == 1)
					{
						// Display Result
						print(output + String(Character(
                          UnicodeScalar(i + startingValue)!)));
					}
					else
					{
						// Find short prefix
						self.shortestPrefix(head!.children[i], 
                          output + String(Character(
                            UnicodeScalar(i + startingValue)!)));
					}
				}
				i += 1;
			}
		}
	}
}
func main()
{
	// Make Tree
	let task: Trie = Trie();
	// Add word
	task.insert("bring");
	task.insert("workout");
	task.insert("break");
	task.insert("word");
	task.insert("works");
	task.insert("wordlike");
	task.insert("bress");
	// Test
	// ----
	// ➀ ["bring","break","bress"] this start with "br"
	//   Scan "br"
	//  "bring"
	//   --
	//      
	//  "break"  
	//   --│    
	//     ↓      
	//  "bress"   unique["bri", "brea","bres"]
	//   --       Note "bre" common in ["break","bress"]
	// ------------------------------------------------------
	//                    -      -      -
	// ➁ ["word","wordlike",workout","works"] this start with "wor"
	//  Scan "wor"
	//  "word" 
	//   ---│
	//      ↓
	//  "wordlike"
	//            Common in both is "word" unique ["wordl"]
	//            Note not taken "word" because after d no character
	//  "workout"
	//   ---│
	//      ↓
	//  "works"
	//        Common in both is "work" unique ["worko","works"]   
	// ------------------------------------------------------
	// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	task.shortestPrefix(task.root, "");
}
main();

Output

brea
bres
bri
wordl
worko
works

/*
  Kotlin program
  Find shortest unique prefix for every word in a given list
*/
class TreeNode
{
	// Indicates end of string
	var last: Boolean;
	var children: Array < TreeNode ? > ;
	var count: Int;
	constructor()
	{
		this.last = false;
		this.children = Array(26)
		{
			null
		};
		this.count = 1;
	}
}
class Trie
{
	var root: TreeNode ? ;
	constructor()
	{
		this.root = TreeNode();
	}
	fun insert(text: String): Unit
	{
		// First get the length of text
		val length: Int = text.length;
		// This variable are used to task find the index location of character
		var index: Int ;
		// Get the root node
		var head: TreeNode ? = this.root;
		var level: Int = 0;
		while (level < length)
		{
			// Get the index
			index = text.get(level).toInt() - 'a'.toInt();
			if (head!!.children[index] == null)
			{
				// When need to add new Node
				head.children[index] = TreeNode();
			}
			else
			{
				head.children[index]!!.count += 1;
			}
			head = head.children[index];
			level += 1;
		}
		if (head != null)
		{
			// indicates end of string
			head.last = true;
		}
	}
	fun shortestPrefix(head: TreeNode ? , output : String): Unit
	{
		if (head != null)
		{
			var i: Int = 0;
			while (i < 26)
			{
				if (head.children[i] != null)
				{
					if (head.children[i]!!.count == 1)
					{
						// Display Result
						println(output + ((i + 97).toChar()));
					}
					else
					{
						// Find short prefix
						this.shortestPrefix(head.children[i], 
                          output + ((i + 97).toChar()).toString());
					}
				}
				i += 1;
			}
		}
	}
}
fun main(args: Array < String > ): Unit
{
	// Make Tree
	val task: Trie = Trie();
	// Add word
	task.insert("bring");
	task.insert("workout");
	task.insert("break");
	task.insert("word");
	task.insert("works");
	task.insert("wordlike");
	task.insert("bress");
	// Test
	// ----
	// ➀ ["bring","break","bress"] this start with "br"
	//   Scan "br"
	//  "bring"
	//   --
	//      
	//  "break"  
	//   --│    
	//     ↓      
	//  "bress"   unique["bri", "brea","bres"]
	//   --       Note "bre" common in ["break","bress"]
	// ------------------------------------------------------
	//                    -      -      -
	// ➁ ["word","wordlike",workout","works"] this start with "wor"
	//  Scan "wor"
	//  "word" 
	//   ---│
	//      ↓
	//  "wordlike"
	//            Common in both is "word" unique ["wordl"]
	//            Note not taken "word" because after d no character
	//  "workout"
	//   ---│
	//      ↓
	//  "works"
	//        Common in both is "work" unique ["worko","works"]   
	// ------------------------------------------------------
	// Result :  [ "brea", "bres", "bri", "wordl", "worko", "works"]
	task.shortestPrefix(task.root, "");
}

Output

brea
bres
bri
wordl
worko
works

« Previous Next »

Tree

AVL Tree Insertion

AVL Tree Deletion

AVL tree with duplicate key

Splay tree insertion

Splay tree deletion

Trie insertion

Display trie tree elements

Trie Deletion

Trie Search Word Element

Trie Bottom Up Traversal

Count Total words in Trie

Red Black Tree insertion

Red Black tree node deletion

Find duplicate rows in a binary matrix

Find the longest common prefix using Trie

Find a longest length word in Trie

Implement Leftist Tree

Fenwick Tree

Pattern Searching in Trie tree

B Tree node insertion

K dimensional tree insertion

Find the minimum in K dimensional tree

Node deletion in K dimensional tree

Construct segment tree from array

Segment tree update query

Implement B + Tree

N ary tree implementation

Find the all Kth ancestor nodes in an N-ary tree

Print the all leaf nodes in N-ary tree

Find height of n-ary tree

Minimum value node having maximum depth in an N-ary Tree

Replace every node with depth in n-ary tree

Treap implementation

Implement interval tree

Ternary Search Tree Insertion

Huffman Tree Example

Ternary Search Tree Deletion

Suffix tree implementation

Score of parentheses using tree

Construct N Level Calkin-Wilf Tree

Sort array with repeated element using AVL Tree

Count the number of words with given prefix using Trie

Find shortest unique prefix for every word in a given list

Iterative n-ary tree preorder traversal

Level order traversal of n-ary tree

Post order traversal of n-ary tree

Remove all leaf nodes from an n-ary tree

Difference between sums of odd and even levels in n-ary tree

Sum of all leaf nodes from a N-ary Tree

Radix tree implementation

Implementation trie tree with memory optimization

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