关闭

Java面试作业,给一个整型数组,要求算出最多相同value的sum,类似二叉树搜索;

标签: java面试二叉树搜索
299人阅读 评论(0) 收藏 举报
分类:

题目:

Given an array of integers, find the sum of the most common integer

直接上代码:

package com.intelematics.findmostcommon;

import java.util.HashMap;
import java.util.Arrays;

/**
 * Intelematics Task:
 *   Given an array of integers, find the sum of the most common integer
 * Assumptions:
 * 	 1: The test array size is in a reasonable range (Depend on the memory size)
 *   2: The count of the same number in the given array is different to each other(Array like {0,0,1,1} is invalid)
 * @author: Tony
 * @since: 12/11/2015
 */

public class SumCommonInteger {
	
	/**
	 * Find the sum of the most common integer
	 * Optimized for runtime
	 * Runtime: O(n)
	 * Space: O(n)
	 * @param int[] inputIntArray
	 * @return sum result
	 */
	public static int sumCommonForRuntime(int[] inputIntArray)
	{
		// Temporary store may occupy memory space whereas more rapid for runtime.
		HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
		// Store the final result occupy memory space
		int common[] = new int[] {0, 0};
		try
		{
			// Iterate over the array while keep it still		
			for(int key : inputIntArray) 
			{
				// hm is rapid for seeking by key
				if(hm.containsKey(key))
				{
					Integer commonCount = hm.get(key);
					commonCount ++;
					// count ++; if true update to another key count
					if(commonCount > common[1])
					{
						common[0] = key;
						common[1] = commonCount;
						// Dynamically update the hm, occupy more memory space
						hm.put(key, commonCount);
					}
				} 
				else 
				{
					// First put count=1
					hm.put(key, 1);
				}
			}
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
		
		return common[0]*common[1];
	}
	
	/**
	 * Find the sum of the most common integer
	 * Optimized for memory space
	 * Runtime: O(nlogn)--O(n^2)
	 * Space: O(n)
	 * @param int[] inputIntArray
	 * @return sum result
	 */
	public static int sumCommonForSpace(int[] inputIntArray)
	{
		// Store the final result occupy memory space
		int common[] = new int[] {0, 0};
		Arrays.sort(inputIntArray);
		
		try
		{
			// Iterate over the array while keep it still
			for(int i=1; i<inputIntArray.length; i++) 
			{
				int currCount = 0;
				int currKey = 0;
				for(int j=0; j<inputIntArray.length-1; j++) 
				{
					if(inputIntArray[j] == inputIntArray[i])
					{
						currKey = inputIntArray[i];
						currCount ++;
						// After currCount ++; if true update to another key count
						if(currCount > common[1])
						{
							common[0] = currKey;
							common[1] = currCount;
						}
					}
				}
			}
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
		
		return common[0]*common[1];
	}

	/**
	 * Main
	 * @param args
	 */
	public static void main(String[] args) 
	{
		int[] inputIntArray = new int[]{1,2,3,4,5,1,8};
		System.out.println("Result of sumCommonForRuntime: "+sumCommonForRuntime(inputIntArray));
		System.out.println("Result of sumCommonForSpace: "+sumCommonForSpace(inputIntArray));
	}
	
}

Junit测试代码:

package com.intelematics.findmostcommon;

import static org.junit.Assert.*;

import org.junit.Test;

/**
 * Test Case for SumCommonInteger
 * @author Tony
 * @since 12/11/2015
 */
public class SumCommonIntegerTest {

	@Test
	public void testSumCommonForRuntimeNormal() 
	{
		int[] inputIntArray = new int[]{1,2,3,4,5,1,8};
		assertEquals(SumCommonInteger.sumCommonForRuntime(inputIntArray), 2);
	}

	@Test
	public void testSumCommonForRuntimeNull() 
	{
		int[] inputIntArray = new int[]{};
		assertEquals(SumCommonInteger.sumCommonForRuntime(inputIntArray), 0);
	}

	@Test
	public void testSumCommonForRuntimeInvalid() 
	{
		int[] inputIntArray = new int[]{3,3,0,0,1,1,2,2};
		assertEquals(SumCommonInteger.sumCommonForRuntime(inputIntArray), 6);
	}

	@Test
	public void testSumCommonForRuntimeNeg() 
	{
		int[] inputIntArray = new int[]{-1,2,-3,4,5,-1,-8};
		assertEquals(SumCommonInteger.sumCommonForRuntime(inputIntArray), -2);
	}
	
	@Test
	public void testSumCommonForRuntimeSame() 
	{
		int[] inputIntArray = new int[]{1,1,1,1,1,1,1};
		assertEquals(SumCommonInteger.sumCommonForRuntime(inputIntArray), 7);
	}
	//------------------------------------------------------------------------
	@Test
	public void testSumCommonForSpaceNormal() 
	{
		int[] inputIntArray = new int[]{1,2,3,4,5,1,8};
		assertEquals(SumCommonInteger.sumCommonForSpace(inputIntArray), 2);
	}

	@Test
	public void testSumCommonForSpaceNull() 
	{
		int[] inputIntArray = new int[]{};
		assertEquals(SumCommonInteger.sumCommonForSpace(inputIntArray), 0);
	}

	@Test
	public void testSumCommonForSpaceInvalid() 
	{
		int[] inputIntArray = new int[]{3,3,0,0,1,1,2,2};
		assertEquals(SumCommonInteger.sumCommonForSpace(inputIntArray), 6);
	}

	@Test
	public void testSumCommonForSpaceNeg() 
	{
		int[] inputIntArray = new int[]{-1,2,-3,4,5,-1,-8};
		assertEquals(SumCommonInteger.sumCommonForSpace(inputIntArray), -2);
	}
	
	@Test
	public void testSumCommonForSpaceSame() 
	{
		int[] inputIntArray = new int[]{1,1,1,1,1,1,1};
		assertEquals(SumCommonInteger.sumCommonForSpace(inputIntArray), 7);
	}
}


ReadMe:

//------------------------------------------------------------------------------------------------------
Problem:
Given an array of integers, find the sum of the most common integer.
Example: (1, 2, 3, 4, 5,1, 8) returns 2 (as 1+1 = 2) .

//------------------------------------------------------------------------------------------------------
My Solution Details:
* Assumptions:
*  1: The test array size is in a reasonable range (Depend on the memory size)
*  2: The count of the same number in the given array is different to each other(Array like {0,0,1,1}, is no sense)

First: Optimized for runtime [Implemented in java]
1. Use HashMap<Integer, Integer> to store the count of each value in the given array, this will occupy memory space.
2. Use int common[] to store the final result, this will occupy memory space.
3. Iterate over the given array while keep it still, use HashMap for a rapid seeking by key.
4. Use hm.put(key, commonCount), dynamically update the hm, in terms of the given array, occupy more memory space.
5. return common[0]*common[1];

If the first value in the given array is the most common one, the minimum runtime would be O(n) and so would be the memory space.

Second: Optimized for space [Described as the following]
1. Use int common[] to store the final result, this will occupy memory space.
2. UseArrays.sort() to sort the given array, depends on the array, this may cost lots of time.
3. Iterate over the given array from 1 to array.length, compare each value to its left one(from 0 to length-1), this may cost lots of time too.
4. Get the most common one and update common[]
5. return common[0]*common[1];

In this solution, I just use the given array and the result array, it take only few bytes of extra memory space for the variables themselves. At the same time, the longest time for running would be O(n^2) and average time would be O(nlogn).

//------------------------------------------------------------------------------------------------------
In my past projects, in most cases, we took the first into effect rather than the second one, as the requirements for runtime speed outweigh for memory cost.

//------------------------------------------------------------------------------------------------------
Please feel free to copy the following lines to execute it in command line in current file dir. [java version "1.8.0_60"]
javac -d . SumCommonInteger.java
java com.intelematics.findmostcommon.SumCommonInteger

//------------------------------------------------------------------------------------------------------



0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:93538次
    • 积分:1540
    • 等级:
    • 排名:千里之外
    • 原创:56篇
    • 转载:21篇
    • 译文:1篇
    • 评论:3条
    最新评论