我正在解决 Yandex 问题并遇到了这个问题：

6. 带答案恢复的 NOP 平均值给定两个序列，需要找到并输出它们的最大公共子序列。

   让我们提醒您：

   如果 x x 是通过从 𝑦 y 中删除几个（可能是零个或全部）元素得到的，则序列 x x 称为序列 y y 的子序列。

   最长公共子序列是两个序列的子序列中的最长序列。

   输入格式 输入数据的第一行包含数字 N – 第一个序列的长度（1 ≤ N ≤ ≤ 1000）。第二行包含第一个序列的成员（以空格分隔）——绝对值不超过 10,000 的整数。

   第三行包含数字 M – 第二个序列的长度（1 ≤ ≤ M ≤ ≤ 1000）。第四行指定第二个序列的成员（以空格分隔）——绝对值不超过 10,000 的整数。

   输出格式 要求输出给定序列的最大公共子序列，各个序列之间用空格分隔。如果有多个这样的子序列，那么输出其中任何一个都可以。

   注意：在示例2中，有三个最大公共子序列。

   1. 1

   2. 2

   3. 3

   其中任何一个都是正确答案。

首先我写了一个常规解决方案，它从第一个序列中取出所有子序列（从最长的开始），并将它们与第二个序列中相同长度的子序列进行比较。前几次测试都成功了，但后来我阅读了条件并意识到困难在于可以从序列中任意删除元素。

也就是说，如果给出两个序列：

1 2 3 4 5
1 7 4 3 5

那么答案就是1 4 5

我不知道如何解决这个问题。

语境

有一个邮件管理器。

每封邮件都包含一个时间戳、一个发件人和一份收件人列表。

时间戳指定了新闻稿的发送时间，可以是：

• 一次性(2025/01/15 12:30)
• 定期（每 3 小时）
• 从某个日期开始定期更新（每月 3 日 15:30）

每个用户的收件人总数上限是有限制的（默认为 500）。

创建新邮件时，如果其创建日期在已创建日期的 24 小时内，则此新邮件的收件人数量将从用户的收件人限制中减去。也就是说，限制与日期以及在该日期创建邮件的用户相关。

24小时内最多可以发送用户收件人的数量限制。

问题

由于创建邮件时没有设置时间限制，用户可以一次创建多封邮件，这些邮件会在24小时内生效，突破了用户数量的限制。

例子：

假设我们同时安排了 2 封定期邮件。

然后在惰性计算期间第一次将限制考虑在内。如果我们将第二次邮寄的日期推迟 2 个月，由于我们一直在偷懒计算新日期并且它不断更新，因此限制仍然会被正确计算。

通过重新排列实数方阵的元素，确保其最大元素位于右上角，次大元素位于位置 (2,j-1)，等等，从而填充整个次对角线。

请用简单的语言解释，并举例说明和逐步的解决方案。我不需要代码，我需要解释。

我正在研究如何最好地在数据库中存储密码这个课题。我发现所有现代网站都将密码哈希存储在数据库中，然后通过相同的哈希函数传递用户输入的文本并比较哈希值。但在所有授权示例中，仅对密码进行了散列。电子邮件或登录信息以明文形式存储。如果您对登录名和电子邮件进行哈希处理，并在检查时将它们传递给哈希函数，就像密码一样，会发生什么？然后攻击者将只能访问哈希，但不能访问可以在其他网站上使用的电话号码或电子邮件。他们为什么不这么做呢？数据库是否会占用更多空间？或者是因为哈希函数很慢所以它们不这样做？这种方法有什么缺点？

SO上也有这样的问题，但争议一直拖在那里。有没有一种快速方法可以找到给定素数之后的下一个素数来扩展哈希表？

示例（根据@MBo的推荐更新代码）

size_t get_next_prime_number(size_t current_prime_number)
{
size_t saved = current_prime_number;
bool is_prime = true;

if (current_prime_number >= MIN_PRIME_NUMBER)
    for(current_prime_number = current_prime_number + 2; current_prime_number < SIZE_MAX; current_prime_number += 2)    
        {
            // previous: for(size_t j = 2; j < current_prime_number; ++j)
            for(size_t j = 3; j*j <= current_prime_number; j +=2)
                if (current_prime_number % j == 0)
                {
                    is_prime = false;
                    
                    break;  
                }
                else
                    is_prime = true;

            if (is_prime)
                break;      
        }

 return (current_prime_number == saved) ? 0 : current_prime_number;
 }

更新

我尝试使用分成简单的建议，但没有成功Floating point exception。

#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#define MIN_PRIME_NUMBER 2 // > 1
#define DIVIDER_LIMIT 65535 // sqrt(4294967295)
#define INDEX_DIFFERENCE 10 // > 1

void resize_array_up(size_t * stored_primes, const size_t prime_position)
{   
if (prime_position % INDEX_DIFFERENCE == INDEX_DIFFERENCE - 1)          
    if (!realloc(stored_primes, (prime_position + INDEX_DIFFERENCE + 1) * sizeof(size_t)))
        exit(EXIT_FAILURE);
        
stored_primes = memset(stored_primes, 0, sizeof(size_t));
}

size_t get_next_prime_number(const size_t current_prime_number, const size_t prime_position, size_t * stored_primes)
{   
resize_array_up(stored_primes, prime_position); 

size_t saved_current = current_prime_number,
       prime_number = 1;    

if ((current_prime_number >= MIN_PRIME_NUMBER) && (prime_position < SIZE_MAX) && (current_prime_number < SIZE_MAX))
{
    for(size_t divider = sqrt(current_prime_number), number = divider * divider, temporary_number = current_prime_number + 2; 
            (divider < DIVIDER_LIMIT) && (number <= temporary_number); divider += 2, number = divider * divider, temporary_number += 2)
        for(size_t counter = 0; counter <= prime_position; ++counter)
        {
            if ((number % stored_primes[counter]) == 0)
                break;              
            else                       
                prime_number = number;                
        }   
}

return (prime_number == saved_current) ? 0 : prime_number;
}

int main(void)
{   
size_t * primes = calloc(INDEX_DIFFERENCE, sizeof(size_t));

if (primes)
{
    size_t prime_position = 0, 
           prime_number = MIN_PRIME_NUMBER;
    primes[prime_position] = prime_number;  

    do
    {
        prime_number = get_next_prime_number(prime_number, prime_position++, primes);
    
        printf("%zu\n\n", prime_number);
    }
    while (prime_number != 0);

    if (prime_number == 0)
        free(primes);
}
else
    exit(EXIT_FAILURE);
    
return EXIT_SUCCESS;
}