全部问题

我有一个界面IMatrix：

public interface IMatrix {

    int[][] data = null;
    public int rows = 0;
    public int cols = 0;
        
    int getElement(int row, int column);
    void setElement(int row, int column, int value);
        
    IMatrix sum(IMatrix m1, IMatrix m2);
    IMatrix product(IMatrix other);
        
    boolean equals(IMatrix other);
    String toString();
        
}

例如，下面是一个sum()我想在每个类中以不同方式实现的方法，但是当访问 fields 时rows，colsEclipse 会抛出警告：

静态字段 IMatrix.cols 应该以静态方式访问

我不太明白如何在实现接口的类中正确实现方法。

以下是我尝试在类中实现此方法的UsualMatrix方法IMatrix：

@Override
public IMatrix sum(IMatrix m1, IMatrix m2) {
            
    if ((m1.rows != m2.rows) || (m1.cols != m2.cols)) {
        throw new MatrixOperationException("Matrices must be the same size to be added together.");
    }
            
    UsualMatrix mtxFinal = new UsualMatrix(rows, cols);
            
    for (int i = 0; i < this.rows; i++) {
        for (int j = 0; j < this.cols; j++) {
            mtxFinal.data[i][j] = m1.data[i][j] + m2.data[i][j];
        }
    }
            
    return mtxFinal;
}

我正在 aiogram 3 上制作一个电报机器人。注册用户后，我需要在 3 天后延迟向用户发送消息。在测试期间，我将时间增量设置为 10 秒，然后在生产中一切正常；当我将时间增量设置为 3 天时，调度程序根本不工作，并且任务从 redis 作业存储中完全删除。应该执行该函数的时间。

初始化调度程序：

# Внешние библиотеки
from apscheduler.jobstores.redis import RedisJobStore
from apscheduler.schedulers.asyncio import AsyncIOScheduler

# Инициализация редис, куда будет сохраняться рассылки
jobstores = {"default": RedisJobStore(host="localhost", port=6379, db=3)}

调度器模块：

# Стандартные библиотеки
import asyncio
from datetime import datetime
import json

# Внешние библиотеки
from aiogram.fsm.storage.base import StorageKey
from aiogram import F, Router
from aiogram.fsm.context import FSMContext
from aiogram.types import FSInputFile

router = Router() 
message_queue = asyncio.Queue()

# Функция-работник для отправки сообщений из очереди
async def message_sender_worker(redis_middleware):
    while True:
        user_id = await message_queue.get()
        try:
            # Создаем ключ и контекст состояния для пользователя
            key = StorageKey(bot_id=bot.id, chat_id=user_id, user_id=user_id)
            state = FSMContext(storage=dp.storage, key=key)

            # Получаем язык пользователя из Redis
            user_lang = await redis_middleware.get(f"user_lang:{user_id}")
            user_lang = user_lang if user_lang else "ru"  # По умолчанию русский
            
            # Отправляем сообщение, передавая актуальный язык пользователя
            await send_scheduled_message(user_id, state=state, user_lang=user_lang)
        except Exception as e:
            logger.error(f"Ошибка при отправке сообщения пользователю {user_id}: {e}")
        finally:
            message_queue.task_done()
        
        # Задержка для соблюдения лимитов Telegram
        await asyncio.sleep(0.05)


# Функция для отправки запланированного сообщения пользователю
async def send_scheduled_message(user_id, state: FSMContext, user_lang):
    print("Функция отправки через 3 дня запущена")

    # Получаем данные пользователя из базы данных
    role = await db.get_role_user(user_id)
    role = role[0]

    country = await db.get_country_user(user_id)
    country = country[0]

    await state.update_data(country_delay = country)
    await state.update_data(role_delay = role)

    if not role and country:
            logger.warning(f"Не найдены данные для пользователя {user_id}")
            return

    # Отправляем первоначальное сообщение
    await bot.send_message(chat_id=user_id, text=post_msg.after_3_days[user_lang])
    logger.info(f"Отправлено сообщение через 3 дня - {user_id}")
    await asyncio.sleep(2)

    # Обрабатываем страну, если нужно
    country_processed = await wrap_half_words_in_percent(country)
    if role in ["Роль1", "Роль2", "Роль3", "Роль4",]:
        await asyncio.sleep(1)
        await bot.send_message(
            chat_id=user_id,
            text=post_msg.get_photo_form["region"][user_lang],
            reply_markup = await reply_regions(country_processed)
        )
        await asyncio.sleep(3)
        # Устанавливаем состояние пользователя
        # state = FSMContext(storage=dp.storage, user=user_id, chat=user_id)
        await state.set_state(GetPhotoRegion.polling_station)
    else:
        await asyncio.sleep(1)
        # doc_path = "send_docs/Права избирателя.docx"
        doc_path = service_msg.agitator_patch_doc[user_lang]
        doc_file = FSInputFile(path=doc_path)
        await bot.send_document(chat_id=user_id, document=doc_file)
        await asyncio.sleep(1)
        await bot.send_message(chat_id=user_id, text=post_msg.agitator_form["send_link"][user_lang])
        
        # Устанавливаем состояние пользователя
        # state = FSMContext(storage=dp.storage, user=user_id, chat=user_id)
        await state.set_state(AgitatorForm.waiting_for_links)
        await asyncio.sleep(2)


# Функция для планирования добавления пользователя в очередь сообщений
def schedule_message(user_id, send_time):
    scheduler.add_job(
        add_user_to_queue,
        'date',
        run_date=send_time,
        args=[user_id]
    )

# Функция для добавления пользователя в очередь сообщений
async def add_user_to_queue(user_id):
    await message_queue.put(user_id)

一段带有注册的代码。这里我向调度程序添加一个任务：

@router.callback_query(
    UserStates.FINISH_AUTH, F.data.in_(["confirm_yes", "confirm_no"])
)
async def finish_auth(callback_query: CallbackQuery, state: FSMContext, user_lang):
    if callback_query.data == "confirm_yes":
        # Добавляем данные в базу данных
        data = await state.get_data()
        tg_id = str(callback_query.from_user.id)
        await add_user_db(
            data["name"], data["phone"], tg_id,
            data["email"], data["country"], data["locality"], data["role"]
        )

        # Планируем отправку сообщения через 3 дня
        send_time = datetime.now() + timedelta(days=3)
        #send_time = datetime.now() + timedelta(seconds=10)
        schedule_message(tg_id, send_time)
        logger.info("Запланировано отправление сообщения через 3 дня")

        # Отправляем подтверждение пользователю
        await callback_query.message.answer(
            reg_msg.finish_msg[user_lang], reply_markup=await keyboard.start_quiz(user_lang)
        )
        logger.info(f"Пользователь с TG_ID - {tg_id} зарегистрировался")
        await state.clear()
    else:
        await callback_query.message.answer(reg_msg.name[user_lang])
        await state.set_state(UserStates.WAITING_FOR_NAME)
    await callback_query.answer()

关于此任务已经提出了有关优化的问题，但是仍然可以通过使用这部分代码来优化代码而不连接任何库吗？

while j + c - 1 < len(mass):
    if mass[j + c - 1] - mass[j] <= m:
        k += 1
        j = j + c
    else:
        j = j + 1

问题编号 1620。苏博尼克

班上还有人在学习N。班主任接到指示，各派一R组С人去清理。所有参与清理工作的团队都将从事搬运原木的工作。每根原木均由一个团队的所有成员同时搬运。在这种情况下，该大队成员的身高差异越小，携带原木就越方便。

团队的不便数将是该团队中最高和最矮成员的身高差（如果团队中只有一个人，则该差值等于0）。班主任决定组队，尽量将组队带来的不便降到最低。帮帮他吧！

考虑以下示例：

设班上有身高厘米为、、、、、、、、、的人，8需170分成两队，每队三人。205225190260130225160

那么一种选择是这样的：

第一大队：身高225、205、225的人

第二大队：身高160、190、170的人

在这种情况下，第一队的不便次数将等于20，第二队的不便次数将等于30。不便数的最大值将为30，这将是最好的结果。

输入格式

首先输入自然数N，R以及C- 班级人数、小组人数和每队人数（1 ≤ R∙C ≤ N ≤ 100 000）。接下来，N输入整数 - 每个N学生的身高。学生的身高是一个不超过的自然数1 000 000 000。

输出格式

打印一个数字 - 所组成的团队的最大不便次数的最小可能值。

n, r, c = map(int, str(input()).split())
mass = []
for i in range(n):
    mass.append(int(input()))
mass = sorted(mass)
right = mass[len(mass) - 1] - mass[0]
left = 0
while left < right:
    m = (left + right) // 2
    j = 0
    k = 0
    while j + c - 1 < len(mass):
        if mass[j + c - 1] - mass[j] <= m:
            k += 1
            j = j + c
        else:
            j = j + 1
    if k >= r:
        right = m

    else:
        left = m + 1

print(right)

需要将两个不同宽度的Text()放在一个Row()中。左侧文本可以根据需要设置宽度，而不会干扰右侧文本。右侧文本占据整个剩余宽度，也不会干扰左侧文本。

我遇到了一个问题，如果左边的文本变长，那么它就会开始挤压右边的文本。

我的意思是这个案例：

val textLeft = "some text text text text text text text text text"
val textRight = "some text text"

我自己想要达到以下效果：



1.通常的状态是两个文本的尺寸都很小并且彼此不冲突。左边的文本正好占据了它需要的空间。正确的文本占据了所有剩余空间。

val textLeft = "some text"
val textRight = "some text text"

2.当左边的文本宽度变得很大，到达右边的文本时，左边的文本就会进入省略号，并将其压到容器的右边缘，而不强制右边的文本进入省略号。



val textLeft = "some text text text text text text text text text"
val textRight = "some text text"   

3.右侧文本太大，以至于到达左侧文本的边缘并消失为省略号。

val textLeft = "some text"
val textRight = "some text text text text text text text text text text"

4.两个文本都很大，大约在中间相遇，并且都变成了省略号。

val textLeft = "some text text text text text"
val textRight = "some text text text text text"

这是我尝试实现我需要的情况的代码本身：

@Composable
fun TwoTextsRow(textLeft: String, textRight: String) {
    Box(
        modifier = Modifier.height(40.dp),
        contentAlignment = Alignment.Center
    ) {
        Row(
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.SpaceBetween,
        ) {
            Box(
                contentAlignment = Alignment.Center,
                modifier = Modifier
                    .fillMaxHeight()
                    .background(Color.Gray)
            ) {
                Text(
                    modifier = Modifier
                        .wrapContentWidth()
                        .padding(horizontal = 4.dp),
                    textAlign = TextAlign.Center,
                    maxLines = 1,
                    text = textLeft,
                    color = Color.White
                )
            }
            Divider(
                color = Color.Red,
                modifier = Modifier
                    .fillMaxHeight()
                    .width(1.dp)
            )
            Text(
                modifier = Modifier
                    .padding(horizontal = 4.dp)
                    .fillMaxWidth(),
                maxLines = 1,
                overflow = TextOverflow.Ellipsis,
                textAlign = TextAlign.Center,
                text = textRight,
                color = Color.White
            )
        }
    }
}

请告诉我需要朝哪个方向来实现这一点，或者需要在我的代码中纠正哪些内容，以便实现我列出的结果。

合并两个数据框时，会出现额外的行。我将用一个例子来解释：数据帧1（50行），我通过4个键将数据帧2（1600万行）的列附加到它，最终的数据帧是51行。此外，这是额外的一行 - 它重复其中一行，即，事实上，行数由于行 - 重复而增加。可能是什么原因？当然，您可以稍后删除重复项，但我希望它们一开始就不会形成。 （至于数据类型 - 一切都很好，我检查过）

Вот примеры кода (2 варианта):

df_merged1 = pd.merge(
    res_test1, df3_,
    left_on=['uuid',  'id_route', 'vehicle_type', 'time' ],
    right_on=['uuid',  'id_route', 'vehicle_type', 'time' ]
)

df_merged2 = res_test1.merge(df3_, on=['uuid',  'id_route', 'vehicle_type', 'time' ])