Посещаемость интернет-сайтов ведущих СМИ резко падает

Данные по сей день там. 1 января там просто точка на графике.

Данные semrush. Есть еще similarweb, но картина похожая.

Павел ответил за меня, подтверждаю его данные полностью. Смотри внимательно на график и поймешь где там 24 го а где 25)) вот. 

Не знаю куда именно запостить, пущай сюда. ну таки да, если сайт чисто текстовый информационник то ему наверное кранты в новых условиях.

Вот гугол бесплатный и без впн-ов уже даже очень неплох, в отличии от яндекса... ну яндекс такой яндекс... Но один пробел и гугол тоже того...

TankIsT-39, да у Яндекса псевдоИИ явно барахло. Я писал уже, что он не отвечает, а просто ищет по сайтам и выдаёт их текст дословно кусками... С такими ИИ ответами все начнут перебираться в гугл. И я даже представляю, какой будет следующий шах Яндекса: они зашлют людей в Думу и правительство, чтобы забанили Гугл, как враждебную структуру и всё такое =))) А там уж придумают, за что их заблокировать =))

В точку) У Яндекса ничего нет нормального. Сплошная халтура. 

не согласен, спросил тоже самое у Алисы, она без проблем поняла вопрос, ответила правда что 3200 чайников, что соответствует 6,4 МВт и в 1000 раз меньше правильного ответа, но она поняла вопрос и расчет сделала, только не правильно перевела мега в кило

Учитывая, что Алиса задолго появилась до того же чатжпт, то яндекс тоже кое что может. И уж алису халтурой я точно не назвал бы.

Данный вопрос лучше задавать не в поиске, а в чате или напрямую колонке, в поиске написано, что результат на основе источников, если в источниках нет ответа, то результат будет нулевым, а вот чат с алисой или колонка могут сами генерировать результат.

Назвал бы халтурой не чатжпт или Алису, а информационники из которых эти ИИ берут информацию
Ну второе, пробел не у ИИ, а у вас - учитесь составлять промты

Просто Яндекс поисковик, поэтому именно такое решение мне кажется более честным с его стороны, чем решение гугла, яндекс ищет по источникам и с помощью ии генерирует быстрый ответ, а гугл генерирует напрямую, функции поска тут уже нет. 

Важно не то, сколько лет Алисе в сравнении с GPT-чатом, а то, что она умеет на сегодня, и соответствует ли реалиям 2025-2026. 

К сожалению (или нет), Алиса, Маруся, Гигачаты и прочие - не конкуренты гигантам буржа.

Вы утверждали, что  сплошная халтура. Но нет, та же алиса не халтура и не плохо справляется со своими задачами, так что утверждение ваше сомнительно.

Что бы сравнить возможности Алисы и того же чатжпт в честных условиях, нужно обучить  и запустить модели на сопоставимом оборудовании, думаю нашим разработчикам это не доступно. Но даже на том что есть, получилось вполне не плохо.

Вот Алиса тетрис накодила, вполне рабочий для первой версии уже не плохо, только скорость слишком высокая

import pygame
import random

# Инициализация pygame
pygame.init()

# Константы
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
GRID_SIZE = 30
GRID_WIDTH = 10
GRID_HEIGHT = 20
FPS = 60

# Цвета
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
CYAN = (0, 255, 255)
MAGENTA = (255, 0, 255)
YELLOW = (255, 255, 0)
ORANGE = (255, 165, 0)

COLORS = [RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW, ORANGE]

# Фигуры (в виде матриц 4x4)
SHAPES = [
    [[1, 1, 1, 1]],  # I
    [[1, 1], [1, 1]],  # O
    [[1, 1, 1], [0, 1, 0]],  # T
    [[1, 1, 1], [1, 0, 0]],  # L
    [[1, 1, 1], [0, 0, 1]],  # J
    [[0, 1, 1], [1, 1, 0]],  # S
    [[1, 1, 0], [0, 1, 1]]   # Z
]

class Tetromino:
    def __init__(self, x, y, shape_idx):
        self.x = x
        self.y = y
        self.shape = SHAPES[shape_idx]
        self.color = COLORS[shape_idx]
        self.rotation = 0

    def rotate(self):
        # Поворот матрицы на 90 градусов
        rows = len(self.shape)
        cols = len(self.shape[0])
        rotated = [[0] * rows for _ in range(cols)]
        for r in range(rows):
            for c in range(cols):
                rotated[c][rows - 1 - r] = self.shape[r][c]
        return rotated

    def get_rotated_shape(self):
        if self.rotation == 0:
            return self.shape
        elif self.rotation == 1:
            return self.rotate()
        elif self.rotation == 2:
            return self.rotate().rotate()
        else:
            return self.rotate().rotate().rotate()

class Game:
    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption("Tetris")
        self.clock = pygame.time.Clock()
        self.grid = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
        self.current_piece = self.new_piece()
        self.game_over = False
        self.score = 0
        self.font = pygame.font.SysFont(None, 36)

    def new_piece(self):
        shape_idx = random.randint(0, len(SHAPES) - 1)
        return Tetromino(GRID_WIDTH // 2 - 2, 0, shape_idx)

    def valid_position(self, piece, dx=0, dy=0, rotated=False):
        shape = piece.get_rotated_shape() if rotated else piece.shape
        for y, row in enumerate(shape):
            for x, cell in enumerate(row):
                if cell:
                    new_x = piece.x + x + dx
                    new_y = piece.y + y + dy
                    if (new_x < 0 or new_x >= GRID_WIDTH or
                        new_y >= GRID_HEIGHT or
                        (new_y >= 0 and self.grid[new_y][new_x])):
                        return False
        return True

    def merge_piece(self):
        shape = self.current_piece.get_rotated_shape()
        for y, row in enumerate(shape):
            for x, cell in enumerate(row):
                if cell and self.current_piece.y + y >= 0:
                    self.grid[self.current_piece.y + y][self.current_piece.x + x] = self.current_piece.color

    def clear_lines(self):
        lines_cleared = 0
        for y in range(GRID_HEIGHT):
            if all(self.grid[y]):
                del self.grid[y]
                self.grid.insert(0, [0 for _ in range(GRID_WIDTH)])
                lines_cleared += 1
        self.score += lines_cleared * 100

    def update(self):
        if not self.game_over:
            if self.valid_position(self.current_piece, 0, 1):
                self.current_piece.y += 1
            else:
                self.merge_piece()
                self.clear_lines()
                self.current_piece = self.new_piece()
                if not self.valid_position(self.current_piece):
                    self.game_over = True

    def handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT and self.valid_position(self.current_piece, -1, 0):
                    self.current_piece.x -= 1
                elif event.key == pygame.K_RIGHT and self.valid_position(self.current_piece, 1, 0):
                    self.current_piece.x += 1
                elif event.key == pygame.K_DOWN and self.valid_position(self.current_piece, 0, 1):
                    self.current_piece.y += 1
                elif event.key == pygame.K_UP:
                    rotated_shape = self.current_piece.rotate()
                    if self.valid_position(self.current_piece, 0, 0, True):
                        self.current_piece.shape = rotated_shape
                        self.current_piece.rotation = (self.current_piece.rotation + 1) % 4
        return True

    def draw_grid(self):
        for y in range(GRID_HEIGHT):
            for x in range(GRID_WIDTH):
                pygame.draw.rect(self.screen, self.grid[y][x] or BLACK,
                                 (x * GRID_SIZE, y * GRID_SIZE, GRID_SIZE, GRID_SIZE), 0)
                pygame.draw.rect(self.screen, WHITE,
                                 (x * GRID_SIZE, y * GRID_SIZE, GRID_SIZE, GRID_SIZE), 1)

    def draw_piece(self):
        shape = self.current_piece.get_rotated_shape()
        for y, row in enumerate(shape):
            for x, cell in enumerate(row):
                if cell:
                    pygame.draw.rect(self.screen, self.current_piece.color,
                                     ((self.current_piece.x + x) * GRID_SIZE,
                                      (self.current_piece.y + y) * GRID_SIZE,
                                      GRID_SIZE, GRID_SIZE), 0)
                    pygame.draw.rect(self.screen, WHITE,
                                     ((self.current_piece.x + x) * GRID_SIZE,
                                      (self.current_piece.y + y) * GRID_SIZE,
                                      GRID_SIZE, GRID_SIZE), 1)

    def draw_text(self):
        score_text = self.font.render(f"Счёт: {self.score}", True, WHITE)
        self.screen.blit(score_text, (GRID_WIDTH * GRID_SIZE + 20, 20))

        if self.game_over:
            game_over_text = self.font.render("GAME OVER", True, RED)
            text_rect = game_over_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))
            self.screen.blit(game_over_text, text_rect)

    def run(self):
        running = True
        while running:
            self.screen.fill(BLACK)

            running = self.handle_input()

            self.update()

            self.draw_grid()
            self.draw_piece()
            self.draw_text()

            pygame.display.flip()
            self.clock.tick(FPS)

        pygame.quit()

# Запуск игры
if __name__ == "__main__":
    game = Game()
    game.run()