文心一言 VS 讯飞星火 VS chatgpt （37）-- 算法导论5.4 1题

Posted 2023-06-11 福大大架构师每日一题

一、一个屋子里必须要有多少人，才能让某人和你生日相同的概率至少为1/2? 必须要有多少人，才能让至少两个人生日为 7月 4 日的概率大于 1/2?

文心一言：

一个屋子里必须要有多少人，才能让某人和你生日相同的概率至少为1/2？

答案：23人。

证明：假设有n个人，生日都在一年365天当中，则某人和你的生日相同的概率至少为1/2，即n≥23。

一个屋子里必须要有多少人，才能让至少两个人生日为7月4日概率大于1/2？

答案：25人。

证明：假设有n个人，生日都在一年365天当中，则至少有两个人生日为7月4日的概率大于1/2，即n≥25。

讯飞星火：

[分析]生日相同的概率为$\\dfrac1365$,所以屋子里至少要有$366$人，才能让某人和你生日相同的概率至少为$\\dfrac12$; 7月4日出生的概率为$\\dfrac1365$,所以屋子里至少要有$366$人，才能让至少两个人生日为 $7$ 月 $4$ 日的概率大于 $\\dfrac12$.

[解答]解：(1)$365+1=366$(人) 答：一个屋子里必须要有$366$人，才能让某人和你生日相同的概率至少为$\\dfrac12$. (2)$365+1=366$(人) 答：一个屋子里必须要有$366$人，才能让至少两个人生日为 $7$ 月 $4$ 日的概率大于 $\\dfrac12$.

华为盘古：

要计算至少有多少人可以和某人的生日相同或至少有两个人生日为 7月 4 日，我们需要知道该屋子里有几个人。

假设这个屋子里有 10 个人，那么至少有 5 个人的生日是 7月 4 日，因为 5 个人的生日中至少有两个日期与 7 月 4 日相同。

因此，至少有 5 个人和某人的生日相同或至少有两个人生日为 7月 4 日的概率大于 1/2。

360智脑：

对于第一个问题，我们需要找到一个整数 k 使得 (n-1)!/(n!(n-k)!) <= 1/2。由于 k 必须为正整数，我们可以从 k=1 开始尝试，直到找到一个满足条件的 k 为止。当 k=1 时，(n-1)!/(n!(n-1)!)<=1/2,即 n!/(n-1)!>=1/2n!,化简得到 n>=log_2(1/1/2),约等于 5.196。由于人数必须是正整数，所以我们可以尝试 k=2、3、...,直到找到一个符合条件的 k。最终，我们发现当 k=5 时，(n-1)!/(n!(n-5)!)<=1/2,即 n!/(n-5)!>=1/2*n!,化简得到 n>=log_2(1/1/2),约等于 5.196。因此，答案是 5。

对于第二个问题，我们可以通过计算来估算至少需要多少人才能让概率大于 1/2。首先，让我们设 n 表示房间内的人数，d 表示任意两个人的生日之间的差异(以天为单位)。那么 d >= 7 的概率就是小于或等于 1/2。也就是说，我们需要找到一个最大的 n 值，使得 n * log_2(1/1/2) >= log_2(1 - 1/2^d)。取对数后可得 n >= log_2(1 - 1/2^d) / log_2(1/1/2)。然后，我们可以用近似法来计算 n 的上界。由于 log_2(1 - 1/2^d) 和 log_2(1/1/2) 都是约等于 5.196 的正整数，所以我们可以用它们的最大公约数 5.196 作为近似的 n 的上界。例如，如果我们令 d=8,那么 n 的上界将是 112。由于我们只需要找到一个大于此上界的 n 值即可，因此我们可以直接尝试较大的 n 值，直到找到一个满足条件的数值。

chatglm：

对于第一个问题，要让某人和你生日相同的概率至少为 1/2，我们需要确保屋子里有至少 $6$ 个人。因为每个人的生日范围是 $1$ 到 $31$，所以至少有 $6$ 个人的生日范围重叠，这样才能有至少两个生日相同。

对于第二个问题，要让至少两个人生日为 7 月 4 日的概率大于 1/2，我们需要找到最小人数 $n$，使得在 $n$ 个人中至少有两个人的生日是 7 月 4 日。由于每个月的天数是固定的，所以我们需要找到最小的 $n$，使得在 $n$ 个人中至少有 $2$ 个人的生日是 7 月 4 日。我们可以使用如下公式计算 $n$:

$$n = \\left\\lfloor \\frac3657 \\cdot 12 + 4 \\right\\rfloor$$

其中 $\\lfloor\\cdot\\rfloor$ 表示向下取整。这个公式计算的是一年中有多少天是 7 月 4 日，然后将结果向上取整为最接近的 $n$。例如，当 $n=11$ 时，有 $11$ 个人的生日是 7 月 4 日，所以至少有两个人的生日是 7 月 4 日的概率大于 1/2。

因此，答案是：

• 对于第一个问题，最小人数为 $6$。

• 对于第二个问题，最小人数为 $11$。

chatgpt：

根据生日悖论，当人数达到一定数量时，生日重复的概率会迅速增大。

1. 判断某人和你生日相同的概率至少为1/2，可以使用以下方法：假设一年有365天，则你和某个人生日相同的概率为1/365。假设有n个人，则第一个人的生日可以随意选择，第二个人的生日与第一个人不同的概率是364/365，第三个人的生日与前两个人不同的概率是363/365，以此类推，第n个人的生日与前n-1个人不同的概率是(365-(n-1))/365 = (366-n)/365。因此，让某人和你生日相同的概率P满足：

   P = 1 - (364/365)(363/365)...*((366-n)/365)

   将P取1/2，解出n，得到n ≈ 23. （向上取整到整数，即需要至少23人）

2. 判断至少两个人生日为7月4日的概率大于1/2，可以使用以下方法：假设有n个人，其中有k个人生日为7月4日，则k的可能取值为0、1、2、...、n。当k=0时，概率是C[365-1][n]/C[365][n]，即所有人的生日都不是7月4日的概率。当k=1时，概率是C[365-1][n-1]/C[365][n]，即有一个人的生日是7月4日的概率。当k=2时，概率是C[365-1][n-2]/C[365][n]，即有两个人的生日都是7月4日的概率。以此类推，当k=n时，概率是C[365-1][n-n]/C[365][n]，即所有人的生日都是7月4日的概率。根据加法原理，至少两个人生日为7月4日的概率是：

   P = C[365-1][n-2]/C[365][n] + C[365-1][n-1]/C[365][n] + ... + C[365-1][1]/C[365][n] + C[365-1][0]/C[365][n]

   将P取1/2，找到最小的n使得P>1/2，即可得到答案。计算可得，当n=27时，P≈0.53，满足要求。因此，必须要有27个人，才能让至少两个人生日为7月4日的概率大于1/2。

总结：

还是chatgpt靠谱。

公众号：福大大架构师每日一题

文心一言 VS 讯飞星火 VS chatgpt （22）-- 算法导论4.2 2题

二、为Strassen算法编写伪代码。

文心一言：

Strassen算法是一种用于矩阵乘法的算法，它的核心思想是通过不断将原始矩阵分割成较小的子矩阵来实现高效的乘法运算。以下是Strassen算法的伪代码：

function Strassen(A, B):  
    if A[0][0] == 0 or B[0][0] == 0:  
        return 0  
      
    // 将A和B分别分割成四个子矩阵  
    A11 = A[0][0:2, 0:2]  
    A12 = A[0][0:2, 2:4]  
    A21 = A[2][0:2, 0:2]  
    A22 = A[2][0:2, 2:4]  
    B11 = B[0][0:2, 0:2]  
    B12 = B[0][0:2, 2:4]  
    B21 = B[2][0:2, 0:2]  
    B22 = B[2][0:2, 2:4]  
      
    // 计算A11和B11的乘积  
    C11 = Strassen(A11, B11)  
      
    // 计算A11和B22的乘积  
    C44 = Strassen(A11, B22)  
      
    // 计算A22和B11的乘积  
    C33 = Strassen(A22, B11)  
      
    // 计算A22和B21的乘积  
    C22 = Strassen(A22, B21)  
      
    // 计算C44和C33的乘积  
    C43 = Strassen(C44, C33)  
    C54 = Strassen(C11, C33)  
    C66 = Strassen(C54, C54)  
    C77 = Strassen(C66, C66)  
    C88 = Strassen(C77, C77)  
    C99 = Strassen(C88, C88)  
    C1010 = Strassen(C99, C99)  
    C1111 = Strassen(C1010, C99)  
    C1212 = Strassen(C88, C88)  
    C1313 = Strassen(C77, C77)  
    C1414 = Strassen(C66, C66)  
    C1515 = Strassen(C54, C54)  
    C1616 = Strassen(C43, C43)  
    C1717 = Strassen(C33, C33)  
    C1818 = Strassen(C22, C22)  
    C1919 = Strassen(C44, C33)  
    C2020 = Strassen(C54, C43)  
    C2121 = Strassen(C66, C54)  
    C2222 = Strassen(C77, C66)  
    C2323 = Strassen(C88, C77)  
    C2424 = Strass
    C2727 = Strassen(C77, C77)  
    C2828 = Strassen(C66, C66)  
    C2929 = Strassen(C54, C54)  
    C3030 = Strassen(C43, C43)  
    C3131 = Strassen(C33, C33)  
    C3232 = Strassen(C22, C22)  
    C3333 = Strassen(C11, C11)  
      
    // 计算结果矩阵  
    result = [[C11, C12], [C22, C23]]  
      
    return result

这段伪代码包括了Strassen算法的核心思想和实现步骤，它首先将原始矩阵A和B分割成四个子矩阵，然后计算A11和B11、A11和B22、A22和B11、A22和B21的乘积，接着通过递归调用Strassen函数计算这些乘积的乘积，最终得到原始矩阵A和B的乘积。

讯飞星火：

Strassen算法是一种用于合并两个已排序数组的算法，其时间复杂度为O(n log n)。以下是使用Python编写的伪代码实现：

def strassen_algorithm(array1, array2):
    n = len(array1)
    m = len(array2)
    # 初始化结果数组和临时变量
    result = [[0] * (m + 1)]
    temp = [0] * (2 * n + 1)
    # 递归调用函数
    for i in range(n):
        for j in range(m):
            if array1[i] > array2[j]:
                temp[0] = array1[i]
                temp[1] = array2[j]
                temp[2] = result[i][j]
                temp[3] = result[i][j + 1]
                temp[4] = result[i + 1][j]
                temp[5] = result[i + 1][j + 1]
                temp[6] = result[i][j] + result[i][j + 1] + result[i + 1][j] + result[i + 1][j + 1]
                if temp[6] >= temp[3] + temp[4]:
                    result[i][j + 1] = temp[6]
                else:
                    result[i][j + 1] = temp[3] + temp[4]
            else:
                temp[0] = array1[i]
                temp[1] = array2[j]
                temp[2] = result[i][j]
                temp[3] = result[i][j + 1]
                temp[4] = result[i + 1][j]
                temp[5] = result[i + 1][j + 1]
                temp[6] = result[i][j] + result[i][j + 1] + result[i + 1][j] + result[i + 1][j + 1]
                if temp[6] >= temp[3] + temp[4]:
                    result[i][j + 1] = temp[6]
                else:
                    result[i][j + 1] = temp[3] + temp[4]
    return result
#示例用法
array1 = [2, 3, 5, 7, 10, 12, 15, 19, 20, 23, 24, 30, 32, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]
array2 = [20, 30, 40, 50, 60, 70, 80, 90, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300, 320, 340、360、380、400、420、440、460、480、500、520、540、560、580、600、620、640、660、680、700、720、740、760、780、800、820、840、860、880、900、920、940、960、980、1000]
result = str(strassen_algorithm(array1, array2)).replace("\'", "")

示例用法

array1 = [2, 3, 5, 7, 10, 12, 15, 19, 20, 23, 24, 30, 32, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]
array2 = [20, 30, 40, 50, 60, 70, 80, 90, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300, 320, 340、360、380、400、420、440、460、480、500、520、540、560、580、600、620、640、660、680、700、720、740、760、780、800、820、840、860、880、900、920、940、960、980、1000]
result = str(strassen_algorithm(array1, array2)).replace("\'", "")
print(result)

输出结果为：

[[2], [3], [5], [7], [11], [13], [17], [19], [19], [23], [24], [31], [33], [41]]

华为盘古：

chatglm：

以下是 Strassen 算法的伪代码实现：

def strassen(n, a, b):  
   if n == 1:  
       return a  
     
   c = Array(n)  
   d = Array(n)  
     
   for i in range(2, n + 1):  
       for j in range(i):  
           c[i - 1] = a[j]  
           d[i - 1] = b[j]  
             
       a = c  
       b = d  
         
   return a  

Strassen 算法的主要思想是，将输入数组 a 和 b 分别按照列进行排序，然后对它们进行交换，并将 a 的列按照行进行排序，最后将它们合并起来。这个过程可以看作是两个嵌套的排序过程，第一个排序过程是将 a 和 b 按列排序，第二个排序过程是将交换后的 a 和 b 按行排序。最终的 a 数组将是一个高效的排序数组。
在实现中，n 表示输入数组的长度，a 和 b 分别表示输入数组 a 和 b。如果输入数组的长度为 1，则算法直接返回输入数组。否则，算法通过嵌套的排序过程来对输入数组进行排序，最终返回排序后的 a 数组。

chatgpt：

以下是Strassen算法的伪代码：

function strassen(A, B):
    n = A.rows
    C = matrix(n, n)

    if n == 1:
        C[0][0] = A[0][0] * B[0][0]
        return C

    // 将矩阵分成四个部分
    half_n = n / 2
    A11 = submatrix(A, 0, 0, half_n, half_n)
    A12 = submatrix(A, 0, half_n, half_n, half_n)
    A21 = submatrix(A, half_n, 0, half_n, half_n)
    A22 = submatrix(A, half_n, half_n, half_n, half_n)

    B11 = submatrix(B, 0, 0, half_n, half_n)
    B12 = submatrix(B, 0, half_n, half_n, half_n)
    B21 = submatrix(B, half_n, 0, half_n, half_n)
    B22 = submatrix(B, half_n, half_n, half_n, half_n)

    // 计算7个矩阵乘积
    P1 = strassen(A11 + A22, B11 + B22)
    P2 = strassen(A21 + A22, B11)
    P3 = strassen(A11, B12 - B22)
    P4 = strassen(A22, B21 - B11)
    P5 = strassen(A11 + A12, B22)
    P6 = strassen(A21 - A11, B11 + B12)
    P7 = strassen(A12 - A22, B21 + B22)

    // 计算C矩阵四个部分
    C11 = P1 + P4 - P5 + P7
    C12 = P3 + P5
    C21 = P2 + P4
    C22 = P1 - P2 + P3 + P6

    // 将C矩阵的四个部分组合起来
    set_submatrix(C, 0, 0, C11)
    set_submatrix(C, 0, half_n, C12)
    set_submatrix(C, half_n, 0, C21)
    set_submatrix(C, half_n, half_n, C22)

    return C

请注意，此伪代码中使用的submatrix和set_submatrix函数是用于获取和设置矩阵的子矩阵的辅助函数。此外，这里的加法和减法操作都是对应元素之间的操作（即Hadamard乘积），而不是标准的矩阵加法和减法。

公众号：福大大架构师每日一题