Uber神仙操作电面

考的是函数式编程基础。
第一次见面试问这个，没接触过概念的话是比较早短时间内接受。

有时面试官自己就是觉得不能让别人这么轻易就进来 然后出些奇奇怪怪的题

想远眺的金蓝鸟 发表于 2018/11/30 03:09:03


唉，可以回邮件举报面试官吗？我真的想argue一下了

可以，不一定有用，看你的hr

这是啥啊，函数式编程么？？？这考的出来个什么

。。。闻所未闻。。。。
真的奇葩
我以为系统设计上火星已经够可以的了
给Uber点赞

谢谢分享

U 家好像没有题库，面试官想怎么出就怎么出。

这个题目出得很不严谨，因为认真考虑的话要处理的情况是非常多的（例如隐式类型转换、变长参数等等），面试小哥估计也是半桶水晃荡..

相关知识点本质上是与编译器前端中的function (overload) resolution有关，看起来楼主面试语言应该是Java，那么是要用Java reflection的一些技术

写了一份参考代码：

1. import java.lang.reflect.Method;
   
2. import java.util.HashMap;
   
3. 
   
4. class Solution {
   
5.   private static final HashMap<Class<?>, Class<?>> primitiveTypes =
   
6.       new HashMap<Class<?>, Class<?>>() {{
   
7.           put(boolean.class, Boolean.class);
   
8.           put(byte.class, Byte.class);
   
9.           put(char.class, Character.class);
   
10.           put(double.class, Double.class);
    
11.           put(float.class, Float.class);
    
12.           put(int.class, Integer.class);
    
13.           put(long.class, Long.class);
    
14.           put(short.class, Short.class);
    
15.           put(void.class, Void.class);
    
16.       }};
    
17. 
    
18.   public boolean testFunction(final Class<?> target,
    
19.                               final Class<?> expected,
    
20.                               final Object... args) {
    
21.     // 实参类型
    
22.     Class<?>[] actualTypes = new Class[args.length];
    
23.     for (int i = 0; i < args.length; ++i) {
    
24.       actualTypes[i] = args[i].getClass();
    
25.     }
    
26. 
    
27.     // 遍历所有method，匹配参数类型以及结果类型
    
28.     for (Method method : target.getMethods()) {
    
29.       if (checkEquivalence(method.getParameterTypes(), actualTypes) &&
    
30.           checkEquivalence(method.getReturnType(), expected, false)) {
    
31.         return true;
    
32.       }
    
33.     }
    
34.     return false;
    
35.   }
    
36. 
    
37.   private boolean checkEquivalence(final Class<?>[] formalTypes,
    
38.                                    final Class<?>[] actualTypes) {
    
39.     // 如果要支持对变长参数(varargs)的检测，这里要写得更复杂一些
    
40.     if (actualTypes.length != formalTypes.length) {
    
41.       return false;
    
42.     }
    
43.     for (int i = 0; i < formalTypes.length; ++i) {
    
44.       if (!checkEquivalence(formalTypes[i], actualTypes[i], true)) {
    
45.         return false;
    
46.       }
    
47.     }
    
48.     return true;
    
49.   }
    
50. 
    
51.   private boolean checkEquivalence(Class<?> formalType,
    
52.                                    Class<?> actualType,
    
53.                                    final boolean allowImplicitTypeCast) {
    
54.     if (primitiveTypes.containsKey(formalType)) {
    
55.       formalType = primitiveTypes.get(formalType);
    
56.     }
    
57.     // 这种简单写法可以支持隐式upcast，例如String -> Object
    
58.     // 但是不支持隐式primitive类型转换，例如int -> float
    
59.     // 如果要支持后者需要更大的代码量
    
60.     return allowImplicitTypeCast ? formalType.isAssignableFrom(actualType)
    
61.                                  : formalType.equals(actualType);
    
62.   }
    
63. }
    
64. 
    
65. // 用于测试的class
    
66. class TestCase {
    
67.   public int f(int x, int y) {
    
68.     return x + y;
    
69.   }
    
70. 
    
71.   public double g(String x, double y) {
    
72.     return x.length() * y;
    
73.   }
    
74. 
    
75.   public String h(long id, String[] values) {
    
76.     return "[" + id + "] " + String.join(" ", values);
    
77.   }
    
78. }
    
79. 
    
80. public class Main {
    
81.   public static void main(String[] args) {
    
82.     Solution solution = new Solution();
    
83.     // 测试 Solution.f
    
84.     // true
    
85.     System.out.println(solution.testFunction(TestCase.class, Integer.class, 1, 2));
    
86.     // false, 参数数量不匹配
    
87.     System.out.println(solution.testFunction(TestCase.class, Integer.class, 1, 2, 3));
    
88.     // false, 第一个参数类型不匹配
    
89.     System.out.println(solution.testFunction(TestCase.class, Integer.class, 1.5, 2));
    
90. 
    
91.     // 测试 Solution.g
    
92.     // true
    
93.     System.out.println(solution.testFunction(TestCase.class, Double.class, "Hello", 1.5));
    
94.     // false，返回值类型不匹配
    
95.     System.out.println(solution.testFunction(TestCase.class, String.class, "Hello", 1.5));
    
96. 
    
97.     // 测试 Solution.h
    
98.     // true
    
99.     System.out.println(solution.testFunction(TestCase.class, String.class, 1L, new String[] {"a", "b"}));
    
100.     // false, 参数类型不匹配
     
101.     System.out.println(solution.testFunction(TestCase.class, String.class, "Hello", new String[] {"a", "b"}));
     
102.     // false, Solution里面的代码不支持隐式基础类型转换
     
103.     System.out.println(solution.testFunction(TestCase.class, String.class, 1, new String[] {"a", "b"}));
     
104.   }
     
105. }
     

复制代码

您好！
本帖隐藏的内容需要积分高于 100 才可浏览
您当前积分为 0。
使用VIP即刻解锁阅读权限或查看其他获取积分的方式

游客，您好！
本帖隐藏的内容需要积分高于 100 才可浏览
您当前积分为 0。
VIP即刻解锁阅读权限 或 查看其他获取积分的方式
Unlock interview details and practice with AI
Curated Interview Questions from Top Companies

PeterR 发表于 2018-11-30 05:48
这是啥啊，函数式编程么？？？这考的出来个什么

好像是用Method class进行参数格式匹配～