CareerCup

Love the simplicity of this answer ! If anyone is wondering what's the complexity , then it's O(logn) [ base 3 , not base 2 ] .

Use Recursion !!

public class RemoveStrings {
	private static String removeStrings(String str) {
		if(str.contains("ab") || str.contains("cd")) {
			str = str.replace("ab", "");
			str = str.replace("cd", "");
			
			return removeStrings(str);
		}	
		return str;	
	}
	
	public static void main(String args[]) {
		String s = "ccdaabcdbb";
		System.out.println(removeStrings(s));	
	}
}

public class RemoveStrings {
	private static String removeStrings(String str) {
		if(str.contains("ab") || str.contains("cd")) {
			str = str.replace("ab", "");
			str = str.replace("cd", "");
			
			return removeStrings(str);
		}	
		return str;	
	}
	
	public static void main(String args[]) {
		String s = "ccdaabcdbb";
		System.out.println(removeStrings(s));	
	}
}

some flaws are there for test cases like "ccc" or "abcc"

I dont think your code is right though !!

import java.util.*;
public class Common
{
 public static void func(int [] array1,int[] array2)
 {
  HashSet<Integer> al=new HashSet<Integer>();
  HashSet<Integer> all=new HashSet<Integer>();
  for (int i:array1)
  {
   al.add(i);
  }
  for (int j:array2)
  {
   all.add(j);
  }
  
  al.retainAll(all);
  System.out.println(al);
 }
public static void main(String args[])
{
 int[] array1={1,2,3,4,3,2,1,2,3,4,5,6,4,3,2};
 int[] array2={4,7,6,5,4,5,6,7,5,5,8,9,0};
 func(array1,array2);
 
}
}

I believe you can optimize it :) currently it's complexity is O(n^2)

Sorry I am not going to answer this in java,

>>> words=["star", "rats", "ice", "cie", "arts"]
>>> from itertools import groupby
>>> [list(group) for key,group in groupby(sorted(words,key=sorted),sorted)]
[['star', 'rats', 'arts'], ['ice', 'cie']]
>>>

d = { '0': "zaqxsw",
'1': "cde",
'2': "vfr",
'3': "bgt",
}
def digstolets(digs):
  if len(digs) == 0:
    yield ''
    return
  first, rest = digs[0], digs[1:]
  if first not in d:
    for x in digstolets(rest): yield first + x
    return
  else:
    for x in d[first]:
      for y in digstolets(rest): yield x + y
print(list(digstolets('1230')))

Well here is a code written very easily in Python 3.3.2, have a look :)

def string():
    a=input("Enter the string: ")
    b=input("Enter the substring: ")
    print("The strings are :",a,b)
    if b in a:
        print("After removing the substring: ",a.replace(b,''))
    else:
        return -1

Insert those numbers in a BST and then insert the number given to u...so now calculate its difference between its root node (and leaf nodes if they exist)....whichever is the minimum value...that shud be the answer...must be done in O(logn) if m nt wrong ! :)

there is a fault in the question if m nt wrong....this is obviously they asked things related to the compiler design/theory of computing related topics....or shud i say turing machine related things...but the problem is on what basis Google wants u to print those 1's or 00's ,cause ofcourse u need to generate 101 only once...but what about the first two elements...upto infinity ??