乐信圣文笔试题

乐信圣文

5进制的1023转换为10进制是多少？转换为7进制是多少?

计算过程：

1023(5) => 15^3 + 0 + 25^1 + 3*5^0 = 125+10+3= 138(10)

138(10) => 138/7= 19…5 19/7 = 2….5 2/7=0…..2

255(7) = 51+57+2*49= 40+98= 138（10）

答：5进制的1023转换为10进制是138。转换为7进制是255。

比较四种排序算法的时间复杂度，空间复杂度，稳定性，适用场景（插入，快排，归并，堆排）

排序算法	时间复杂度（平均）	时间复杂度（最坏）	空间复杂度	稳定性
插入排序	O(n²)	O(n²)	O(1)	稳定
快速排序	O(nlogn)	O(n²)	O (logn)（递归栈）	不稳定
归并排序	O(nlogn)	O(nlogn)	O (n)（辅助数组）	稳定
堆排序	O(nlogn)	O(nlogn)	O(1)	不稳定

• 插入排序：小规模数据、接近有序的数据、作为复杂排序算法的子过程（如快排的小规模子数组）。
• 快速排序：通用场景优先选择，如数据库排序、日常开发中的大部分排序需求。
• 归并排序：需要稳定排序的场景、外部排序（如超大文件排序）、对时间复杂度稳定性要求高的场景。
• 堆排序：内存受限的场景、嵌入式系统、无需稳定排序且追求空间效率的场景。

进程和线程的概念？它们的区别有哪些？

进程：是操作系统分配资源的最小单位。进程可以类比为工厂，其中包含地址空间和资源和执行任务的线程。

线程：是操作系统中执行CPU调度的最小单位。线程可以类比为工人，它可以使用进程内的资源和地址空间，负责执行进程分配的任务。

区别：

1、进程是完整的一套程序，包含自己的地址空间和资源。而线程是进程的一部分，一个进程可以有多个线程，并且这些线程共享进程的相关资源。

2、进程间隔离性强，并发安全，进程A崩溃不会影响进程B。而线程由于共享进程资源，所以进程A内的线程a崩溃会导致线程b也崩溃，所以存在并发不安全的问题。

3、进程间通信需要依赖管道、信号量、信号、消息队列、共享内存等机制。而线程间通信由于共享进程资源，所以较为容易。

分辨率为1024x1024的RGBA32格式图片的内存占用多少字节？

• 单像素字节数：RGBA32 格式中，R（红）、G（绿）、B（蓝）、A（透明度）各占 8 位（1 字节），因此每个像素占用 4 字节。
• 总像素数：1024 × 1024 = 1,048,576 像素。
• 总内存占用：总像素数 × 单像素字节数 = 1,048,576 × 4 = 4,194,304 字节（即 4MB，1MB = 1024×1024 字节）。

结论：该图片的内存占用为 4,194,304 字节（4MB）。

两个数组合并并去重

using System;
using System.Collections.Generic;
using System.Linq;

public class ArrayMerger
{
    /// <summary>
    /// 合并两个整数数组并去重
    /// </summary>
    /// <param name="arr1">第一个数组</param>
    /// <param name="arr2">第二个数组</param>
    /// <returns>合并后去重的新数组</returns>
    public static int[] MergeAndRemoveDuplicates(int[] arr1, int[] arr2)
    {
        // 处理null情况（若输入为null，视为空数组）
        arr1 ??= Array.Empty<int>();
        arr2 ??= Array.Empty<int>();

        // 合并两个数组并转换为HashSet（自动去重）
        HashSet<int> uniqueSet = new HashSet<int>(arr1);
        foreach (int num in arr2)
        {
            uniqueSet.Add(num); // HashSet.Add() 会忽略重复元素
        }

        // 将HashSet转换为数组并返回
        return uniqueSet.ToArray();
    }
}

判断密码是否合法

using System;

public class PasswordValidator
{
    /// <summary>
    /// 判断密码是否合法
    /// </summary>
    /// <param name="password">待验证的密码</param>
    /// <returns>合法返回true，否则返回false</returns>
    public static bool IsValidPassword(string password)
    {
        // 检查长度：8-16字符
        if (password == null || password.Length < 8 || password.Length > 16)
        {
            return false;
        }

        bool hasLower = false;   // 是否包含小写字母
        bool hasUpper = false;   // 是否包含大写字母
        bool hasDigit = false;   // 是否包含数字

        foreach (char c in password)
        {
            if (char.IsLower(c))
            {
                hasLower = true;
            }
            else if (char.IsUpper(c))
            {
                hasUpper = true;
            }
            else if (char.IsDigit(c))
            {
                hasDigit = true;
            }
            else
            {
                // 包含其他字符（如符号、空格等），直接非法
                return false;
            }
        }
        // 统计符合条件的字符类型数量（至少两种）
        int typeCount = 0;
        if (hasLower) typeCount++;
        if (hasUpper) typeCount++;
        if (hasDigit) typeCount++;

        return typeCount >= 2;
    }
}

扑克牌包含13*4张牌。洗牌，每次从牌堆顶抽牌，按照同种花色K->A(K在最上，A在最下）的顺序排列成4列。假设已洗好牌，编写代码将牌堆按照要求完成排列

using System;
using System.Collections.Generic;
using System.Linq;
// 定义花色（4种）
public enum Suit
{
    Spades,   // 黑桃
    Hearts,   // 红桃
    Clubs,    // 梅花
    Diamonds  // 方块
}
// 定义点数（13种，按K→A的优先级排序）
public enum Rank
{
    K = 13,   // 优先级最高（13）
    Q = 12,
    J = 11,
    T10 = 10,
    T9 = 9,
    T8 = 8,
    T7 = 7,
    T6 = 6,
    T5 = 5,
    T4 = 4,
    T3 = 3,
    T2 = 2,
    A = 1     // 优先级最低（1）
}
// 扑克牌类
public class Card
{
    public Suit Suit { get; }
    public Rank Rank { get; }

    public Card(Suit suit, Rank rank)
    {
        Suit = suit;
        Rank = rank;
    }

    // 重写ToString便于输出
    public override string ToString()
    {
        string rankStr = Rank switch
        {
            Rank.A => "A",
            Rank.T2 => "2",
            Rank.T3 => "3",
            Rank.T4 => "4",
            Rank.T5 => "5",
            Rank.T6 => "6",
            Rank.T7 => "7",
            Rank.T8 => "8",
            Rank.T9 => "9",
            Rank.T10 => "10",
            Rank.J => "J",
            Rank.Q => "Q",
            Rank.K => "K",
            _ => throw new ArgumentOutOfRangeException()
        };
        return $"{rankStr}({Suit})";
    }
}
public class PokerArranger
{
    /// <summary>
    /// 将洗好的牌堆按规则排列成4列
    /// </summary>
    /// <param name="shuffledDeck">已洗好的牌堆（队列，从顶部抽牌即出队）</param>
    /// <returns>4列牌（每列对应一种花色，顺序为K→A）</returns>
    public List<List<Card>> Arrange(Queue<Card> shuffledDeck)
    {
        // 初始化4列（对应4种花色）
        var columns = new Dictionary<Suit, List<Card>>
        {
            { Suit.Spades, new List<Card>() },
            { Suit.Hearts, new List<Card>() },
            { Suit.Clubs, new List<Card>() },
            { Suit.Diamonds, new List<Card>() }
        };

        // 依次从牌堆顶部抽牌（出队）
        while (shuffledDeck.Count > 0)
        {
            Card currentCard = shuffledDeck.Dequeue();
            List<Card> targetColumn = columns[currentCard.Suit];

            // 按K→A的顺序插入当前列的头部（确保后抽的高优先级牌在上方）
            // 原理：点数优先级高的牌（如K）应放在更前面，插入时直接加在头部
            targetColumn.Insert(0, currentCard);
        }

        // 转换为按花色顺序排列的列表（黑桃→红桃→梅花→方块）
        return new List<List<Card>>
        {
            columns[Suit.Spades],
            columns[Suit.Hearts],
            columns[Suit.Clubs],
            columns[Suit.Diamonds]
        };
    }
}
public class Program
{
    public static void Main()
    {
        // 模拟一副洗好的牌（实际场景中这是随机洗牌后的结果）
        // 此处为了测试，手动生成一组牌（包含所有花色和点数）
        var allCards = new List<Card>();
        foreach (Suit suit in Enum.GetValues(typeof(Suit)))
        {
            foreach (Rank rank in Enum.GetValues(typeof(Rank)))
            {
                allCards.Add(new Card(suit, rank));
            }
        }
        // 打乱顺序（模拟洗牌）
        var rng = new Random();
        var shuffledDeck = new Queue<Card>(allCards.OrderBy(c => rng.Next()));

        // 排列牌
        var arranger = new PokerArranger();
        var columns = arranger.Arrange(shuffledDeck);

        // 输出结果（4列，每列从上到下为K→A）
        for (int i = 0; i < columns.Count; i++)
        {
            Console.WriteLine($"第{i + 1}列（{columns[i].First().Suit}）：");
            foreach (var card in columns[i])
            {
                Console.WriteLine($"  {card}");
            }
            Console.WriteLine();
        }
    }
}

说明MonoBehavior中的关于生命周期的函数，关于使用时机进行排序

Awake` → `OnEnable` → `Start` → （每帧循环：`FixedUpdate` → `Update` → `LateUpdate` → 碰撞 / 交互函数 → `OnGUI`） → `OnDisable` → `OnDestroy` → `OnApplicationQuit