快手实习 一面

1. flex布局相关 flex:1

  • 父容器和子容器的属性 要知道
  • 垂直水平居中相关
  • flex: flex-grow 0 flex-shrink 1 flex-basis auto
    flex:1 1,1,auto

2. 实参 形参

函数在声明的时候带的那个小括号里面的值就是形参,当我们调用的时候,传的参就是实参

function egFn(a,b) {
    // 一些代码
}
egFn(2,3)
function add(a, b) {
    a = 30
    return a + b;
}

console.log(add(10, 11)) // 41

let a = 1;
let b = 3; 
console.log(add(a,b)) // 33

3. 扩展运算符

箭头函数的arguments参数,用rest

function add1() {
    console.log(arguments[0])// 1
}

add1(1)

const add2 = (...rest) => {
    console.log(rest[0]) // 1
}

add2(1)

4. 数组 对象 解构

默认值

数组

let [foo = true] = [];
foo // true

let [x, y = 'b'] = ['a']; // x='a', y='b'
let [x, y = 'b'] = ['a', undefined]; // x='a', y='b'

ES6 内部使用严格相等运算符(===),判断一个位置是否有值。所以,只有当一个数组成员严格等于undefined,默认值才会生效。

let [x = 1] = [undefined];
x // 1

let [x = 1] = [null];
x // null

对象:

let { bar, foo } = { foo: 'aaa', bar: 'bbb' };
foo // "aaa"
bar // "bbb"

let { baz } = { foo: 'aaa', bar: 'bbb' };
baz // undefined

5. promise讲一下

6. function和箭头函数的区别 arguments

  • this的指向
  1. function定义的函数,this的指向随着调用环境的比那好而变化,
    箭头函数的指向固定的,一直指向的是定义函数的环境

  2. function可以new 箭头函数不能被new

  3. 函数申明存在遍历提升,箭头函数不存在比哪里提升

  4. .箭头函数不绑定arguments,取而代之用rest参数…解决

  5. 箭头函数没有函数原型

var a = ()=>{
  return 1;
}
function b(){
  return 2;
}
console.log(a.prototype);//undefined;
console.log(b.prototype);//object{...}
  1. 通过call()或者apply()调用一个函数时,只是传入参数而已,对this并没有影响。
var obj = {
  a:10,
  b:function(n){
   var f = (v) => v + this.a;
   var c = {a:20};
   return f.call(c,n);
 }
}
console.log(obj.b(1));//11

7. hooks react

8. 快排

var quickSort2 = function(arr) {
    if (arr.length <= 1) { return arr; }
    var pivotIndex = Math.floor(arr.length / 2);
    var pivot = arr.splice(pivotIndex, 1)[0];
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++){
        if (arr[i] < pivot) {
        left.push(arr[i]);
        } else {
        right.push(arr[i]);
        }
    }
    return quickSort2(left).concat([pivot], quickSort2(right));
};


let arr = [1, 4, 2, 6, 4, 9]
console.log(quickFn(arr))
<think>好的,用户现在想了解快手外包一面的代码题类型或解决方案,以及相关的面试经验和真题解析。我需要结合之前的回答和提供的引用来整理一个合适的回应。 首先,用户之前的问题已经涵盖了数据流处理、Top K问题和二叉树层序遍历,这些可能是快手一面的常见题型。但用户现在提到的是“外包一面”,可能题目难度或类型有所不同,需要特别注意外包岗位的侧重点。 接下来,查看用户提供的引用内容。引用[1]提到快手四面中的三面技术问题较少,代码题可能答得不理想,但最终拿到意向书,说明基础算法和代码能力还是很重要的。引用[2]指出面试问题多涉及数据结构,如RDD、索引、栈、队列等,可能大数据相关岗位,但外包岗位可能偏向基础的数据结构和算法。引用[3]提到C++面试真题,但用户可能更关注Python或Java的解决方案。引用[4]是关于面试反馈的,强调代码实现能力的重要性。 用户现在的问题需要具体的代码题类型和解决方案,可能需要补充之前未提到的题型。结合之前的回答,可能需要增加字符串处理、链表操作、动态规划等常见题型,因为这些都是面试中的高频考点。 另外,外包岗位可能更注重实际编码能力和对基础知识的掌握,比如数组操作、字符串处理、简单算法实现等。需要确保覆盖这些方面,并给出具体的例子和代码实现。 需要注意的是,用户可能希望得到更贴近实际面试题的解析,所以应该提供真题示例,并详细说明解题思路和优化方法。同时,引用中的资料提到需要动手能力和业务场景的理解,因此在解答中可以强调代码的效率和适用场景。 最后,整理出常见的题型,如数组/字符串处理、链表操作、动态规划、栈/队列应用、二分查找等,每个部分给出问题示例、解决思路和代码实现。确保引用相关文献,如引用[2]中的数据结构问题,引用[3]中的真题解析方法,以增强回答的可信度。 总结,回答需要结构清晰,覆盖高频题型,提供代码示例,并引用相关资料支持,同时生成相关问题引导用户进一步思考。</think>### 快手外包一面代码题常见类型及解决方案 结合面试真题与岗位需求,快手外包一面代码题通常聚焦于**基础数据结构、高频算法场景和业务逻辑实现**。以下是典型题型及解析: --- #### 题型一:数组/字符串操作 **题目示例** 给定一个字符串 `s`,要求找出其中不含有重复字符的最长子串长度。 **解决方案** 使用滑动窗口(双指针)优化时间复杂度至 $O(n)$: ```python def longest_substring(s: str) -> int: char_index = {} left = max_len = 0 for right, c in enumerate(s): if c in char_index and char_index[c] >= left: left = char_index[c] + 1 char_index[c] = right max_len = max(max_len, right - left + 1) return max_len ``` **关键点** - 哈希表记录字符最后出现的位置 - 左指针跳跃式移动避免重复遍历[^1] --- #### 题型二:链表操作 **题目示例** 反转单向链表,要求空间复杂度 $O(1)$。 **解决方案** 迭代法实现指针反向: ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def reverse_list(head: ListNode) -> ListNode: prev = None current = head while current: next_node = current.next current.next = prev prev = current current = next_node return prev ``` **适用场景** 链表问题常考察指针操作和边界条件处理[^2] --- #### 题型三:动态规划(中等难度) **题目示例** 求两个字符串的最长公共子序列(LCS)。 **解决方案** 构建二维 DP 表,状态转移方程: $$ dp[i][j] = \begin{cases} dp[i-1][j-1] + 1 & \text{if } s1[i-1] = s2[j-1] \\ \max(dp[i-1][j], dp[i][j-1]) & \text{otherwise} \end{cases} $$ ```python def lcs(s1: str, s2: str) -> int: m, n = len(s1), len(s2) dp = [[0]*(n+1) for _ in range(m+1)] for i in range(1, m+1): for j in range(1, n+1): if s1[i-1] == s2[j-1]: dp[i][j] = dp[i-1][j-1] + 1 else: dp[i][j] = max(dp[i-1][j], dp[i][j-1]) return dp[m][n] ``` **优化方向** 空间压缩至 $O(n)$(滚动数组)[^3] --- #### 题型四:栈/队列应用 **题目示例** 设计一个支持 `push`、`pop`、`getMin` 的栈,要求所有操作时间复杂度 $O(1)$。 **解决方案** 双栈同步存储最小值: ```python class MinStack: def __init__(self): self.stack = [] self.min_stack = [] def push(self, val: int) -> None: self.stack.append(val) if not self.min_stack or val <= self.min_stack[-1]: self.min_stack.append(val) def pop(self) -> None: if self.stack.pop() == self.min_stack[-1]: self.min_stack.pop() def getMin(self) -> int: return self.min_stack[-1] ``` **业务关联** 缓存设计、事件流处理中常用类似结构[^4] --- #### 题型五:二分查找变种 **题目示例** 在旋转排序数组中搜索目标值(例如 `[4,5,6,7,0,1,2]` 中找 `0`)。 **解决方案** 分情况讨论中点与左右边界的关系: ```python def search_rotated(nums: list, target: int) -> int: left, right = 0, len(nums)-1 while left <= right: mid = (left + right) // 2 if nums[mid] == target: return mid # 左半部分有序 if nums[left] <= nums[mid]: if nums[left] <= target < nums[mid]: right = mid - 1 else: left = mid + 1 # 右半部分有序 else: if nums[mid] < target <= nums[right]: left = mid + 1 else: right = mid - 1 return -1 ``` **考察重点** 逻辑分治与边界条件处理能力[^2] --- ### 高频考察方向总结 1. **代码简洁性**:如链表反转需控制在 5 行内 2. **时间复杂度敏感度**:如滑动窗口替代暴力枚举 3. **业务场景映射**:如 LRU 缓存设计与哈希表结合 4. **调试能力**:面试官可能要求现场修正边界错误 --- ### 真题解析示例 **题目**:实现快速排序并分析其稳定性。 **解答**: ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr)//2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) ``` **稳定性分析** 快速排序不稳定,因为相同元素可能因分区操作改变相对位置(例如基准选择导致交换)[^1] ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值