Taulan Khatuaev

import time
from telebot import types

current_step = None

def family_buttons(message):
    global current_step

    email(message)
    current_step = 'email'

def email(message):
    markup = types.InlineKeyboardMarkup(row_width=1)
    email_button = types.InlineKeyboardButton('Введите почту', callback_data='email')
    markup.add(email_button)
    bot.send_message(message.chat.id, 'Время заполнения поля 30 секунд', reply_markup=markup)

def phone_code(message):
    markup = types.InlineKeyboardMarkup(row_width=1)
    phone_code_button = types.InlineKeyboardButton('Введите код телефона', callback_data='phone_code')
    markup.add(phone_code_button)
    bot.send_message(message.chat.id, 'Нажмите для заполнения поля!', reply_markup=markup)

@bot.callback_query_handler(func=lambda call: True)
def callback(call):
    global current_step

    if call.message:
        if call.data == 'email':
            text_email = bot.send_message(chat_id=call.message.chat.id, text='Введите почту')
            bot.register_next_step_handler(text_email, next)

        elif call.data == 'phone_code':
            text_phone_code = bot.send_message(chat_id=call.message.chat.id, text='Введите код телефона')
            bot.register_next_step_handler(text_phone_code, next)

def next(message):
    global current_step

    if current_step == 'email':
        # Обработка введенной почты
        current_step = 'phone_code'
        phone_code(message)

    elif current_step == 'phone_code':
        # Обработка введенного кода телефона
        current_step = None
        # Здесь можете выполнить какие-то действия после завершения обоих шагов

import React, { useEffect, useState } from "react";
import { useAppDispatch, useAppSelector } from "../hooks/hooks";
import "./styles/Tester.scss";
import { keyboardHandler, startTyping } from "../store/typer.slice";

const Tester: React.FC = () => {
  const accuracy = useAppSelector((state) => state.typer.accuracy);
  const text = useAppSelector(({ typer: { text } }) => Array.from(text));
  const time = useAppSelector((state) => state.typer.time);
  const words = useAppSelector((s) => s.typer.words);
  const completeWords = useAppSelector((s) => s.typer.completeWords);
  const key = useAppSelector((state) => state.typer.key);
  const characters = useAppSelector((state) => state.typer.countCharacters);
  const inputText = useAppSelector((s) => s.typer.inputText);
  const dispatch = useAppDispatch();

  const [printedText, setPrintedText] = useState(""); // Новое состояние для хранения текста с обернутыми символами

  useEffect(() => {
    const keyHandler = (event: KeyboardEvent) => {
      dispatch(keyboardHandler(event.key));
    };
    dispatch(startTyping());
    document.addEventListener("keydown", keyHandler);
    return () => {
      document.removeEventListener("keydown", keyHandler);
    };
  }, []);

  const inputOnChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const value = e.target.value;
    let newPrintedText = "";
    for (let i = 0; i < text.length; i++) {
      if (i < value.length) {
        // Проверка на наличие символа в введенном тексте
        if (text[i] === value[i]) {
          newPrintedText += `<span class="highlight">${text[i]}</span>`; // Обернуть символ в <span> с классом highlight
        } else {
          newPrintedText += text[i]; // Добавить символ без обертки
        }
      } else {
        newPrintedText += text[i]; // Добавить символ без обертки
      }
    }
    setPrintedText(newPrintedText);
  };

  return (
    <div className="testWrapper">
      <div>
        <p
          className="textForTest"
          dangerouslySetInnerHTML={{ __html: printedText }} // Используйте dangerouslySetInnerHTML для отображения HTML-разметки
        />
        <input
          value={inputText}
          onChange={inputOnChange}
          type="text"
          placeholder="text"
        />
        <p>Last character: {key}</p>
        <div className="typeStatistics">
          <span className="statisticsItem">Accuracy: {accuracy}%</span>
          <span className="statisticsItem">
            Characters per minute: {characters}
          </span>
          <span className="statisticsItem">Time: {time} s.</span>
        </div>
      </div>
      <div className="controls">
        <button>Start</button>
        <button>Restart</button>
      </div>
    </div>
  );
};

export default Tester;

.highlight {
  background-color: yellow;
}

#include <vector>

const int voxel_size = 16;

std::vector<short> get_voxels_from_chunk(short (*voxels)[voxel_size][voxel_size][voxel_size], int world_length, int chunk_size_x, int chunk_size_y, int chunk_size_z, int chunk_id) {
    std::vector<short> result;
    int chunk_count_x = world_length / chunk_size_x;
    int chunk_count_y = world_length / chunk_size_y;
    int chunk_count_z = world_length / chunk_size_z;
    int chunk_index_x = chunk_id % chunk_count_x;
    int chunk_index_y = (chunk_id / chunk_count_x) % chunk_count_y;
    int chunk_index_z = chunk_id / (chunk_count_x * chunk_count_y);
    int x_offset = chunk_index_x * chunk_size_x;
    int y_offset = chunk_index_y * chunk_size_y;
    int z_offset = chunk_index_z * chunk_size_z;
    for (int i = x_offset; i < x_offset + chunk_size_x; i++){
        for (int ii = y_offset; ii < y_offset + chunk_size_y; ii++){
            for (int iii = z_offset; iii < z_offset + chunk_size_z; iii++){
                result.push_back(*(*(*(voxels + i) + ii) + iii));
            }
        }
    }
    return result;
}

int main() {
    short voxels[voxel_size][voxel_size][voxel_size]; // пример массива вокселей
    int world_length = voxel_size;
    int chunk_size_x = 4;
    int chunk_size_y = 8;
    int chunk_size_z = 8;
    int chunk_id = 3; // пример id чанка
    std::vector<short> chunk_voxels = get_voxels_from_chunk(&voxels, world_length, chunk_size_x, chunk_size_y, chunk_size_z, chunk_id);
    // обработка chunk_voxels
    return 0;
}

import { Module, OnModuleInit } from '@nestjs/common';
import { KnexModule } from '@nestjsplus/knex';
import { MigrationConfig } from '@nestjsplus/knex/dist/interfaces/migration-config.interface';
import * as path from 'path';

@Module({
  imports: [
    KnexModule.forRootAsync({
      useFactory: (): MigrationConfig => ({
        config: {
          client: 'sqlite3',
          useNullAsDefault: true,
          connection: ':memory:',
        },
        migrations: {
          directory: path.resolve(__dirname, 'migrations'),
        },
      }),
    }),
  ],
})
export class DatabaseModule implements OnModuleInit {
  constructor(private readonly knexService: KnexService) {}

  async onModuleInit() {
    await this.knexService.client.migrate.latest();
  }
}

add_action('wp_head', 'woocommerce_pagination_canonical_tag');

function woocommerce_pagination_canonical_tag() {
    if (is_paged()) {
        $canonical_url = get_pagenum_link(1);
        echo '<link rel="canonical" href="' . $canonical_url . '" />' . "\n";
    }
}

<?php
$post_ids = get_objects_in_term( get_query_var( 'cat' ), 'category' );
if ( ! empty( $post_ids ) && ! is_wp_error( $post_ids ) ) {
  $tags = get_terms( array(
    'taxonomy' => 'post_tag',
    'object_ids' => $post_ids,
    'orderby' => 'count',
    'order' => 'DESC',
    'number' => 10
  ) );
  if ( ! empty( $tags ) && ! is_wp_error( $tags ) ) {
    shuffle($tags);
    ?>
    <ul>
    <?php foreach( $tags as $tag ) { ?>
      <li><a href="<?php echo get_term_link( $tag, 'post_tag' ); ?>"><?php echo $tag->name; ?></a></li>
    <?php } ?>
    </ul>
  <?php } ?>
<?php } ?>