全部问题

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;
}

我比较两个列表：

app_list = ['word', 'port']
    
new_list = ['word list', 'port world']
    
if any(x in app_list for x in new_list):
    print("Списки list1 и list2 имеют общие элементы")
else:
    print("Списки list1 и list2 не имеют общих элементов")

结果：

列表list1和list2没有共同元素

我正在第二个列表“单词列表”的元素中寻找“单词”：

app_list = ['*word*', 'port']
    
new_list = ['word list', 'port world']
    
if any(x in app_list for x in new_list):
    print("Списки list1 и list2 имеют общие элементы")
else:
    print("Списки list1 и list2 не имеют общих элементов")

结果是完全相同的：

列表list1和list2没有共同元素

我认为“*”可以是任意数量的任意字符。

我想在 keras 中编写一个神经网络，绘制图像的底部，知道顶部。数据集 - mnist 数字，28x28，黑白。我知道这对于神经网络来说是一项艰巨的任务，无论如何错误都会相当高，但我不需要一切都完美，最主要的是不模糊，这就是我最终得到的结果。这是训练代码：

import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, Flatten, Reshape
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from glob import glob
from PIL import Image
import keras
import numpy as np

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = np.concatenate([x_train, x_test])
y_train = np.concatenate([y_train, y_test])
x_train = x_train[y_train == 1]

# Размеры изображения
img_width, img_height = 28, 28
input_img = Input(shape=(img_width//2, img_height, 1))  

# Энкодер
x = Conv2D(64, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
encoded = Flatten()(x)

# Декодер
x = Reshape(target_shape=(7, 14, 8*8))(encoded)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)  
# Создание модели
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy')

x_train = x_train.astype('float32') / 255.0;

x_train = np.reshape(x_train, (x_train.shape[0], 28, 28, 1))

autoencoder.fit(x_train[:, :14], x_train[:, 14:], epochs=10, batch_size=128, shuffle=True)
autoencoder.save("model.h5")

我仅在单位上训练模型，以免混淆，因为 1 是最简单的数字。但即便如此，结果也不是很令人印象深刻：

如果是其他数字，结果通常是灾难性的。我将不胜感激任何能够告诉我选择什么架构和超参数，或者可能是其他东西的人......可以人为地增加图像下部的亮度，因为它总是变得更暗，但是某种扭曲仍然存在。根据我的尝试 - 学习步骤更小（不起作用），架构更复杂（部分起作用），获取所有数字（结果更糟）。

* {
  position: relative;
  padding: 0;
  margin: 0;
  outline: none;
  letter-spacing: 1px;
  box-sizing: border-box;
  scrollbar-width: none;
  -webkit-tap-highlight-color: transparent
}

main {
  display: flex;
  flex-wrap: wrap;
  gap: 25px;
  padding: 25px;
  height: 1000px;
  width: 500px;
  margin: 0 auto;
}

.blok1 {
  background: green;
  height: 100px;
  flex: 1;
  padding: 50px;
}

.blok2 {
  background: #ff0000;
  padding: 50px;
}

<main>
  <div class='blok1'></div>
  <div class='blok1'></div>
  <div class='blok2'></div>
</main>

如何放置 2 个绿色块，一个在另一个下面。须符合以下条件

1. 父级必须具有 display:flex
2. 嵌套结构应保持不变。也就是说，无需将其包裹在额外的层中。有一个父块和 3 个子块。
3. 绿色块的高度可能会有所不同。即内容的高度与红色相同。绿色边可能是 100 像素高，红色边是 1000 像素高

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}
main {
  --gap: 25px;
  --height: 100vh;  
  display: flex;
  gap: var(--gap);
  flex-wrap: wrap;
  flex-direction: column;
  height: var(--height);
  padding: var(--gap);
  align-content: center;
}
.block1,
.block2 {
    width: 70%;
    max-width: min(calc(50vh*(16 / 9)), 70%);
    background: #cfc;
}
.block3 {
  flex: 0 0 100%;
  width: calc(30% - var(--gap));
  background: #fcc
}
.block3, .block1, .block2 {padding: 0.5em;}

<main>
  <div class="block1">
    <h2>block1</h2>
     Text Text Text Text Text Text 
  </div>
  <div class="block2">
    <h2>block2</h2>
    Text Text Text Text Text Text Textext Text Text Text Text Text Textext Text Text Text Text  
  </div>
  <div class="block3">
     Text Text Text Text Text Text Text 
  </div>
</main>

部分实现。仅当总高度超过红色时。他们跳过去，站成一排……

网格示例

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}
main {
    display: grid;
    gap: 10px;
    grid-template:
        "a c" auto
        "b c" auto / min(calc(50vh*(16 / 9)), 70%) 30%;
    padding: 10px;
    width: 100%;
    max-width: 800px;
    margin: 0 auto;
    justify-content: center;
}
.block1 {grid-area: a}
.block2 {grid-area: b}
.block1, .block2 {background: #cfc}
.block3 {
  grid-area: c;
  grid-row: 1 / 3;
  background: #fcc
}
main > div {padding: 0.5em;}

<main>
  <div class="block1">
    Text Text Text Text Text Text 
  </div>
  <div class="block2">
    Text Text Text Text Text Text Text 
  </div>
  <div class="block3">
   Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text 
   Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text 
   Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text 
   Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text Text 
  </div>
</main>

这似乎有效，但是...怎么做呢。使绿色的高度与内容一致，而不是拉伸...如果你尝试按下它，间隙就会被打破。

它似乎保留了网格，位置是正确的，但它没有按下绿色块......

对于本程序，实现按照选项（见表）将查询结果输出到文件中。

选项：显示商店中可用产品的所有信息（由用户输入）[已取消]总之，我把表中的选项搞乱了，我只需要将它输出到文件中即可。

代码：

Program
static void Main(string[] args)
{
    Storage stock = new Storage(3);
    stock[0] = new Tovar("01", "Товар1", "Магазин5", 4300);
    stock[1] = new Tovar("02", "Товар2", "Магазин7", 5340);
    stock[2] = new Tovar("03", "Товар3", "Магазин3", 3040);

    bool auditor = true;
    while (auditor)
    {

        Console.WriteLine("\nВведите тип операции");
        Console.WriteLine("1) Найти товар по ID");
        Console.WriteLine("2) Найти товар по названию");
        Console.WriteLine("3) Отсортировать массив товаров по цене");
        Console.WriteLine("4) Отсортировать массив товаров по названию");
        Console.WriteLine("5) Отсортировать массив товаров по магазину");
        Console.WriteLine("6) Закончить");

        string number = Console.ReadLine();
        Console.WriteLine();

        switch (number)
        {
            case "1":
                string search_ID = Console.ReadLine();
                Tovar  item0 = stock.FindProductID(search_ID);
                if (item0 != null)
                    Console.WriteLine(item0.ToString());
                break;
            case "2":
                string search_name = Console.ReadLine();
                Tovar item1 = stock.FindProductName(search_name);
                if (item1 != null)
                    Console.WriteLine(item1.ToString());
                else Console.WriteLine("Нет такого");
                break;
            case "3":
                Tovar[] tests = stock.SortByCost();
                for (int i = 0; i < tests.Length; i++)
                {
                    Console.WriteLine(tests[i].ToString());
                }
                break;
            case "4":
                Tovar[] tests1 = stock.SortByName();
                for (int i = 0; i < tests1.Length; i++)
                {
                    Console.WriteLine(tests1[i].ToString());
                }
                break;
            case "5":
                Tovar[] tests2 = stock.SortByShop();
                for (int i = 0; i < tests2.Length; i++)
                {
                    Console.WriteLine(tests2[i].ToString());
                }
                break;
            case "6":
                auditor = false;        
                break;
        }
    }
    Console.WriteLine();
    
    Console.WriteLine("Сумма товаров:");
    Console.WriteLine(stock[0] + stock[1]);
    Console.ReadKey();
}

internal class Tovar
{
    public string ID { get; private set; } //что бы явно не обявлять резервную переменную
    public string Name { get; private set; }
    public string Shop { get; private set; }
    public double Cost { get; private set; }
    public Tovar(string id, string name, string shop, double cost)
    {
        ID = id;
        Name = name;
        Shop = shop;
        Cost = cost;
    }
    public override string ToString()
    {
        return $"ID: {ID}, название: {Name}, магазин: {Shop}, цена: {Cost}";
    }
    public static double operator +(Tovar obj1, Tovar obj2)
    {
        return obj1.Cost + obj2.Cost;
    }
}

internal class Storage
{
    Tovar[] products;
    public int Length { get; private set; }
    public Storage(int length)
    {
        Length = length;
        products = new Tovar[Length];
    }

    public Tovar this[int index]
    {
        get
        {
            if (IsValid(index))
                return products[index];
            throw new IndexOutOfRangeException();
        }
        set
        {
            if (IsValid(index))
                products[index] = value;
            else
                throw new IndexOutOfRangeException();
        }
    }

    public Tovar FindProductID(string id)
    {
        foreach (Tovar item0 in products)
        {
            if (item0.ID == id)
                return item0;
        }
        return null;
    }

    public Tovar FindProductName(string name)
    {
        foreach (Tovar item1 in products)
        {
            if (item1.Name == name)
                return item1;
        }
        return null;
    }
    public Tovar[] SortByName()
    {
        return products.OrderBy(n => n.Name).ToArray();
    }
    public Tovar[] SortByShop()
    {
        return products.OrderBy(n => n.Shop).ToArray();
    }
    public Tovar[] SortByCost()
    {
        return products.OrderBy(n => n.Cost).ToArray();
    }
    private bool IsValid(int index)
    {
        return (index >= 0) && (index < Length);
    }
}

问题：代码中需要添加什么才能将所有信息输出到文件中？