rajarshi129
BAN USERJava:
// Sort on char array
public ArrayList<String> sortOnCharArray(char[] chars, String[] strings)
{
ArrayList<String> stringArrayList = new ArrayList<String>();
HashMap<Character, String[]> mapper = new HashMap<Character, String[]>();
mapper = ConstructMap(chars, strings);
for (int count=0; count<chars.length; count++)
{
String[] pullArray = mapper.get(chars[count]);
String[] sortedPullArray = SortStrings(pullArray);
for (String str : sortedPullArray)
stringArrayList.add(str);
}
return stringArrayList;
}
public HashMap<Character, String[]> ConstructMap(char[] chars, String[] strings)
{
HashMap<Character, String[]> mapper = new HashMap<Character, String[]>();
for (int count=0; count<strings.length; count++)
{
if (contains(chars, strings[count].charAt(0)))
{
String[] pushArray = new String[strings.length];
if (mapper.containsKey(strings[count].charAt(0)))
{
String[] push = new String[mapper.get(strings[count].charAt(0)).length+1];
push = mapper.get(strings[count].charAt(0));
push[push.length-1] = strings[count];
pushArray = push;
}
else
{
pushArray[0] = strings[count];
}
mapper.put(strings[count].charAt(0), pushArray);
}
}
return mapper;
}
public String[] SortStrings(String[] strings)
{
for (int count = 0; count<strings.length; count++)
{
if (strings[count]==null)
strings[count] = "";
}
Arrays.sort(strings);
return strings;
}
public boolean contains(char[] chars, char ch)
{
for (char c : chars)
{
if (c == ch)
return true;
}
return false;
}
Java: [based on @eugene's logic]
public Node print5thNode(Node head)
{
Node front = head;
Node back = head;
int count = 0;
while(count<=5)
{
if (front.next == null)
return back;
front = front.next;
++count;
}
while(front.next != null)
{
front = front.next;
back = back.next;
}
return back;
}
Java:
public boolean isBST(Node Root)
{
if (Root == null)
return true;
if (Root.value < Root.left.value || Root.value >= Root.right.value)
return false;
else
return isBST(Root.left) && isBST(Root.right)
}
I think that 'add' in case of ArrayList is always O(n) because the array contents need to be shifted by one for every addition (except when the addition happens at the end, in which case the ArrayList may need to expand.)
- rajarshi129 October 09, 2012Great, this is even simpler than the algorithm given in CLRS!
- rajarshi129 October 09, 2012Java:
StringBuffer s = new StringBuffer("hello");
System.out.println(s.reverse());
This is called an Euler tour. Refer: [http]jrgalia.com/content/euler-tour-traversal-binary-search-tree for java implementation.
- rajarshi129 October 01, 2012Duplicates: The inverted index should have tf scores associated with each phone number. So for example, phone# 898765432 will have tf score of 2 for index 8.
Yes, the same phone number will be stored at most 10 times and this will make the inverted index very large. We can avert this by increasing the size of the dictionary from 10 to say 100. Now the indices will be from 00 to 99 instead of 0 to 9.
Simple, call up your two friends who have high speed vehicles (say, racer bikes). One chooses to go north side of the road and the other goes south. Off you go!!!
- rajarshi129 October 01, 2012// Longest Sum Subsequence
public int find_Longest_Sum_Subsequence(int[] array)
{
// return Integer.Min_value if the input array is null
if (array == null)
return Integer.MIN_VALUE;
if (array.length == 1)
return array[0];
int longest_sum = array[0];
int build_sum = array[0];
int counter = 1;
while (counter < array.length)
{
if ((build_sum+array[counter])>0)
build_sum += array[counter++];
else
build_sum = array[counter++];
if (build_sum > longest_sum)
longest_sum = build_sum;
}
return longest_sum;
}
If you mean to minimize {Sum(elements of array1) - Sum(elements of array2)}, then follow:
1. Sort the original array.
2. Alternatively place the pairs {ith element, (length-i)th element} to each of the two resulting arrays.
Java code:
Iterator<Integer> list1_iterator = List1.Iterator();
Iterator<Integer> list2_iterator = List2.Iterator();
while(list1_iterator.hasNext())
{
int key = list1_iterator.next();
while(list2_iterator.hasNext())
{
if (key<list2_iterator.next())
list2_iterator.next();
else
// insert key at this position in List2 and break;
}
}
int gcd(int a, int b)
{
if(b==a) return a;
if (a>b)
return gcd(a-b, b);
else
return gcd(a, b-a);
}
Java: [based on binary search method]
- rajarshi129 October 10, 2012