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

class VNode {
  constructor(tagName, props, children) {
    this.tagName = tagName;
    this.props = props;
    this.children = children;
  }
}

const h = (tagName, props, children) => new VNode(tagName, props, children);

const ul = h('ul', { id: 'list', style: 'color:red' }, [
  h('li', { class: 'item' }, ['Item 1']),
  h('li', { class: 'item' }, ['Item 2']),
  h('li', { class: 'item' }, ['Item 3'])
]);

// 渲染目标DOM
function render(node) {
  const element = document.createElement(node.tagName);
  element.id = node.props.id;
  element.style = node.props.style;

  for (let i = 0; i < node.children.length; i++) {
    const child = node.children[i];
    const childElement = render(child);
    element.appendChild(childElement);
  }

  return element;
}

const ulDom = render(ul);
console.log(ulDom);

连字转驼峰【美团一面】

1.split('-')

2.toUpperCase()

3.slice(1)

function transformString(input) {
  const words = input.split('-'); // 使用连字符分割字符串
  let result = '';

  for (let i = 0; i < words.length; i++) {
    if (i === 0) {
      result += words[i]; // 第一个单词保持不变
    } else if (words[i]) {
      result += words[i][0].toUpperCase() + words[i].slice(1); // 非空单词首字母大写
    }
  }

  return result;
}

// 示例用法
const inputString = '-font-size';
const transformedString = transformString(inputString);
console.log(transformedString); // 输出 'fontSize'

用友sp

一面【二选一】

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

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

function formatNumberWithCommas(number) {
    // 将数字转换为字符串
    const numStr = number.toString();
    
    // 判断是否为小数
    const isDecimal = numStr.includes('.');
    
    // 如果是小数，分割整数部分和小数部分
    let integerPart = numStr;
    let decimalPart = '';
    if (isDecimal) {
        [integerPart, decimalPart] = numStr.split('.');
    }
    
    // 使用贪心算法从右往左插入逗号
    let formattedInteger = '';
    let count = 0;
    for (let i = integerPart.length - 1; i >= 0; i--) {
        formattedInteger = integerPart[i] + formattedInteger;
        count++;
        if (count === 3 && i !== 0) {
            formattedInteger = ',' + formattedInteger;
            count = 0;
        }
    }
    
    // 如果有小数部分，添加回小数点和小数部分
    const formattedNumber = isDecimal
        ? formattedInteger + '.' + decimalPart
        : formattedInteger;
    
    return formattedNumber;
}

// 测试
const number1 = -1234567.89;
const number2 = 12345.67;
const number3 = 123456;
console.log(formatNumberWithCommas(number1)); // 输出 "-1,234,567.89"
console.log(formatNumberWithCommas(number2)); // 输出 "12,345.67"
console.log(formatNumberWithCommas(number3)); // 输出 "123,456"

二面

华容道：BFS

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

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

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

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

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

#include <iostream>
#include <algorithm>
#include <queue>
#include <unordered_map>
 
using namespace std;
 
int bfs(string start)
{
    string end = "12345678x";
    
    queue<string> q;
    unordered_map<string,int> d;
    
    q.push(start);
    d[start] = 0;
    
    int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};
    
    //宽搜过程
    while(q.size())
    {
        auto t = q.front();
        q.pop();
        
        int distance = d[t];
        
        if(t == end) return distance;
        
        //状态转移
        //找到x的位置
        int k = t.find('x'); //返回x的下标
        int x = k / 3, y = k % 3; //一维数组下标转化到二维数组中的坐标
        
        //枚举上下左右四个方向
        for(int i = 0; i < 4; i ++ )
        {
            int a = x + dx[i], b = y + dy[i];
            if(a >= 0 && a < 3 && b >= 0 && b < 3)
            {
                swap(t[k],t[a*3+b]);
                
                if(!d.count(t)) //当前更新的状态没有搜到过
                {
                    d[t] = distance + 1; //更新当前距离
                    q.push(t); //把新的状态加到队列中
                }
                
                swap(t[k],t[a*3+b]); //状态恢复
            }
        }
    }
    
    return -1;
}
int main()
{
    string start;
    for(int i = 0 ; i < 9; i ++ )
    {
        char c;
        cin >> c;
        start += c;
    }
    
    cout << bfs(start) << endl;
    
    return 0;
}

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

// 假设有一个版本号数组
const versionNumbers = ["1.0.2", "1.1.0", "2.0.0", "1.0.1"];

// 定义一个比较函数来进行版本号排序
function compareVersions(versionA, versionB) {
    const partsA = versionA.split('.').map(Number);
    const partsB = versionB.split('.').map(Number);

    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
        const partA = partsA[i] || 0;
        const partB = partsB[i] || 0;

        if (partA < partB) return -1;
        if (partA > partB) return 1;
    }

    return 0;
}

// 使用比较函数对版本号数组进行排序
const sortedVersions = versionNumbers.sort(compareVersions);

// 打印排序后的版本号数组
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.正则表达式

var decodeString = function(s) {
    const regex = /\d+\[[a-zA-Z]+\]/g; // Match patterns like cnt[str]
    
    while (s.match(regex)) {
        s = s.replace(regex, (match) => {
            const cnt = parseInt(match.match(/\d+/)[0]); 
            const subStr = match.match(/[a-zA-Z]+/)[0];    
            return subStr.repeat(cnt);  // Repeat str cnt times
        });
    }
    
    return s;
};

B.递归

function flattenString(str) {
    let result = '';
    
    for (let i = 0; i < str.length; i++) {
        if (str[i] >= '0' && str[i] <= '9') { // 如果当前字符是数字
            let j = i;
            while (j < str.length && str[j] >= '0' && str[j] <= '9') j++; // 找到所有的数字字符
            let num = parseInt(str.substring(i, j)); // 转化为数字

            let count = 1; // 用于找到与当前左括号匹配的右括号
            let k = j + 1;
            while (k < str.length) {
                if (str[k] === '[') count++;
                else if (str[k] === ']') count--;

                if (count === 0) break;
                k++;
            }

            let innerStr = flattenString(str.substring(j + 1, k)); // 递归地处理方括号内的字符串
            while (num-- > 0) result += innerStr;

            i = k; // 移动索引位置
        } else if (str[i] !== '[' && str[i] !== ']') { // 忽略方括号
            result += str[i];
        }
    }

    return result;
}

C.栈

/**
 * @param {string} s
 * @return {string}
 */
var decodeString = function(s) {
    let subStr = '';
    const stack = [];
    
    for (const char of s) {
        if (char === ']') {
            let cur = stack.pop();
            
            // Build the subStr within the brackets
            while (cur !== '[') {
                subStr = cur + subStr;
                cur = stack.pop();
            }

            let num = '';
            cur = stack.pop();
            
            // Extract the repetition count
            while (!isNaN(cur)) {
                num = cur + num;
                cur = stack.pop();
            }
            
            // Put back any non-numeric characters
            if (cur !== undefined) {
                stack.push(cur);
            }

            // Repeat subStr and push it back onto the stack
            stack.push(subStr.repeat(parseInt(num, 10)));

            subStr = '';
        } else {
            stack.push(char);
        }
    }
    
    return stack.join('');
};

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

function eliminateAdjacentDuplicates(input) {
  const result = [];
  
  for (let i = 0; i < input.length; i++) {
    if (i === 0 || input[i] !== input[i - 1]) {
      result.push(input[i]);
    }
  }
  
  return result.join('');
}

const inputString = 'abccbbb';
const resultString = eliminateAdjacentDuplicates(inputString);
console.log(resultString); // 输出 'abcb'

龙湖一面

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

条件（三元）运算符

位运算（异或操作）

逻辑 NOT 运算符

减法

条件语句

数组映射

求和1-100的数组

等差数列

reduce

const array = Array.from({ length: 100 }, (_, i) => i + 1); // 创建包含1到100的数组

const sum = array.reduce((accumulator, currentValue) => accumulator + currentValue, 0);

console.log(sum); // 输出5050