新浪微博笔试题

一、第一题

题目描述

假设有一个已经排好序的整型数组，要求实现一个使用二分查找的函数，判断某个数字是否出如今该数组中。

题目分析

这道题目相对来讲很简单，二分查找可用递归或者迭代实现，主要是中间值进行比较。

解决方法：

输入一个已经排好序的整型数组以及待查的数组，返回一个布尔值，表示查询的值是否存在。
代码以下：

package sina;
/** 
 * @author smile_tina
 * 
 */
public class Problem1 {
    public boolean findNum(int[] nums, int num) {
        if (null == nums)
            return false;
        return findNumSub(nums, num, 0, nums.length - 1);
    }
    public boolean findNumSub(int[] nums, int num, int left, int right) {
        if (left > right)
            return false;
        int mid = left + (right - left) / 2;
        if (nums[mid] == num) {
            return true;
        } else if (nums[mid] > num)
            return findNumSub(nums, num, left, mid - 1);
        else
            return findNumSub(nums, num, mid + 1, right);
    }
    public static void main(String[] args) {
        int[] a = { 1, 2, 3, 4, 5, 6, 7 };
        Problem1 po = new Problem1();
        System.out.println(po.findNum(a, 8));
    }
}

二、第二题

题目描述

假设有一个整型数组，里面有若干数字，要求统计出一共有多少种不一样的数字，并将这些数字保存到一个新的数组中，且根据数字出现的频率从少到多排列，若是频率相同则按数字值从小到大排列。

题目分析

使用Hashmap存储对应数字出现的频数，key是数字，value是该数字出现的次数。而后根据value值进行排序。

解决方法：

输入数组，map存储数字以及出现的次数，而后重写Collections的sort函数，按value值进行排序，输出不一样数字的个数，result为所求新数组。

package sina;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * 
 * @author smile_tina
 * 
 */
public class Problem2 {

    /**
     * 
     * @param nums 输入数组
     * @return 按要求输出新数组
     */
    public int[] distinctNum(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        // fill map
        for (int i = 0; i < nums.length; i++) {
            if(map.containsKey(nums[i])){
                map.put(nums[i], map.get(nums[i])+1);
            }else
                map.put(nums[i], 1);
        }
        //根据value值进行排序
        List<Map.Entry<Integer, Integer>> info = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());
        Collections.sort(info,new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Entry<Integer, Integer> o1,
                    Entry<Integer, Integer> o2) {               
                return o1.getValue()-o2.getValue();
            }
            
        });
        System.out.println("一共有"+info.size()+"种不一样的数字");
        int[] result = new int[info.size()];
        for(int i = 0;i<info.size();i++){
            result[i] = info.get(i).getKey();
        }
        return result;
        
    }

    public static void main(String[] args) {
        Problem2 po = new Problem2();
        int[] a = {1,2,6,4,2,1,8,9,3,6,7};
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(po.distinctNum(a)));
    }

}

三、第三题

题目描述

假设有一个字符串数组，每个字符都是一个数字（1-9），找到其中的最大递增数，递增数是指相邻的数位从小到大排列的数字，如：28953456323，递增数有：289，3456，23，那么最大的递增数为3456。

题目分析

该题是个动态规划问题。
若是严格按照动态规划的步骤去解，在字符串长度为n的状况下须要存储n个字符串。可是咱们能够发现以下规律，若是str[m:n]是严格递增的，则他的子集str[p:q] (p大于等于m 而且小于等于n) 必定是严格递增的，并且若是str[m] < str[m-1] 而且 str[n] > str[n+1] （未考虑边界条件），则str[m:n]必定是字符串m到n索引中值最大的字符串，有了这个规律，咱们只须要从头日后遍历一次：用一个索引start表示当前正在遍历的递增字符串的初始位置，用一个变量res来存储以前最大的字符串，每当发现一个局部递增的字符串就和res比较一次（比较的规则是：若是str1的长度大于res的长度，则str1大，若是长度相等则比较字符串第一个位置），同时索引tmpIndex增长这个递增字符串的长度，不然一旦不连续，更新初始位置也就是start的值。这样当tmpIndex到达字符串末尾的时候，就获得了最大字符串。

解决方法

代码以下：

package sina;

/**
 * 
 * @author smile_tina
 * 
 */
public class Problem3 {

    public String findMaxNum(String str) {
        if (null == str || str.length() == 0)
            return "";
        String res = "";
        int start = 0;
        int tmpIndex = start;
        for (int i = 1; i < str.length(); i++) {
            if (str.charAt(i) - str.charAt(tmpIndex) == 1) {
                tmpIndex++;
                if ((tmpIndex - start+1) > res.length())
                    res = str.substring(start, tmpIndex + 1);
                if((tmpIndex - start + 1== res.length()) && str.charAt(start)>res.charAt(0))
                    res = str.substring(start, tmpIndex + 1);
            }
            else{
                start = i;
                tmpIndex = start;
            }
        }
        return res;
    }

    public static void main(String[] args) {
        Problem3 po = new Problem3();
        System.out.println(po.findMaxNum("209876543210243423243242382648327493274832784123456789"));
    }
}