笔试题

柠檬微趣 0306

限使用Java

力扣原题290 单词规律

用哈希就好咯

import java.util.HashMap;
import java.util.Map;

public class n1 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * @param pattern string字符串
     * @param str string字符串
     * @return bool布尔型
     */
    public boolean testMatch (String pattern, String str) {
        // write code here
        if(pattern==null || str==null){
            return false;
        }
        String[] words = str.split(" ");
        if(pattern.length() != words.length){
            return false;
        }
        Map<Character, String> hashMap = new HashMap<>();
        for(int i =0 ;i<words.length;i++){
            if(hashMap.containsKey(pattern.charAt(i))){
                if(!hashMap.get(pattern.charAt(i)).equals(words[i])){
                    return false;
                }
            }else{
                if(hashMap.containsValue(words[i])){
                    return false;
                }else{
                    hashMap.put(pattern.charAt(i),words[i]);
                }
            }
        }
        return true;
    }
}

力扣 556. 下一个更大元素 III

从右边开始找，找到第一个小于右边递减序列的相邻头元素的位置i，在右边序列里找到j元素的位置第一次大于i位置元素，交换i j处元素，对i右边的序列实行倒序。

import java.util.*;
public class n2 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * @param N int整型
     * @return int整型
     */
    public int findGreaterNum (int N) {
        // write code here
        char [] a = ("" + N).toCharArray();
        int i = a.length - 2;
        while(i>=0 && a[i+1] <= a[i]){
            i--;
        }
        if(i < 0)   return -1;
        int j = a.length - 1;
        while(j>=0 && a[j] <= a[i]){
            j--;
        }
        swap(a, i, j);
        reverse(a, i+1);
        try{  // try catch保证答案是32位整数范围的
            return Integer.parseInt(new String(a));
        }catch (Exception e){
            return -1;
        }
    }

    private void swap(char[] a, int i, int j){
        char tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    private void reverse(char [] a, int start){
        int i = start, j = a.length-1;
        while(i<j){
            swap(a,i,j);
            i++;
            j--;
        }
    }
}

最小两个连续子数组长度和

题目
对于给定正整数数组A和给定正整数T，请在A中找出两个连续子数组，这两个子数组不能相交，并且两个子数组的和相等且为T。可能会有多种方案，请返回两个子数组长度和的最小值。如果无法找到这样的方案，返回-1。

输入	输出	说明
[7, 3, 4, 7], 7	2	3个不相交数组分别为[7], [3, 4], [7]
[5, 5, 4, 4, 5], 3	-1	无法找到满足条件的子数组

参考力扣560
用滑动窗口找到和为T的连续数组，记录子数组长度。

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * @param N int整型
     * @return int整型
     */
    public int minSumOfLengths(int [] A , int T ){
        if(A==null || A.length==0) return -1;
        ArrayList<Integer> res = new ArrayList<>();
        int left=0,sum=0;
        for(int i = 0; i<A.length; i++){
            sum += A[i];
            if(sum>=T){
                while(sum>=T){
                    if(sum>T){
                        sum -= A[left];
                        left+=1;

                    }else{
                        res.add(i-left+1);
                        left = i+1; //注意满足条件的窗口无重叠，所以左指针重置
                        sum = 0;
                    }

                }
            }
        }
        if(res.size()<2)  return -1;
        Collections.sort(res);
        return res.get(0)+res.get(1);
    }

    public static void main(String[] args) {
        n2 a = new n2();
        System.out.println(a.minSumOfLengths(new int[]{7, 3, 4, 5}, 7));
    }
}

ProtocolBuffer序列化 不会

奇安信 0306

奶牛吃草

上升子序列的最大和？？

class Solution:
    def MaxMilk(self, grass, milk):
        n = len(grass)
        if n==0:
            print(0)
        else:
            l = []
            for i in range(n):
                l.append([])
                l[i].append(grass[i])
                l[i].append(milk[i])
            l.sort()

            f = [0 for i in range(n)]
            for i in range(n):
                f[i] = l[i][1]
                for j in range(i):
                    if l[j][1] <= l[i][1]:
                        f[i] = max(f[i], f[j]+l[i][1])
            return max(f)