УдалитьЭлементыПоУсловию(МояКоллекция, "Элемент = 0");

УдалитьЭлементыПоУсловию(ЧисловаяКоллекция, "Элемент < 0");

import random

def print_board(board):
    """Функция для отображения текущего состояния поля."""
    print("\nТекущая игровая доска:")
    for row in board:
        print(" ".join(row))
    print()

def get_user_input():
    """Функция для получения и валидации ввода от пользователя."""
    while True:
        try:
            user_input = input("Введите координаты выстрела (строка, колонка, через запятую): ")
            row, col = user_input.split(',')
            row, col = int(row) - 1, int(col) - 1
            if 0 <= row < 3 and 0 <= col < 3:
                return row, col
            else:
                print("Координаты должны быть в пределах 1-3. Попробуйте снова.")
        except ValueError:
            print("Неверный формат ввода. Попробуйте снова.")

def play_game():
    # Создание пустой доски 3x3
    board = [['_' for _ in range(3)] for _ in range(3)]

    # Размещение корабля компьютера
    ship_row = random.randint(0, 2)
    ship_col = random.randint(0, 2)

    # Игрок-человек получает 5 выстрелов
    shots = 5

    print("Добро пожаловать в игру 'Морской бой'!")
    print_board(board)

    while shots > 0:
        row, col = get_user_input()
        
        # Проверка выстрела
        if row == ship_row and col == ship_col:
            print("Попадание! Вы победили!")
            board[row][col] = 'X'
            print_board(board)
            return
        else:
            print("Мимо!")
            board[row][col] = 'o'
            shots -= 1
            print_board(board)

        if shots == 0:
            print("У вас закончились выстрелы. Выиграл компьютер!")
            return

if __name__ == "__main__":
    play_game()

import random

def print_board(board):
    """Функция для отображения текущего состояния поля."""
    print("\nТекущая игровая доска:")
    for row in board:
        print(" ".join(row))
    print()

def get_user_input():
    """Функция для получения и валидации ввода от пользователя."""
    while True:
        try:
            user_input = input("Введите координаты выстрела (строка, колонка, через запятую): ")
            row, col = user_input.split(',')
            row, col = int(row) - 1, int(col) - 1
            if 0 <= row < 3 and 0 <= col < 3:
                return row, col
            else:
                print("Координаты должны быть в пределах 1-3. Попробуйте снова.")
        except ValueError:
            print("Неверный формат ввода. Попробуйте снова.")

def place_ships():
    """Функция для размещения трех кораблей на поле."""
    ships = set()
    while len(ships) < 3:
        row = random.randint(0, 2)
        col = random.randint(0, 2)
        ships.add((row, col))
    return ships

def play_game():
    # Создание пустой доски 3x3
    board = [['_' for _ in range(3)] for _ in range(3)]

    # Размещение кораблей компьютера
    ships = place_ships()

    # Игрок-человек получает 5 выстрелов
    shots = 5
    hits = 0
    
    print("Добро пожаловать в игру 'Морской бой'!")
    print_board(board)

    while shots > 0:
        row, col = get_user_input()
        
        # Проверка выстрела
        if (row, col) in ships:
            print("Попадание!")
            board[row][col] = 'X'
            ships.remove((row, col))
            hits += 1
            if hits == 3:
                print("Вы поразили все корабли! Вы победили!")
                print_board(board)
                return
        else:
            print("Мимо!")
            board[row][col] = 'o'
        
        shots -= 1
        print_board(board)

        if shots == 0:
            print("У вас закончились выстрелы. Выиграл компьютер!")
            return

if __name__ == "__main__":
    play_game()

import random

class Ship:
    """Класс для представления корабля на поле."""
    def __init__(self, location):
        self.location = location
        self.is_sunk = False

class Board:
    """Класс для представления игрового поля."""
    def __init__(self, size):
        self.size = size
        self.shots = []
        self.ships = []

    def place_ships(self, number_of_ships):
        """Размещение кораблей на доске."""
        while len(self.ships) < number_of_ships:
            location = (random.randint(0, self.size - 1), random.randint(0, self.size - 1))
            if location not in [ship.location for ship in self.ships]:
                new_ship = Ship(location)
                self.ships.append(new_ship)

    def print_board(self):
        """Отображение текущего состояния игрового поля."""
        display_board = [['_' for _ in range(self.size)] for _ in range(self.size)]
        for row, col in self.shots:
            if any(ship.location == (row, col) and ship.is_sunk for ship in self.ships):
                display_board[row][col] = 'X'
            else:
                display_board[row][col] = 'o'
        
        print("\nТекущая игровая доска:")
        for row in display_board:
            print(" ".join(row))
        print()

class Game:
    """Основной класс для организации игрового процесса."""
    def __init__(self, board_size=3, number_of_ships=3, shots=5):
        self.board = Board(board_size)
        self.board.place_ships(number_of_ships)
        self.shots = shots
        self.hits = 0

    def get_user_input(self):
        """Получение и валидация ввода от пользователя."""
        while True:
            try:
                user_input = input("Введите координаты выстрела (строка, колонка, через запятую): ")
                row, col = user_input.split(',')
                row, col = int(row) - 1, int(col) - 1
                if 0 <= row < self.board.size and 0 <= col < self.board.size:
                    return row, col
                else:
                    print(f"Координаты должны быть в пределах 1-{self.board.size}. Попробуйте снова.")
            except ValueError:
                print("Неверный формат ввода. Попробуйте снова.")

    def play(self):
        """Основной игровой цикл."""
        print("Добро пожаловать в игру 'Морской бой'!")
        self.board.print_board()

        while self.shots > 0:
            row, col = self.get_user_input()

            if (row, col) in self.board.shots:
                print("Вы уже стреляли в эту клетку. Попробуйте другую.")
                continue

            self.board.shots.append((row, col))

            # Проверка попадания
            hit_ship = next((ship for ship in self.board.ships if ship.location == (row, col)), None)
            if hit_ship and not hit_ship.is_sunk:
                print("Попадание!")
                hit_ship.is_sunk = True
                self.hits += 1
                if self.hits == len(self.board.ships):
                    print("Вы поразили все корабли! Вы победили!")
                    self.board.print_board()
                    return
            else:
                print("Мимо!")

            self.shots -= 1
            self.board.print_board()

        print("У вас закончились выстрелы. Выиграл компьютер!")

if __name__ == "__main__":
    game = Game()
    game.play()

import random

class Ship:
    """Класс для представления корабля на поле."""
    def __init__(self, start_location, orientation, size):
        self.start_location = start_location
        self.orientation = orientation
        self.size = size
        self.hit_locations = [False] * size

    def get_locations(self):
        """Возвращает все клетки, занимаемые кораблем."""
        locations = []
        row, col = self.start_location
        for i in range(self.size):
            if self.orientation == 'H':
                locations.append((row, col + i))
            else:
                locations.append((row + i, col))
        return locations

    def register_hit(self, location):
        """Регистрирует попадание по кораблю."""
        for i, loc in enumerate(self.get_locations()):
            if loc == location:
                self.hit_locations[i] = True

    def is_sunk(self):
        """Проверяет, потоплен ли корабль."""
        return all(self.hit_locations)

class Board:
    """Класс для представления игрового поля."""
    def __init__(self, size):
        self.size = size
        self.shots = []
        self.ships = []

    def place_ships(self, ship_specs):
        """Размещение кораблей на доске."""
        for size in ship_specs:
            placed = False
            while not placed:
                orientation = random.choice(['H', 'V'])
                start_row = random.randint(0, self.size - 1)
                start_col = random.randint(0, self.size - 1)

                if orientation == 'H':
                    if start_col + size <= self.size:
                        ship = Ship((start_row, start_col), orientation, size)
                        if not self._is_overlap(ship):
                            self.ships.append(ship)
                            placed = True

                elif orientation == 'V':
                    if start_row + size <= self.size:
                        ship = Ship((start_row, start_col), orientation, size)
                        if not self._is_overlap(ship):
                            self.ships.append(ship)
                            placed = True

    def _is_overlap(self, new_ship):
        """Проверка пересечения с существующими кораблями."""
        new_locations = set(new_ship.get_locations())
        for ship in self.ships:
            if not set(ship.get_locations()).isdisjoint(new_locations):
                return True
        return False

    def print_board(self):
        """Отображение текущего состояния игрового поля."""
        display_board = [['_' for _ in range(self.size)] for _ in range(self.size)]
        for row, col in self.shots:
            is_hit = False
            for ship in self.ships:
                if (row, col) in ship.get_locations():
                    if ship.hit_locations[ship.get_locations().index((row, col))]:
                        display_board[row][col] = '*'
                    if ship.is_sunk():
                        display_board[row][col] = 'X'
                    is_hit = True
                    break
            if not is_hit:
                display_board[row][col] = 'o'

        print("\nТекущая игровая доска:")
        for row in display_board:
            print(" ".join(row))
        print()

class Game:
    """Основной класс для организации игрового процесса."""
    def __init__(self, board_size=5, shots=25):
        self.board = Board(board_size)
        # 1 трёхпалубный, 2 двухпалубных и 3 однопалубных корабля
        self.board.place_ships([3, 2, 2, 1, 1, 1])
        self.shots = shots

    def get_user_input(self):
        """Получение и валидация ввода от пользователя."""
        while True:
            try:
                user_input = input("Введите координаты выстрела (строка, колонка, через запятую): ")
                row, col = user_input.split(',')
                row, col = int(row) - 1, int(col) - 1
                if 0 <= row < self.board.size and 0 <= col < self.board.size:
                    return row, col
                else:
                    print(f"Координаты должны быть в пределах 1-{self.board.size}. Попробуйте снова.")
            except ValueError:
                print("Неверный формат ввода. Попробуйте снова.")

    def play(self):
        """Основной игровой цикл."""
        print("Добро пожаловать в игру 'Морской бой'!")
        self.board.print_board()

        while self.shots > 0:
            row, col = self.get_user_input()

            if (row, col) in self.board.shots:
                print("Вы уже стреляли в эту клетку. Попробуйте другую.")
                continue

            self.board.shots.append((row, col))
            hit_anything = False

            for ship in self.board.ships:
                if (row, col) in ship.get_locations():
                    ship.register_hit((row, col))
                    hit_anything = True
                    if ship.is_sunk():
                        print("Корабль потоплен!")
                    else:
                        print("Корабль ранен!")
                    break

            if not hit_anything:
                print("Мимо!")

            self.shots -= 1
            self.board.print_board()

            if all(ship.is_sunk() for ship in self.board.ships):
                print("Вы поразили все корабли! Вы победили!")
                return

        print("У вас закончились выстрелы. Выиграл компьютер!")

if __name__ == "__main__":
    game = Game()
    game.play()

import random

class Ship:
    """Класс для представления обычного корабля на поле."""
    def __init__(self, start_location, orientation, size, ship_type="ship"):
        self.start_location = start_location
        self.orientation = orientation
        self.size = size
        self.ship_type = ship_type
        self.hit_locations = [False] * size

    def get_locations(self):
        """Возвращает все клетки, занимаемые кораблем."""
        locations = []
        row, col = self.start_location
        for i in range(self.size):
            if self.orientation == 'H':
                locations.append((row, col + i))
            else:
                locations.append((row + i, col))
        return locations

    def register_hit(self, location):
        """Регистрирует попадание по кораблю."""
        for i, loc in enumerate(self.get_locations()):
            if loc == location:
                self.hit_locations[i] = True

    def is_sunk(self):
        """Проверяет, потоплен ли корабль."""
        return all(self.hit_locations)

class Board:
    """Класс для представления игрового поля."""
    def __init__(self, size):
        self.size = size
        self.shots = []
        self.ships = []

    def place_ships(self, ship_specs):
        """Размещение кораблей на доске."""
        for size, ship_type in ship_specs:
            placed = False
            while not placed:
                orientation = random.choice(['H', 'V'])
                start_row = random.randint(0, self.size - 1)
                start_col = random.randint(0, self.size - 1)

                ship = Ship((start_row, start_col), orientation, size, ship_type)
                
                if ship_type == "submarine" or not self._is_overlap(ship):
                    self.ships.append(ship)
                    placed = True

    def _is_overlap(self, new_ship):
        """Проверка пересечения с существующими кораблями (кроме подводной лодки)."""
        new_locations = set(new_ship.get_locations())
        for ship in self.ships:
            if ship.ship_type != "submarine" and not set(ship.get_locations()).isdisjoint(new_locations):
                return True
        return False

    def print_board(self):
        """Отображение текущего состояния игрового поля."""
        display_board = [['_' for _ in range(self.size)] for _ in range(self.size)]
        for row, col in self.shots:
            is_hit = False
            for ship in self.ships:
                if (row, col) in ship.get_locations():
                    idx = ship.get_locations().index((row, col))
                    if ship.hit_locations[idx]:
                        display_board[row][col] = '*'
                    if ship.is_sunk():
                        display_board[row][col] = 'X'
                    is_hit = True
            if not is_hit:
                display_board[row][col] = 'o'

        print("\nТекущая игровая доска:")
        for row in display_board:
            print(" ".join(row))
        print()

class Game:
    """Основной класс для организации игрового процесса."""
    def __init__(self, board_size=5, shots=25):
        self.board = Board(board_size)
        # 1 трёхпалубный, 2 двухпалубных, 3 однопалубных корабля и 1 подводная лодка
        self.board.place_ships([(3, "ship"), (2, "ship"), (2, "ship"), (1, "ship"), (1, "ship"), (1, "ship"), (3, "submarine")])
        self.shots = shots

    def get_user_input(self):
        """Получение и валидация ввода от пользователя."""
        while True:
            try:
                user_input = input("Введите координаты выстрела (строка, колонка, через запятую): ")
                row, col = user_input.split(',')
                row, col = int(row) - 1, int(col) - 1
                if 0 <= row < self.board.size and 0 <= col < self.board.size:
                    return row, col
                else:
                    print(f"Координаты должны быть в пределах 1-{self.board.size}. Попробуйте снова.")
            except ValueError:
                print("Неверный формат ввода. Попробуйте снова.")

    def play(self):
        """Основной игровой цикл."""
        print("Добро пожаловать в игру 'Морской бой'!")
        self.board.print_board()

        while self.shots > 0:
            row, col = self.get_user_input()

            if (row, col) in self.board.shots:
                print("Вы уже стреляли в эту клетку. Попробуйте другую.")
                continue

            self.board.shots.append((row, col))
            hit_anything = False

            for ship in self.board.ships:
                if (row, col) in ship.get_locations():
                    ship.register_hit((row, col))
                    hit_anything = True

                    # Определяем, что произошло поражение обеих при пересечении с подводной лодкой
                    other_ship_hit = [s for s in self.board.ships if s != ship and (row, col) in s.get_locations()]
                    for other_ship in other_ship_hit:
                        other_ship.register_hit((row, col))

                    if ship.is_sunk():
                        print(f"Корабль {ship.ship_type} потоплен!")
                    else:
                        print(f"Корабль {ship.ship_type} ранен!")
            if not hit_anything:
                print("Мимо!")

            self.shots -= 1
            self.board.print_board()

            if all(ship.is_sunk() for ship in self.board.ships):
                print("Вы поразили все корабли! Вы победили!")
                return

        print("У вас закончились выстрелы. Выиграл компьютер!")

if __name__ == "__main__":
    game = Game()
    game.play()

import random
from enum import Enum

class ShipType(Enum):
    ship = 1
    submarine = 2

class Orientation(Enum):
    horizontal = 1
    vertical = 2

class Ship:
    def __init__(self, start_location:(int, int), orientation:Orientation, size:int, ship_type:ShipType):

        if size > Board.SIZE:
            raise Exception(f"Размеры корабля {size} превышают размеры доски {Board.SIZE}")

        self.start_location = start_location
        self.orientation = orientation
        self.size = size
        self.ship_type = ship_type
        self.hit_locations = [False] * size


    def get_locations(self):
        locations = []
        row, col = self.start_location
        for i in range(self.size):
            if self.orientation == Orientation.horizontal:
                locations.append((row, col + i))
            elif self.orientation == Orientation.vertical:
                locations.append((row + i, col))
        return locations

    def register_hit(self, location):
        if location in self.get_locations():
            index = self.get_locations().index(location)
            self.hit_locations[index] = True

    def is_sunk(self):
        return all(self.hit_locations)


class Board:
    SIZE = 4

    def __init__(self):
        self.shots = []
        self.ships = []

    def place_ships(self, ship_specs):

        ready = False
        global_attempts = 0
        while not ready and global_attempts < 100:

            global_attempts += 1

            for size, ship_type in ship_specs:
                    ship_placed = False
                    ship_attempts = 0
                    while not ship_placed and ship_attempts < 100:
                        orientation = random.choice([Orientation.horizontal, Orientation.vertical])
                        start_row = random.randint(0, Board.SIZE - 1)
                        start_col = random.randint(0, Board.SIZE - 1)

                        new_ship = Ship((start_row, start_col), orientation, size, ship_type)

                        if self._is_valid_placement(new_ship, ship_type):
                            self.ships.append(new_ship)
                            ship_placed = True
                        ship_attempts += 1

                    if not ship_placed:
                        self.ships.clear() # всё сбросить и начать заново
                        break

            if len(self.ships) == len(ship_specs):
                ready = True

        if not ready:
            raise Exception(f"Не удалось разместить все корабли за {global_attempts} попыток")

    def _is_valid_placement(self, new_ship, ship_type):
        # Проверка выхода за пределы игрового поля
        locations = new_ship.get_locations()
        if not all(0 <= row < Board.SIZE and 0 <= col < Board.SIZE for row, col in locations):
            return False
        # Проверка пересечения кораблей, кроме субмарин
        if ship_type != ShipType.submarine and self._is_overlap(new_ship):
            return False
        return True

    def _is_overlap(self, new_ship):
        new_locations = set(new_ship.get_locations())
        for ship in self.ships:
            if not new_locations.isdisjoint(ship.get_locations()):
                return True
        return False

    def print_board(self):
        display_board = [['_' for _ in range(Board.SIZE)] for _ in range(Board.SIZE)]
        for row, col in self.shots:
            for ship in self.ships:
                if (row, col) in ship.get_locations():
                    if ship.ship_type == ShipType.submarine:
                        display_board[row][col] = '#' if ship.is_sunk() else '+'
                    else:
                        display_board[row][col] = 'X' if ship.is_sunk() else '*'
                    break
            else:
                display_board[row][col] = 'o'

        print("\nТекущая игровая доска:")
        for row in display_board:
            print(" ".join(row))
        print()

class Game:
    def __init__(self, shots=25):
        self.board = Board()
        try:
            self.board.place_ships(
                [(3, ShipType.submarine),
                 (3, ShipType.ship),
                 (2, ShipType.ship),
                 (2, ShipType.ship),
                 (1, ShipType.ship)])
        except Exception as e:
            print(str(e))
            exit(1)
        self.shots = shots

    def get_user_input(self):
        while True:
            try:
                user_input = input("Введите координаты выстрела (строка, колонка, через запятую): ")
                row, col = user_input.split(',')
                row, col = int(row) - 1, int(col) - 1
                if 0 <= row < Board.SIZE and 0 <= col < Board.SIZE:
                    return row, col
                else:
                    print(f"Координаты должны быть в пределах 1-{Board.SIZE}. Попробуйте снова.")
            except ValueError:
                print("Неверный формат ввода. Попробуйте снова.")

    def play(self):
        print("Добро пожаловать в игру 'Морской бой'!")
        self.board.print_board()

        while self.shots > 0:
            row, col = self.get_user_input()

            self.board.shots.append((row, col))
            hit_anything = False

            for ship in self.board.ships:
                if (row, col) in ship.get_locations():
                    ship.register_hit((row, col))
                    hit_anything = True
                    print(f"Корабль {ship.ship_type} {'потоплен' if ship.is_sunk() else 'ранен'}!")
                    break

            if not hit_anything:
                print("Мимо!")

            self.board.print_board()

            if all(ship.is_sunk() for ship in self.board.ships):
                print("Вы поразили все корабли! Вы победили!")
                return

            self.shots -= 1

        print("У вас закончились выстрелы. Выиграл компьютер!")

if __name__ == "__main__":
    game = Game()
    game.play()

```python
def проведение_документа():
	if документ.проверка():
		документ.записать()
```

```1C
// Первая неудачная попытка
Функция PythonTo1C(Код)
	Возврат "Неправильный контекст"
КонецФункции
```

```1C
&НаКлиенте
Процедура ГенерацияКода(Команда)
	Запрос = Новый HTTPЗапрос;
	Запрос.URL = "https://super-ai-coder.com
	Запрос.ТелоЗапроса = "Создай функцию для расчёта зарплаты";
	Запрос.Вставить("context", "1C:Enterprise");
	Ответ = Запрос.ПолучитьОтвет();
	Если Ответ.КодСостояния = 200 Тогда
		Сообщить("Успешно получили код!");
		ВставитьКод(Ответ.ТелоОтвета);
	КонецЕсли;
КонецПроцедуры
```

```1C
Функция СоздатьФункцию(ИмяФункции, Параметры) Экспорт
	// Здесь происходит магия самосознания
	Возврат "Процедура "+ИмяФункции+"("+Параметры+")
		// TODO: реализовать через нейросеть
	КонецПроцедуры";
КонецФункции
```

```1C
Процедура СделатьВсе(ТекстЗапроса,Контекст)
	Пока Истина Цикл
		  ИИОтвет = ОбратитьсяКИИ(ТекстЗапроса,Контекст);
		  Если СинтаксисВерный(ИИОтвет) Тогда
			Попытка
		  		Выполнить(ИИОтвет);
		  		Прервать;
			Исключение
		  		Продолжить;	
			КонецПопытки;
		  КонецЕсли;
	КонецЦикла;
КонецПроцедуры
```