• 前端笔面编程收录【按公司】

    目录

    虚拟DOM【腾讯音乐笔试】

    连字转驼峰【美团一面】

    1.split('-')

    2.toUpperCase()

    3.slice(1)

    用友sp

    一面【二选一】

    数组相邻和最大的对应两个元素

    千位分割【无负数，含小数】

    二面

    华容道：BFS

    k / 3, y = k % 3; //一维数组下标转化到二维数组中的坐标

    swap(t[k],t[a*3+b]);

    版本号排序：【滴滴提前批】

    leetCode394字符串解码【地平线一面、金山笔试】

    k[encoded_string]

    A.正则表达式

    B.递归

    C.栈

    消除相邻同字符【地平线一面】

    龙湖一面

    输入1返回0，输入0返回1

    条件（三元）运算符

    位运算（异或操作）

    逻辑 NOT 运算符

    减法

    条件语句

    数组映射

    求和1-100的数组

    等差数列

    reduce

    拓展：等比数列

    虚拟DOM【腾讯音乐笔试】

    1. class VNode {
    2.   constructor(tagName, props, children) {
    3.     this.tagName = tagName;
    4.     this.props = props;
    5.     this.children = children;
    6.   }
    7. }
    8.  
    9. const h = (tagName, props, children) => new VNode(tagName, props, children);
    10.  
    11. const ul = h('ul', { id: 'list', style: 'color:red' }, [
    12.   h('li', { class: 'item' }, ['Item 1']),
    13.   h('li', { class: 'item' }, ['Item 2']),
    14.   h('li', { class: 'item' }, ['Item 3'])
    15. ]);
    16.  
    17. // 渲染目标DOM
    18. function render(node) {
    19.   const element = document.createElement(node.tagName);
    20.   element.id = node.props.id;
    21.   element.style = node.props.style;
    22.  
    23.   for (let i = 0; i < node.children.length; i++) {
    24.     const child = node.children[i];
    25.     const childElement = render(child);
    26.     element.appendChild(childElement);
    27.   }
    28.  
    29.   return element;
    30. }
    31.  
    32. const ulDom = render(ul);
    33. console.log(ulDom);

    连字转驼峰【美团一面】

    1.split('-')

    2.toUpperCase()

    3.slice(1)

    1. function transformString(input) {
    2.   const words = input.split('-'); // 使用连字符分割字符串
    3.   let result = '';
    4.  
    5.   for (let i = 0; i < words.length; i++) {
    6.     if (i === 0) {
    7.       result += words[i]; // 第一个单词保持不变
    8.     } else if (words[i]) {
    9.       result += words[i][0].toUpperCase() + words[i].slice(1); // 非空单词首字母大写
    10.     }
    11.   }
    12.  
    13.   return result;
    14. }
    15.  
    16. // 示例用法
    17. const inputString = '-font-size';
    18. const transformedString = transformString(inputString);
    19. console.log(transformedString); // 输出 'fontSize'

    用友sp

    一面【二选一】

    数组相邻和最大的对应两个元素
    千位分割【无负数，含小数】
    1. function formatNumberWithCommas(number) {
    2.     // 将数字转换为字符串
    3.     const numStr = number.toString();
    4.     
    5.     // 判断是否为小数
    6.     const isDecimal = numStr.includes('.');
    7.     
    8.     // 如果是小数，分割整数部分和小数部分
    9.     let integerPart = numStr;
    10.     let decimalPart = '';
    11.     if (isDecimal) {
    12.         [integerPart, decimalPart] = numStr.split('.');
    13.     }
    14.     
    15.     // 使用贪心算法从右往左插入逗号
    16.     let formattedInteger = '';
    17.     let count = 0;
    18.     for (let i = integerPart.length - 1; i >= 0; i--) {
    19.         formattedInteger = integerPart[i] + formattedInteger;
    20.         count++;
    21.         if (count === 3 && i !== 0) {
    22.             formattedInteger = ',' + formattedInteger;
    23.             count = 0;
    24.         }
    25.     }
    26.     
    27.     // 如果有小数部分，添加回小数点和小数部分
    28.     const formattedNumber = isDecimal
    29.         ? formattedInteger + '.' + decimalPart
    30.         : formattedInteger;
    31.     
    32.     return formattedNumber;
    33. }
    34.  
    35. // 测试
    36. const number1 = -1234567.89;
    37. const number2 = 12345.67;
    38. const number3 = 123456;
    39. console.log(formatNumberWithCommas(number1)); // 输出 "-1,234,567.89"
    40. console.log(formatNumberWithCommas(number2)); // 输出 "12,345.67"
    41. console.log(formatNumberWithCommas(number3)); // 输出 "123,456"

    二面

    华容道：BFS

    k / 3, y = k % 3; //一维数组下标转化到二维数组中的坐标
    swap(t[k],t[a*3+b]);

    distance 数组用于记录每个状态距离初始状态的步数。

    在华容道问题中，每次移动一次，就相当于从一个状态转移到了另一个状态。

    BFS的核心思想是从初始状态开始，逐步地将可能的状态加入队列，并记录每个状态距离初始状态经过的步数。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7.  
    8. int bfs(string start)
    9. {
    10.     string end = "12345678x";
    11.     
    12.     queue q;
    13.     unordered_mapint> d;
    14.     
    15.     q.push(start);
    16.     d[start] = 0;
    17.     
    18.     int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};
    19.     
    20.     //宽搜过程
    21.     while(q.size())
    22.     {
    23.         auto t = q.front();
    24.         q.pop();
    25.         
    26.         int distance = d[t];
    27.         
    28.         if(t == end) return distance;
    29.         
    30.         //状态转移
    31.         //找到x的位置
    32.         int k = t.find('x'); //返回x的下标
    33.         int x = k / 3, y = k % 3; //一维数组下标转化到二维数组中的坐标
    34.         
    35.         //枚举上下左右四个方向
    36.         for(int i = 0; i < 4; i ++ )
    37.         {
    38.             int a = x + dx[i], b = y + dy[i];
    39.             if(a >= 0 && a < 3 && b >= 0 && b < 3)
    40.             {
    41.                 swap(t[k],t[a*3+b]);
    42.                 
    43.                 if(!d.count(t)) //当前更新的状态没有搜到过
    44.                 {
    45.                     d[t] = distance + 1; //更新当前距离
    46.                     q.push(t); //把新的状态加到队列中
    47.                 }
    48.                 
    49.                 swap(t[k],t[a*3+b]); //状态恢复
    50.             }
    51.         }
    52.     }
    53.     
    54.     return -1;
    55. }
    56. int main()
    57. {
    58.     string start;
    59.     for(int i = 0 ; i < 9; i ++ )
    60.     {
    61.         char c;
    62.         cin >> c;
    63.         start += c;
    64.     }
    65.     
    66.     cout << bfs(start) << endl;
    67.     
    68.     return 0;
    69. }

    版本号排序：【滴滴提前批】

    1. // 假设有一个版本号数组
    2. const versionNumbers = ["1.0.2", "1.1.0", "2.0.0", "1.0.1"];
    3.  
    4. // 定义一个比较函数来进行版本号排序
    5. function compareVersions(versionA, versionB) {
    6.     const partsA = versionA.split('.').map(Number);
    7.     const partsB = versionB.split('.').map(Number);
    8.  
    9.     for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
    10.         const partA = partsA[i] || 0;
    11.         const partB = partsB[i] || 0;
    12.  
    13.         if (partA < partB) return -1;
    14.         if (partA > partB) return 1;
    15.     }
    16.  
    17.     return 0;
    18. }
    19.  
    20. // 使用比较函数对版本号数组进行排序
    21. const sortedVersions = versionNumbers.sort(compareVersions);
    22.  
    23. // 打印排序后的版本号数组
    24. console.log(sortedVersions);

    leetCode394字符串解码【地平线一面、金山笔试】

    k[encoded_string]

    表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数

    示例1：

    输入：s = "3[a]2[bc]"

    输出："aaabcbc"

    示例2：

    输入：s = "3[a2[c]]"

    输出："accaccacc"

    输入：s = "2[abc]3[cd]ef"

    输出："abcabccdcdcdef"

    A.正则表达式

    1. var decodeString = function(s) {
    2.     const regex = /\d+\[[a-zA-Z]+\]/g; // Match patterns like cnt[str]
    3.     
    4.     while (s.match(regex)) {
    5.         s = s.replace(regex, (match) => {
    6.             const cnt = parseInt(match.match(/\d+/)[0]); 
    7.             const subStr = match.match(/[a-zA-Z]+/)[0];    
    8.             return subStr.repeat(cnt);  // Repeat str cnt times
    9.         });
    10.     }
    11.     
    12.     return s;
    13. };

    B.递归

    1. function flattenString(str) {
    2.     let result = '';
    3.     
    4.     for (let i = 0; i < str.length; i++) {
    5.         if (str[i] >= '0' && str[i] <= '9') { // 如果当前字符是数字
    6.             let j = i;
    7.             while (j < str.length && str[j] >= '0' && str[j] <= '9') j++; // 找到所有的数字字符
    8.             let num = parseInt(str.substring(i, j)); // 转化为数字
    9.  
    10.             let count = 1; // 用于找到与当前左括号匹配的右括号
    11.             let k = j + 1;
    12.             while (k < str.length) {
    13.                 if (str[k] === '[') count++;
    14.                 else if (str[k] === ']') count--;
    15.  
    16.                 if (count === 0) break;
    17.                 k++;
    18.             }
    19.  
    20.             let innerStr = flattenString(str.substring(j + 1, k)); // 递归地处理方括号内的字符串
    21.             while (num-- > 0) result += innerStr;
    22.  
    23.             i = k; // 移动索引位置
    24.         } else if (str[i] !== '[' && str[i] !== ']') { // 忽略方括号
    25.             result += str[i];
    26.         }
    27.     }
    28.  
    29.     return result;
    30. }
    31.

    C.栈

    1. /**
    2.  * @param {string} s
    3.  * @return {string}
    4.  */
    5. var decodeString = function(s) {
    6.     let subStr = '';
    7.     const stack = [];
    8.     
    9.     for (const char of s) {
    10.         if (char === ']') {
    11.             let cur = stack.pop();
    12.             
    13.             // Build the subStr within the brackets
    14.             while (cur !== '[') {
    15.                 subStr = cur + subStr;
    16.                 cur = stack.pop();
    17.             }
    18.  
    19.             let num = '';
    20.             cur = stack.pop();
    21.             
    22.             // Extract the repetition count
    23.             while (!isNaN(cur)) {
    24.                 num = cur + num;
    25.                 cur = stack.pop();
    26.             }
    27.             
    28.             // Put back any non-numeric characters
    29.             if (cur !== undefined) {
    30.                 stack.push(cur);
    31.             }
    32.  
    33.             // Repeat subStr and push it back onto the stack
    34.             stack.push(subStr.repeat(parseInt(num, 10)));
    35.  
    36.             subStr = '';
    37.         } else {
    38.             stack.push(char);
    39.         }
    40.     }
    41.     
    42.     return stack.join('');
    43. };

    消除相邻同字符【地平线一面】

    1. function eliminateAdjacentDuplicates(input) {
    2.   const result = [];
    3.   
    4.   for (let i = 0; i < input.length; i++) {
    5.     if (i === 0 || input[i] !== input[i - 1]) {
    6.       result.push(input[i]);
    7.     }
    8.   }
    9.   
    10.   return result.join('');
    11. }
    12.  
    13. const inputString = 'abccbbb';
    14. const resultString = eliminateAdjacentDuplicates(inputString);
    15. console.log(resultString); // 输出 'abcb'

    龙湖一面

    输入1返回0，输入0返回1

    条件（三元）运算符

    位运算（异或操作）

    逻辑 NOT 运算符

    减法

    条件语句

    数组映射

    求和1-100的数组

    等差数列

    reduce

    1. const array = Array.from({ length: 100 }, (_, i) => i + 1); // 创建包含1到100的数组
    2.  
    3. const sum = array.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
    4.  
    5. console.log(sum); // 输出5050

    拓展：等比数列

  • 相关阅读:
    电脑端微信无法打开腾讯文档
    Redis：Redis配置文件相关配置、Redis的持久化
    chrome extension 普通网页与插件直接通信
    Ubuntu系统中tree的用法
    大一新生HTML期末作业 学生个人网页设计作业 HTML5响应式个人简历网站模板 web前端网页制作课作业
    Vue：状态管理pinia
    一小时快速上手win10 docker 、vscode、MobaXterm、git协作开发
    Java反射详解，还有什么理由学不会
    活动预告|“构建新安全格局”专家研讨会即将开幕
    爬虫 - CSS表达式
  • 原文地址：https://blog.csdn.net/qq_28838891/article/details/132890586