有一个邮件管理器。
每封邮件都包含一个时间戳、一个发件人和一份收件人列表。
时间戳指定了新闻稿的发送时间，可以是：
每个用户的收件人总数上限是有限制的（默认为 500）。
创建新邮件时，如果其创建日期在已创建日期的 24 小时内，则此新邮件的收件人数量将从用户的收件人限制中减去。也就是说，限制与日期以及在该日期创建邮件的用户相关。
24小时内最多可以发送用户收件人的数量限制。
由于创建邮件时没有设置时间限制，用户可以一次创建多封邮件，这些邮件会在24小时内生效，突破了用户数量的限制。
假设我们同时安排了 2 封定期邮件。
然后在惰性计算期间第一次将限制考虑在内。如果我们将第二次邮寄的日期推迟 2 个月，由于我们一直在偷懒计算新日期并且它不断更新，因此限制仍然会被正确计算。
我正在研究如何最好地在数据库中存储密码这个课题。我发现所有现代网站都将密码哈希存储在数据库中，然后通过相同的哈希函数传递用户输入的文本并比较哈希值。但在所有授权示例中，仅对密码进行了散列。电子邮件或登录信息以明文形式存储。如果您对登录名和电子邮件进行哈希处理，并在检查时将它们传递给哈希函数，就像密码一样，会发生什么？然后攻击者将只能访问哈希，但不能访问可以在其他网站上使用的电话号码或电子邮件。他们为什么不这么做呢？数据库是否会占用更多空间？或者是因为哈希函数很慢所以它们不这样做？这种方法有什么缺点？
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;
}
是否可以在偶像中返回变量？我们需要确保 check_numbers 函数将值 x 返回给主算法，主算法将该值传递给另一个函数。
алг Факториал положительных чисел
нач
цел n1,n2,x
вывод "Введите n1 "
ввод n1
вывод "Введите n2 "
ввод n2
check_numbers(n1,n2)
x:= check_numbers(n1,n2)
Fact(n2,x)
кон
алг check_numbers(цел n1,цел n2)
нач
цел x
x:=n1
нц пока x<0
вывод нс, x , " - Не положительное "
x:=x+1
кц
кон
алг Fact (цел x,цел n2)
нач
цел i,F
F:= 1
если x = 0
то вывод "Присутствует 0. Факториал равен 1"
иначе
нц для i от x до n2
F:=F*i
вывод нс,"Факториал равен "
кц
всё
кон
有必要创建一种算法来查找将自然数分解为自然数之和（至少 2）的方法数。
这个算法应该是一个特定的函数，它将一个自然数（2及以上）作为输入，并输出将该数分解为自然数之和（至少2）的方法数。
例如，对于数字 6，有 4 种方法：
6 = 6 = 2 + 4 = 3 + 3 = 2 + 2 + 2
我不需要束缚于特定的编程语言，重要的只是算法。
求和分解可以用图来表示，例如：
图上有 6 个顶点，每个顶点可以连接另外 2 个顶点（但至少 1 个），但不能关闭链：
因此，该函数将采用以下值：
f(1) = 0,
f(2) = 1,
f(3) = 1,
f(4) = 2,
f(5) = 2,
f(6) = 4,
f(7) = 4,
f(8) = 7,
f(9) = 8,
f(10) = 12,
<...>。
我也有兴趣了解序列的极限或函数相邻值之间关系序列的极限。
目前我知道如何计算连接所有顶点的方法数量，连接顶点以使图分为两部分，以及连接顶点以使图分为3部分。