fork download
copy 
  1. use warnings;
  2. my @iparray=( "ab",  "bd","d");
  3. my @sortedarray=sort(@iparray);
  4. my @oparray;
  5. my $lowerlimit=0;
  6. my $upperlimit=0;
  7. my $count=0;
  8. my $inc=1;
  9. my $mat=0;
  10. my $matchedstring;
  11. my @regexarray;
  12. sub shrink
  13. {
  14. 	my $low = 0;
  15. 	my $up = 1;
  16. 	my $len = scalar @sortedarray;
  17. 	my $inc = 1;
  18. 	for (;$inc< $len;$inc++)
  19. 	{
  20. 		if ($sortedarray[$low] eq $sortedarray[$up])
  21. 		{
  22. 			splice(@sortedarray, $up , 1);
  23. 		}
  24. 		else
  25. 		{
  26. 			$up++;
  27. 			$low++;
  28. 		}
  29. 	}
  30. }
  31. sub regexp
  32. {
  33. 	my $inc = 0;
  34. 	my $regex;
  35. 	if(length($matchedstring ne ""))
  36. 	{
  37. 		$regex = $matchedstring . '[';
  38. 	}
  39. 	else
  40. 	{
  41. 		$regex = '[';
  42. 	}
  43. 	for (;$inc < scalar(@oparray); $inc++)
  44. 	{
  45. 		$regex = $regex . $oparray[$inc];
  46. 		if (($inc+1)<scalar(@oparray))
  47. 		{
  48. 			$regex = $regex.'|';
  49. 		}
  50. 	}
  51. 	$regex = $regex . ']';
  52. 	#print $regex;
  53. 	push @regexarray , $regex;
  54. 	@oparray = ();
  55. 	return;
  56. }
  57. sub splitter
  58. {
  59.         #If the match is zero then increase the lowerlimit by one and call the func subroutine to identify other matches
  60.  
  61.         #Else get the matched and unmatched substring from lowerlimit to upperlimit and store it into an array
  62.  
  63.                 #Get the matched substring
  64.         $matchedstring=substr($sortedarray[$count-1],0,$mat);
  65. print("\n",$matchedstring);
  66.         my $temp=$upperlimit; 
  67.         print("\n1.",$temp);   
  68.                 #Traverse from lowerlimit to upperlimit to get the unmatched substring and store it into an array        
  69.         while($temp>=$lowerlimit)
  70.             {
  71.                 $word=substr($sortedarray[$temp],$mat,length($sortedarray[$temp]));
  72.                 if($word eq "")
  73.                     {
  74.                     push @oparray,"\\s";
  75.                     }
  76.                 else
  77.                     {
  78.                     push @oparray ,$word;
  79.                     }                               
  80.                     $temp--;
  81.  
  82.             } 
  83.             regexp();           
  84.          #print ("\n2.",@oparray);
  85.            #print("\n3.",$upperlimit);
  86.                         #If the upperlimit reached the size of the array then endthe application
  87.             if(($upperlimit)==(scalar(@sortedarray)-1))
  88.                 {
  89. 				print @regexarray;
  90.                 die "Terminated ";
  91.                 #print "All the words are parsed";
  92.                 #last;
  93.                 }
  94.                         #Else set the lowerlimit as upperlimit+1
  95.             else
  96.                 {
  97.                 $lowerlimit=$upperlimit+1;
  98.                # print ("4.",$lowerlimit);
  99.                 $count=$lowerlimit;
  100.                 $inc=1;
  101.                 func();
  102.                 }
  103.  
  104. }
  105. #print "All the words are parsed";
  106. sub func
  107. {
  108. #Get the specified number of characters from the word if it is defined in the array
  109. if (defined $sortedarray[$count])
  110.         {
  111.         $base=substr($sortedarray[$count],0,$inc);
  112.         #print ("\n5.",$base);
  113.         }
  114.                 #Else terminate the application
  115.         else
  116.         {
  117. 		print @regexarray;
  118.         die;
  119.         }
  120.                 #Get the specified number of characters from the word if it is defined in the array
  121.         if (defined $sortedarray[$count+1])
  122.         {
  123.                 $match=substr($sortedarray[$count+1],0,$inc) ;
  124.                 #print ("\n6.",$match);
  125.         }
  126.                 #If the second word is not matched then find whether there is a match between the previous two words.
  127.  
  128.         else
  129.         {
  130.         if (defined $sortedarray[$count-1])
  131.                         {
  132.  
  133.  
  134.                 $s=substr($sortedarray[$count-1],0,$inc);
  135.                 #print ("\n7.",$sortedarray[$count-1]);
  136.                 #print ("\n8.",$s);
  137.                 #print ("\n9.",$count);
  138.                 }
  139.  
  140.                 else
  141.                 {
  142.                 if($lowerlimit==0)
  143.                         {
  144.                         $upperlimit=$lowerlimit;
  145.                         $mat=$inc-1;
  146.                         splitter();
  147.                         }
  148.                 }
  149.                 if($s eq $base)
  150.                 {
  151.                 $upperlimit=$count;
  152.                 $count = $lowerlimit;
  153.                 $inc++;
  154.                 #print $inc;
  155.                 func();
  156.                 }
  157.                 else
  158.                 {
  159.                 $upperlimit=$lowerlimit;
  160.                 $mat=0;
  161.                 splitter();
  162.                 }
  163.                         }
  164.        # print("\n",$base," ",$match);
  165.         $count++;
  166.         #print("\n10.",$count);
  167.                 #Determine whether the the two substrings were matched or not
  168.         if($base ne $match)
  169.             {
  170.                         #If the mismatch occurs at the lower limit itself means call the splitter to split the word based on the no of matches
  171.                 if(($count-1) == $lowerlimit)
  172.                     {
  173.                     #print ("\n11.",$mat);
  174. if(($mat==0))
  175. {
  176. if(($inc==1))
  177. {
  178. $upperlimit=$lowerlimit;
  179. splitter();
  180. }
  181. }
  182.                     my $lcount=$count;
  183.                     my $ucount=$count+1;
  184.                         #print("\n12.",$lcount,$ucount);         #If the end of the array is reached , call the splitter to split the unmatched and matched characters.
  185.                     if($ucount>=scalar(@sortedarray))
  186.                         {
  187.                         $upperlimit=$count;
  188.                         $mat=$inc-1;
  189.                        # print("\n13.",$mat);
  190.                         splitter();
  191.                         }
  192.                                                 #If the mismatch occurs at the lowerlimit ,then parse the array upto the upperlimit and find any other words having the mathch
  193.                         else
  194.                         {
  195.                         my $ulimit=$upperlimit;
  196.                         #print ("\n13.",$ulimit);
  197.                         #print("\n14.",$lcount,"\n",$ucount,"\n",$ulimit);
  198.                         while($ulimit >= $count)
  199.                             {
  200.                             my $new=substr($sortedarray[$lcount],0,$inc);
  201.                             #print("\n15.",$new);
  202.                             my $new1=substr($sortedarray[$ucount],0,$inc);
  203.                             #print("\n16. ",$new1);
  204.                                                         #If the any two words have a match, then call the splitter to split the words before the matched words.
  205.                             if($new eq $new1)
  206.                                                                 {
  207.                                                                 $upperlimit=$lcount-1;
  208.                                                                 #print("\n17.",$upperlimit);
  209.                                                                 $mat=$inc-1;
  210.                                                                 #print("\n18.",$mat);
  211.                                                                 splitter();
  212.                                                                 }
  213.                                                         #Traverse the array until the end of the array is reached
  214.                             else
  215.                                 {
  216.                                                                 $ulimit--;
  217.                                                                 $lcount++;
  218.                                                                 $ucount++;
  219.                                                                 #print("\n19.",$lcount,"\n",$ucount,"\n",$ulimit);
  220.                                 }
  221.                             }
  222.                         $mat=$inc-1;
  223.                         #print $mat;
  224.                         splitter();
  225.                         }
  226.                     }
  227.                                 #Else increment the substring counter and do the same by calling func subroutine        
  228.                 else
  229.                     {
  230.                     $inc++;
  231.                     #print $inc;
  232.                     unless(($count) == $upperlimit)
  233.                         {
  234.                         $count=$lowerlimit;
  235.                         func();
  236.                         }                               
  237.                     }
  238.             }
  239.                 #If the substrings were matched change the upper limit and call func subroutine to find whether there is any other words available with the same match.         
  240.         else
  241.             {
  242.             $mat=$inc-1;
  243.             #print("\n20.",$mat);
  244.             $upperlimit=$count;
  245.             func();
  246.             }
  247. }
  248. shrink();
  249. func();
Runtime error #stdin #stdout 0s 4724KB
comments (?)
stdin
copy 
5 23 45 43 82 143 3
stdout
copy 

1.0

1.1

1.2[ab][bd][d]
https://ideone.com/nLoqS
language:
Perl (perl 5.28.1)
created:
14 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!