Initial commit

.gitignore

@@ -0,0 +1,2 @@
+# Project exclude paths
+/venv/

.idea/.gitignore

@@ -0,0 +1,2 @@
+# Default ignored files
+/workspace.xml

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.7" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/pythonCoolGames.iml" filepath="$PROJECT_DIR$/.idea/pythonCoolGames.iml" />
+    </modules>
+  </component>
+</project>

.idea/pythonCoolGames.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.7" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

cipher/cipher.py

@@ -0,0 +1,52 @@
+# Шифр Цезаря
+SYMBOLS = 'АБВГДЕЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеежзийклмнопрстуфхцчшщъыьэюя'
+MAX_KEY_SIZE = len(SYMBOLS)
+
+def getMode():
+    while True:
+        print('Вы хотите зашифровать или расшифровать текст?')
+        mode = input().lower()
+        if mode in ['зашифровать', 'з', 'расшифровать', 'р']:
+            return mode
+        else:
+            print('Введите "зашифровать" или "з" для зашифровки или "расшифровать" или "р" для расшифровки.')
+
+def getMessage():
+    print('Введите текст:')
+    return input()
+
+def getKey():
+    key = 0
+    while True:
+        print('Введите ключ шифрования (1-%s)' % (MAX_KEY_SIZE))
+        key = int(input())
+        if (key >= 1 and key <= MAX_KEY_SIZE):
+            return key
+
+def getTranslatedMessage(mode, message, key):
+    if mode[0] == 'р':
+        key = -key
+    translated = ''
+
+    for symbol in message:
+        symbolIndex = SYMBOLS.find(symbol)
+        if symbolIndex == -1: # Символ не найден в SYMBOLS.
+        # Просто добавить этот символ без изменений.
+            translated += symbol
+        else:
+        # Зашифровать или расшифровать
+            symbolIndex += key
+
+            if symbolIndex >= len(SYMBOLS):
+                symbolIndex -= len(SYMBOLS)
+            elif symbolIndex < 0:
+                symbolIndex += len(SYMBOLS)
+
+        translated += SYMBOLS[symbolIndex]
+    return translated
+
+mode = getMode()
+message = getMessage()
+key = getKey()
+print('Преобразованный текст:')
+print(getTranslatedMessage(mode, message, key))

cipher/cipher2.py

@@ -0,0 +1,52 @@
+# Шифр Цезаря
+SYMBOLS = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзийклмнопрстуфхцчшщъыьэюя0123456789!@#$%^&*№;:?.-+=`~|,<>®§™ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+MAX_KEY_SIZE = len(SYMBOLS)
+
+def getMode():
+    while True:
+        print('Вы хотите зашифровать или расшифровать текст?')
+        mode = input().lower()
+        if mode in ['зашифровать', 'з', 'расшифровать', 'р']:
+            return mode
+        else:
+            print('Введите "зашифровать" или "з" для зашифровки или "расшифровать" или "р" для расшифровки.')
+
+def getMessage():
+    print('Введите текст:')
+    return input()
+
+def getKey():
+    key = 0
+    while True:
+        print('Введите ключ шифрования (1-%s)' % (MAX_KEY_SIZE))
+        key = int(input())
+        if (key >= 1 and key <= MAX_KEY_SIZE):
+            return key
+
+def getTranslatedMessage(mode, message, key):
+    if mode[0] == 'р':
+        key = -key
+    translated = ''
+
+    for symbol in message:
+        symbolIndex = SYMBOLS.find(symbol)
+        if symbolIndex == -1: # Символ не найден в SYMBOLS.
+        # Просто добавить этот символ без изменений.
+            translated += symbol
+        else:
+        # Зашифровать или расшифровать
+            symbolIndex += key
+
+            if symbolIndex >= len(SYMBOLS):
+                symbolIndex -= len(SYMBOLS)
+            elif symbolIndex < 0:
+                symbolIndex += len(SYMBOLS)
+
+        translated += SYMBOLS[symbolIndex]
+    return translated
+
+mode = getMode()
+message = getMessage()
+key = getKey()
+print('Преобразованный текст:')
+print(getTranslatedMessage(mode, message, key))

cipher/cipher2AndHack.py

@@ -0,0 +1,58 @@
+# Шифр Цезаря
+SYMBOLS = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзийклмнопрстуфхцчшщъыьэюя0123456789!@#$%^&*№;:?.-+=`~|,<>®§™ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+MAX_KEY_SIZE = len(SYMBOLS)
+
+def getMode():
+    while True:
+        print('Вы хотите зашифровать, расшифровать или взломать текст?')
+        mode = input().lower()
+        if mode in ['зашифровать', 'з', 'расшифровать', 'р', 'взломать', 'в']:
+            return mode
+        else:
+            print('Введите "зашифровать" или "з" для зашифровки, "расшифровать" или "р" для расшифровки, "взломать" или "в" для взлома')
+
+def getMessage():
+    print('Введите текст:')
+    return input()
+
+def getKey():
+    key = 0
+    while True:
+        print('Введите ключ шифрования (1-%s)' % (MAX_KEY_SIZE))
+        key = int(input())
+        if (key >= 1 and key <= MAX_KEY_SIZE):
+            return key
+
+def getTranslatedMessage(mode, message, key):
+    if mode[0] == 'р':
+        key = -key
+    translated = ''
+
+    for symbol in message:
+        symbolIndex = SYMBOLS.find(symbol)
+        if symbolIndex == -1: # Символ не найден в SYMBOLS.
+        # Просто добавить этот символ без изменений.
+            translated += symbol
+        else:
+        # Зашифровать или расшифровать
+            symbolIndex += key
+
+            if symbolIndex >= len(SYMBOLS):
+                symbolIndex -= len(SYMBOLS)
+            elif symbolIndex < 0:
+                symbolIndex += len(SYMBOLS)
+
+        translated += SYMBOLS[symbolIndex]
+    return translated
+
+mode = getMode()
+message = getMessage()
+if mode[0] != 'в':
+    key = getKey()
+print('Преобразованный текст:')
+if mode[0] != 'в':
+    print(getTranslatedMessage(mode, message, key))
+
+else:
+    for key in range(1, MAX_KEY_SIZE + 1):
+        print(key, getTranslatedMessage('расшифровать', message, key))

cipher/cipherAndHack.py

@@ -0,0 +1,58 @@
+# Шифр Цезаря
+SYMBOLS = 'АБВГДЕЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеежзийклмнопрстуфхцчшщъыьэюя'
+MAX_KEY_SIZE = len(SYMBOLS)
+
+def getMode():
+    while True:
+        print('Вы хотите зашифровать, расшифровать или взломать текст?')
+        mode = input().lower()
+        if mode in ['зашифровать', 'з', 'расшифровать', 'р', 'взломать', 'в']:
+            return mode
+        else:
+            print('Введите "зашифровать" или "з" для зашифровки, "расшифровать" или "р" для расшифровки, "взломать" или "в" для взлома')
+
+def getMessage():
+    print('Введите текст:')
+    return input()
+
+def getKey():
+    key = 0
+    while True:
+        print('Введите ключ шифрования (1-%s)' % (MAX_KEY_SIZE))
+        key = int(input())
+        if (key >= 1 and key <= MAX_KEY_SIZE):
+            return key
+
+def getTranslatedMessage(mode, message, key):
+    if mode[0] == 'р':
+        key = -key
+    translated = ''
+
+    for symbol in message:
+        symbolIndex = SYMBOLS.find(symbol)
+        if symbolIndex == -1: # Символ не найден в SYMBOLS.
+        # Просто добавить этот символ без изменений.
+            translated += symbol
+        else:
+        # Зашифровать или расшифровать
+            symbolIndex += key
+
+            if symbolIndex >= len(SYMBOLS):
+                symbolIndex -= len(SYMBOLS)
+            elif symbolIndex < 0:
+                symbolIndex += len(SYMBOLS)
+
+        translated += SYMBOLS[symbolIndex]
+    return translated
+
+mode = getMode()
+message = getMessage()
+if mode[0] != 'в':
+    key = getKey()
+print('Преобразованный текст:')
+if mode[0] != 'в':
+    print(getTranslatedMessage(mode, message, key))
+
+else:
+    for key in range(1, MAX_KEY_SIZE + 1):
+        print(key, getTranslatedMessage('расшифровать', message, key))

coinFlips/flips.py

@@ -0,0 +1,20 @@
+import random
+print('Я подброшу монетку 1000 раз. Угадай, сколько раз выпадет "Орел"? (Нажми клавишу Enter, чтобы начать)')
+input()
+flips = 0
+heads = 0
+while flips < 1000:
+    if random.randint(0, 1) == 1:
+        heads = heads + 1
+    flips = flips + 1
+
+    if flips == 900:
+        print('900 подкидываний и "Орел" выпал ' + str(heads) + ' раз.')
+    if flips == 100:
+        print('При 100 бросках, "Орел" выпал ' + str(heads) + ' раз.')
+    if flips == 500:
+        print('Полпути пройдено и "Орел" выпал ' + str(heads) + ' раз.')
+
+print()
+print('Из 1000 подбрасываний монетки "Орел" выпал ' + str(heads) + ' раз!')
+print('Насколько вы близки к правильному ответу?')

drakoni/drakoni.py

@@ -0,0 +1,42 @@
+import random
+import time
+
+def displayIntro():
+    print('''Вы находитесь в землях, заселенных драконами.
+Перед собой вы видите две пещеры. В одной из них — дружелюбный дракон,
+который готов поделиться с вами своими сокровищами. Во второй —
+жадный и голодный дракон, который мигом вас съест.''')
+    print()
+
+def chooseCave():
+    cave = ''
+    while cave != '1' and cave != '2':
+        print('В какую пещеру вы войдете? (нажмите клавишу 1 или 2)   ')
+        cave = input()
+
+    return cave
+
+def checkCave(chosenCave):
+    print('Вы приближаетесь к пещере...')
+    time.sleep(2)
+    print('Ее темнота заставляет вас дрожать от страха...')
+    time.sleep(2)
+    print('Большой дракон выпрыгивает перед вами! Он раскрывает свою пасть и...')
+    print()
+    time.sleep(2)
+
+    friendlyCave = random.randint(1, 2)
+
+    if chosenCave == str(friendlyCave):
+        print('...делится с вами своими сокровищами!')
+    else:
+        print('...моментально вас съедает!')
+
+playAgain = 'да'
+while playAgain == 'да' or playAgain == 'д' or playAgain == 'l':
+    displayIntro()
+    caveNumber = chooseCave()
+    checkCave(caveNumber)
+
+    print('Попытаете удачу еще раз? (да или нет)  ')
+    playAgain = input()

goracho-holodno/goracho-holodno.py

@@ -0,0 +1,72 @@
+import random
+
+NUM_DIGITS = 3
+MAX_GUESS = 10
+
+def getSecretNum():
+    # Возвращает строку уникальных случайных цифр, длина которой составляет NUM_DIGITS.
+    numbers = list(range(10))
+    random.shuffle(numbers)
+    secretNum = ''
+    for i in range(NUM_DIGITS):
+        secretNum += str(numbers[i])
+    return secretNum
+
+def getClues(guess, secretNum):
+    # Возвращает строку с подсказками пользователю "Тепло", "Горячо" и "Холодно".
+    if guess == secretNum:
+        return 'Вы угадали!'
+
+    clues = []
+    for i in range(len(guess)):
+        if guess[i] == secretNum[i]:
+            clues.append('Горячо')
+        elif guess[i] in secretNum:
+            clues.append('Тепло')
+    if len(clues) == 0:
+        return 'Холодно'
+
+    clues.sort()
+    return ' '.join(clues)
+
+def isOnlyDigits(num):
+    # Возвращает значение True, если num - строка, состоящая только из цифр. В противном случае возвращает False.
+    if num == '':
+        return False
+    for i in num:
+        if i not in '0 1 2 3 4 5 6 7 8 9'.split():
+
+            return False
+
+    return True
+
+
+print('Я загадаю %s-х значное число, которое вы должны отгадать.' % (NUM_DIGITS))
+print('Я дам несколько подсказок...')
+print('Когда я говорю: Это означает:')
+print(' Холодно         Ни одна цифра не отгадана.')
+print(' Тепло           Одна цифра отгадана, но не отгадана ее позиция.')
+print(' Горячо          Одна цифра и ее позиция отгаданы.')
+
+while True:
+    secretNum = getSecretNum()
+    print('Итак, я загадал число. У вас есть %s попыток, чтобы отгадать его.' % (MAX_GUESS))
+
+    guessesTaken = 1
+    while guessesTaken <= MAX_GUESS:
+        guess = ''
+        while len(guess) != NUM_DIGITS or not isOnlyDigits(guess):
+            print('Попытка №%s: ' % (guessesTaken))
+            guess = input()
+
+        print(getClues(guess, secretNum))
+        guessesTaken += 1
+
+    if guess == secretNum:
+        break
+    if guessesTaken > MAX_GUESS:
+        print('Попыток больше не осталось. Я загадал число %s.' % (secretNum))
+
+    print('Хотите сыграть еще раз? (да или нет)')
+    if not input().lower().startswith('д'):
+        break

krestiki-noliki/krestiki-noliki.py

@@ -0,0 +1,175 @@
+# Крестики-нолики
+
+import random
+
+def drawBoard(board):
+# Эта функция выводит на экран игровое поле, клетки которого будут заполняться.
+
+# "board" — это список из 10 строк, для прорисовки игрового поля (индекс 0 игнорируется).
+    print(board[7] + '|' + board[8] + '|' + board[9])
+    print('-+-+-')
+    print(board[4] + '|' + board[5] + '|' + board[6])
+    print('-+-+-')
+    print(board[1] + '|' + board[2] + '|' + board[3])
+
+def inputPlayerLetter():
+    # Разрешение игроку ввести букву, которую он выбирает.
+    # Возвращает список, в котором буква игрока — первый элемент, а буква компьютера — второй.
+    letter = ''
+    while not (letter == 'Х' or letter == 'О'):
+        print('Вы выбираете Х или О?')
+        letter = input().upper()
+
+    # Первым элементом списка является буква игрока, вторым — буква компьютера.
+    if letter == 'Х':
+        return ['Х', 'О']
+    else:
+        return ['О', 'Х']
+
+def whoGoesFirst():
+    # Случайный выбор игрока, который ходит первым.
+    if random.randint(0, 1) == 0:
+        return 'Компьютер'
+    else:
+        return 'Человек'
+
+def makeMove(board, letter, move):
+    board[move] = letter
+
+def isWinner(bo, le):
+    # Учитывая заполнение игрового поля и буквы игрока, эта функция возвращает True, если игрок выиграл.
+    # Мы используем "bo" вместо "board" и "le" вместо "letter", поэтому нам не нужно много печатать.
+    return ((bo[7] == le and bo[8] == le and bo[9] == le) or # across the top
+    (bo[4] == le and bo[5] == le and bo[6] == le) or # через центр
+    (bo[1] == le and bo[2] == le and bo[3] == le) or # через низ
+    (bo[7] == le and bo[4] == le and bo[1] == le) or # вниз по левой стороне
+    (bo[8] == le and bo[5] == le and bo[2] == le) or # вниз по центру
+    (bo[9] == le and bo[6] == le and bo[3] == le) or # вниз по правой стороне
+    (bo[7] == le and bo[5] == le and bo[3] == le) or # по диагонали
+    (bo[9] == le and bo[5] == le and bo[1] == le)) # по диагонали
+
+def getBoardCopy(board):
+    # Создает копию игрового поля и возвращает его.
+    boardCopy = []
+    for i in board:
+        boardCopy.append(i)
+    return boardCopy
+
+def isSpaceFree(board, move):
+    # Возвращает True, если сделан ход в свободную клетку.
+    return board[move] == ' '
+
+def getPlayerMove(board):
+    # Разрешение игроку сделать ход.
+    move = ' '
+    while move not in '1 2 3 4 5 6 7 8 9'.split() or not isSpaceFree(board, int(move)):
+        print('Ваш следующий ход? (1-9)')
+        move = input()
+    return int(move)
+
+def chooseRandomMoveFromList(board, movesList):
+    # Возвращает допустимый ход, учитывая список сделанных ходов и список заполненных клеток.
+    # Возвращает значение None, если больше нет допустимых ходов.
+    possibleMoves = []
+    for i in movesList:
+        if isSpaceFree(board, i):
+            possibleMoves.append(i)
+
+    if len(possibleMoves) != 0:
+        return random.choice(possibleMoves)
+    else:
+        return None
+
+def getComputerMove(board, computerLetter):
+    # Учитывая заполнение игрового поля и букву компьютера, определяет допустимый ход и возвращает его.
+    if computerLetter == 'Х':
+        playerLetter = 'О'
+    else:
+        playerLetter = 'Х'
+
+    # Это алгоритм для ИИ "Крестиков-Ноликов":
+    # Сначала проверяем — победим ли мы, сделав следующий ход.
+    for i in range(1, 10):
+        boardCopy = getBoardCopy(board)
+        if isSpaceFree(boardCopy, i):
+            makeMove(boardCopy, computerLetter, i)
+            if isWinner(boardCopy, computerLetter):
+                return i
+
+    # Проверяем — победит ли игрок, сделав следующий ход, и блокируем его.
+    for i in range(1, 10):
+        boardCopy = getBoardCopy(board)
+        if isSpaceFree(boardCopy, i):
+            makeMove(boardCopy, playerLetter, i)
+            if isWinner(boardCopy, playerLetter):
+                return i
+
+    # Пробуем занять один из углов, если есть свободные.
+    move = chooseRandomMoveFromList(board, [1, 3, 7, 9])
+    if move != None:
+        return move
+
+    # Пробуем занять центр, если он свободен.
+    if isSpaceFree(board, 5):
+        return 5
+
+    # Делаем ход по одной стороне.
+    return chooseRandomMoveFromList(board, [2, 4, 6, 8])
+
+def isBoardFull(board):
+# Возвращает True, если клетка на игровом поле занята. В противном случае, возвращает False.
+    for i in range(1, 10):
+        if isSpaceFree(board, i):
+            return False
+    return True
+
+
+print('Игра "Крестики-нолики"')
+
+while True:
+    # Перезагрузка игрового поля
+    theBoard = [' '] * 10
+    playerLetter, computerLetter = inputPlayerLetter()
+    turn = whoGoesFirst()
+    print('' + turn + ' ходит первым.')
+    gameIsPlaying = True
+
+    while gameIsPlaying:
+        if turn == 'Человек':
+            # Ход игрока.
+            drawBoard(theBoard)
+            move = getPlayerMove(theBoard)
+            makeMove(theBoard, playerLetter, move)
+
+            if isWinner(theBoard, playerLetter):
+                drawBoard(theBoard)
+                print('Ура! Вы выиграли!')
+                gameIsPlaying = False
+            else:
+                if isBoardFull(theBoard):
+                    drawBoard(theBoard)
+                    print('Ничья!')
+                    break
+                else:
+                    turn = 'Компьютер'
+
+        else:
+        # Ход компьютера.
+            move = getComputerMove(theBoard, computerLetter)
+            makeMove(theBoard, computerLetter, move)
+
+            if isWinner(theBoard, computerLetter):
+                drawBoard(theBoard)
+                print('Компьютер победил! Вы проиграли.')
+                gameIsPlaying = False
+            else:
+                if isBoardFull(theBoard):
+                    drawBoard(theBoard)
+                    print('Ничья!')
+                    break
+                else:
+                    turn = 'Человек'
+
+    print('Сыграем еще раз? (да или нет)')
+    if not input().lower().startswith('д'):
+        break

notes

@@ -0,0 +1,2 @@
+\d{1,2}\.
+это надо контрол+R и там поставить regex и забить это, чтобы убрать цифры(привет копипастерам)

reversi/computerVScomputer/AISim1.py

@@ -0,0 +1,243 @@
+# "Реверси": клон "Отелло".
+import random
+import sys
+WIDTH = 8 # Игровое поле содержит 8 клеток по ширине.
+HEIGHT = 8 # Игровое поле содержит 8 клеток по высоте.
+CONST_X = 'X'
+CONST_O = 'O'
+def drawBoard(board):
+    # Вывести игровое поле, переданное этой функции. Ничего не возвращать.
+    print('  12345678')
+    print(' +--------+')
+    for y in range(HEIGHT):
+        print('%s|' % (y+1), end='')
+        for x in range(WIDTH):
+            print(board[x][y], end='')
+        print('|%s' % (y+1))
+    print(' +--------+')
+    print('  12345678')
+
+def getNewBoard():
+    # Создать структуру данных нового чистого игрового поля.
+    board = []
+    for i in range(WIDTH):
+        board.append([' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '])
+    return board
+
+def isValidMove(board, tile, xstart, ystart):
+    # Вернуть False, если ход игрока в клетку с координатами xstart, ystart — недопустимый.
+    # Если это допустимый ход, вернуть список клеток, которые "присвоил" бы игрок, если бы сделал туда ход.
+    if board[xstart][ystart] != ' ' or not isOnBoard(xstart, ystart):
+        return False
+
+    if tile == CONST_X:
+        otherTile = CONST_O
+    else:
+        otherTile = CONST_X
+
+    tilesToFlip = []
+    for xdirection, ydirection in [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
+        x, y = xstart, ystart
+        x += xdirection # Первый шаг в направлении x
+        y += ydirection # Первый шаг в направлении y
+        while isOnBoard(x, y) and board[x][y] == otherTile:
+            # Продолжать двигаться в этом направлении x и y.
+            x += xdirection
+            y += ydirection
+            if isOnBoard(x, y) and board[x][y] == tile:
+            #Естьфишки,которыеможноперевернуть.Двигатьсявобратномнаправлениидодостиженияисходнойклетки,отмечаявсефишкинаэтомпути.
+                while True:
+                    x -= xdirection
+                    y -= ydirection
+                    if x == xstart and y == ystart:
+                        break
+                    tilesToFlip.append([x, y])
+
+    if len(tilesToFlip) == 0: # Если ни одна из фишек не перевернулась, это недопустимый ход
+        return False
+    return tilesToFlip
+
+def isOnBoard(x, y):
+# Вернуть True, если координаты есть на игровом поле.
+    return x >= 0 and x <= WIDTH - 1 and y >= 0 and y <= HEIGHT - 1
+
+def getBoardWithValidMoves(board, tile):
+    # Вернуть новое поле с точками, обозначающими допустимые ходы, которые может сделать игрок.
+    boardCopy = getBoardCopy(board)
+
+    for x, y in getValidMoves(boardCopy, tile):
+        boardCopy[x][y] = '.'
+    return boardCopy
+
+def getValidMoves(board, tile):
+    # Вернуть список списков с координатами x и y допустимых ходов для данного игрока на данном игровом поле.
+    validMoves = []
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            if isValidMove(board, tile, x, y) != False:
+                validMoves.append([x, y])
+    return validMoves
+
+def getScoreOfBoard(board):
+# Определить количество очков, подсчитав фишки. Вернуть словарь с ключами CONST_X и CONST_O.
+    xscore = 0
+    oscore = 0
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            if board[x][y] == CONST_X:
+                xscore += 1
+            if board[x][y] == CONST_O:
+                oscore += 1
+    return {CONST_X:xscore, CONST_O:oscore}
+
+def enterPlayerTile():
+    # Позволить игроку ввести выбранную фишку.
+    # Возвращает список с фишкой игрока в качестве первого элемента и фишкой компьютера в качестве второго.
+    tile = ''
+    while not (tile == CONST_X or tile == CONST_O):
+        print('Вы играете за Х или О?')
+        tile = input().upper()
+
+    # Первый элемент в списке — фишка игрока, второй элемент — фишка компьютера.
+    if tile == CONST_X:
+        return [CONST_X, CONST_O]
+    else:
+        return [CONST_O, CONST_X]
+
+def whoGoesFirst():
+    # Случайно выбрать, кто ходит первым.
+    if random.randint(0, 1) == 0:
+        return 'Компьютер'
+    else:
+        return 'Человек'
+
+def makeMove(board, tile, xstart, ystart):
+    # Поместить фишку на игровое поле в позицию xstart, ystart и перевернуть какую-либо фишку противника.
+    # Вернуть False, если это недопустимый ход; вернуть True, если допустимый.
+    tilesToFlip = isValidMove(board, tile, xstart, ystart)
+
+    if tilesToFlip == False:
+        return False
+
+    board[xstart][ystart] = tile
+    for x, y in tilesToFlip:
+        board[x][y] = tile
+    return True
+
+def getBoardCopy(board):
+# Сделать копию списка board и вернуть ее.
+    boardCopy = getNewBoard()
+
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            boardCopy[x][y] = board[x][y]
+
+    return boardCopy
+
+def isOnCorner(x, y):
+    # Вернуть True, если указанная позиция находится в одном из четырех углов.
+    return (x == 0 or x == WIDTH - 1) and (y == 0 or y == HEIGHT - 1)
+
+def getPlayerMove(board, playerTile):
+    # Позволить игроку ввести свой ход.
+    # Вернуть ход в виде [x, y] (или вернуть строки 'подсказка' или 'выход').
+    DIGITS1TO8 = '1 2 3 4 5 6 7 8'.split()
+    while True:
+        print('Укажите ход, текст "выход" для завершения игры или "подсказка" для вывода подсказки.')
+        move = input().lower()
+        if move == 'выход' or move == 'подсказка':
+            return move
+
+        if len(move) == 2 and move[0] in DIGITS1TO8 and move[1] in DIGITS1TO8:
+            x = int(move[0]) - 1
+            y = int(move[1]) - 1
+            if isValidMove(board, playerTile, x, y) == False:
+                continue
+            else:
+                break
+        else:
+            print('Это недопустимый ход. Введите номер столбца (1-8) и номер ряда (1-8).')
+            print('К примеру, значение 81 перемещает в верхний правый угол.')
+
+    return [x, y]
+
+def getComputerMove(board, computerTile):
+    # Учитывая данное игровое поле и данную фишку компьютера, определить,
+    # куда сделать ход, и вернуть этот ход в виде списка [x, y].
+    possibleMoves = getValidMoves(board, computerTile)
+    random.shuffle(possibleMoves) # Сделать случайным порядок ходов
+
+    # Всегда делать ход в угол, если это возможно.
+    for x, y in possibleMoves:
+        if isOnCorner(x, y):
+            return [x, y]
+
+    # Найти ход с наибольшим возможным количеством очков.
+    bestScore = -1
+    for x, y in possibleMoves:
+        boardCopy = getBoardCopy(board)
+        makeMove(boardCopy, computerTile, x, y)
+        score = getScoreOfBoard(boardCopy)[computerTile]
+        if score > bestScore:
+            bestMove = [x, y]
+            bestScore = score
+    return bestMove
+
+def printScore(board, playerTile, computerTile):
+    scores = getScoreOfBoard(board)
+    print('Ваш счет: %s. Счет компьютера: %s.' % (scores[playerTile], scores[computerTile]))
+
+def playGame(playerTile, computerTile):
+    showHints = False
+    turn = whoGoesFirst()
+    print(turn + ' ходит первым.')
+
+    # Очистить игровое поле и выставить стартовые фишки.
+    board = getNewBoard()
+    board[3][3] = CONST_X
+    board[3][4] = CONST_O
+    board[4][3] = CONST_O
+    board[4][4] = CONST_X
+
+    while True:
+        playerValidMoves = getValidMoves(board, playerTile)
+        computerValidMoves = getValidMoves(board, computerTile)
+
+        if playerValidMoves == [] and computerValidMoves == []:
+            return board # Ходов нет ни у кого, так что окончить игру.
+
+        elif turn == 'Человек': # Ход человека
+            if playerValidMoves != []:
+                move = getComputerMove(board, playerTile)
+                makeMove(board, playerTile, move[0], move[1])
+            turn = 'Компьютер'
+
+        elif turn == 'Компьютер': # Ход компьютера
+            if computerValidMoves != []:
+                move = getComputerMove(board, computerTile)
+                makeMove(board, computerTile, move[0], move[1])
+            turn = 'Человек'
+
+
+
+print('Приветствуем в игре "Р е в е р с и"!')
+
+playerTile, computerTile = [CONST_X, CONST_O]
+
+while True:
+    finalBoard = playGame(playerTile, computerTile)
+
+    # Отобразить итоговый счет.
+    drawBoard(finalBoard)
+    scores = getScoreOfBoard(finalBoard)
+    print('X набрал %s очков. O набрал %s очков.' % (scores[CONST_X], scores[CONST_O]))
+    if scores[playerTile] > scores[computerTile]:
+        print('ИИ 1 победил ИИ 2, обогнав его на %s очков!' % (scores[playerTile] - scores[computerTile]))
+    elif scores[playerTile] < scores[computerTile]:
+        print('ИИ 2 победил ИИ 1, обогнав его на %s очков!' % (scores[computerTile] - scores[playerTile]))
+    else:
+        print('Ничья!')
+
+    print('Хотите сыграть еще раз? (да или нет)')
+    if not input().lower().startswith('д'):
+        break

reversi/computerVScomputer/AISim2.py

@@ -0,0 +1,278 @@
+# Reversegam: a clone of Othello/Reversi
+import random
+import sys
+WIDTH = 8  # Board is 8 spaces wide
+HEIGHT = 8 # Board is 8 spaces tall
+def drawBoard(board):
+    # This function prints the board that it was passed. Returns None.
+    print('  12345678')
+    print(' +--------+')
+    for y in range(HEIGHT):
+        print('%s|' % (y+1), end='')
+        for x in range(WIDTH):
+            print(board[x][y], end='')
+        print('|%s' % (y+1))
+    print(' +--------+')
+    print('  12345678')
+
+def getNewBoard():
+    # Creates a brand-new, blank board data structure.
+    board = []
+    for i in range(WIDTH):
+        board.append([' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '])
+    return board
+
+def isValidMove(board, tile, xstart, ystart):
+    # Returns False if the player's move on space xstart, ystart is invalid.
+    # If it is a valid move, returns a list of spaces that would become the player's if they made a move here.
+    if board[xstart][ystart] != ' ' or not isOnBoard(xstart, ystart):
+        return False
+
+    if tile == 'Х':
+        otherTile = 'О'
+    else:
+        otherTile = 'Х'
+
+    tilesToFlip = []
+    for xdirection, ydirection in [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
+        x, y = xstart, ystart
+        x += xdirection # First step in the x direction
+        y += ydirection # First step in the y direction
+        while isOnBoard(x, y) and board[x][y] == otherTile:
+            # Keep moving in this x & y direction.
+            x += xdirection
+            y += ydirection
+            if isOnBoard(x, y) and board[x][y] == tile:
+                # There are pieces to flip over. Go in the reverse direction until we reach the original space, noting all the tiles along the way.
+                while True:
+                    x -= xdirection
+                    y -= ydirection
+                    if x == xstart and y == ystart:
+                        break
+                    tilesToFlip.append([x, y])
+
+    if len(tilesToFlip) == 0: # If no tiles were flipped, this is not a valid move.
+        return False
+    return tilesToFlip
+
+def isOnBoard(x, y):
+    # Returns True if the coordinates are located on the board.
+    return x >= 0 and x <= WIDTH - 1 and y >= 0 and y <= HEIGHT - 1
+
+def getBoardWithValidMoves(board, tile):
+    # Returns a new board with periods marking the valid moves the player can make.
+    boardCopy = getBoardCopy(board)
+
+    for x, y in getValidMoves(boardCopy, tile):
+        boardCopy[x][y] = '.'
+    return boardCopy
+
+def getValidMoves(board, tile):
+    # Returns a list of [x,y] lists of valid moves for the given player on the given board.
+    validMoves = []
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            if isValidMove(board, tile, x, y) != False:
+                validMoves.append([x, y])
+    return validMoves
+
+def getScoreOfBoard(board):
+    # Determine the score by counting the tiles. Returns a dictionary with keys 'X' and 'O'.
+    xscore = 0
+    oscore = 0
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            if board[x][y] == 'Х':
+                xscore += 1
+            if board[x][y] == 'О':
+                oscore += 1
+    return {'Х':xscore, 'О':oscore}
+
+def enterPlayerTile():
+    # Lets the player type which tile they want to be.
+    # Returns a list with the player's tile as the first item and the computer's tile as the second.
+    tile = ''
+    while not (tile == 'Х' or tile == 'О'):
+        print('Вы играете за Х или О?')
+        tile = input().upper()
+
+    # The first element in the list is the player's tile, and the second is the computer's tile.
+    if tile == 'Х':
+        return ['Х', 'О']
+    else:
+        return ['О', 'Х']
+
+def whoGoesFirst():
+    # Randomly choose who goes first.
+    if random.randint(0, 1) == 0:
+        return 'computer'
+    else:
+        return 'player'
+
+def makeMove(board, tile, xstart, ystart):
+    # Place the tile on the board at xstart, ystart, and flip any of the opponent's pieces.
+    # Returns False if this is an invalid move; True if it is valid.
+    tilesToFlip = isValidMove(board, tile, xstart, ystart)
+
+    if tilesToFlip == False:
+        return False
+
+    board[xstart][ystart] = tile
+    for x, y in tilesToFlip:
+        board[x][y] = tile
+    return True
+
+def getBoardCopy(board):
+    # Make a duplicate of the board list and return it.
+    boardCopy = getNewBoard()
+
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            boardCopy[x][y] = board[x][y]
+
+    return boardCopy
+
+def isOnCorner(x, y):
+    # Returns True if the position is in one of the four corners.
+    return (x == 0 or x == WIDTH - 1) and (y == 0 or y == HEIGHT - 1)
+
+def getPlayerMove(board, playerTile):
+    # Let the player enter their move.
+    # Returns the move as [x, y] (or returns the strings 'hints' or 'quit').
+    DIGITS1TO8 = '1 2 3 4 5 6 7 8'.split()
+    while True:
+        print('Укажите ход, текст "выход" для завершения игры или "подсказка" для вывода подсказки.')
+        move = input().lower()
+        if move == 'выход' or move == 'подсказка':
+            return move
+
+        if len(move) == 2 and move[0] in DIGITS1TO8 and move[1] in DIGITS1TO8:
+            x = int(move[0]) - 1
+            y = int(move[1]) - 1
+            if isValidMove(board, playerTile, x, y) == False:
+                continue
+            else:
+                break
+        else:
+            print('Это недопустимый ход. Введите номер столбца (1-8) и номер ряда (1-8).')
+            print('К примеру, значение 81 перемещает в верхний правый угол.')
+
+    return [x, y]
+
+def getComputerMove(board, computerTile):
+    # Given a board and the computer's tile, determine where to
+    # move and return that move as a [x, y] list.
+    possibleMoves = getValidMoves(board, computerTile)
+    random.shuffle(possibleMoves) # randomize the order of the moves
+
+    # Always go for a corner if available.
+    for x, y in possibleMoves:
+        if isOnCorner(x, y):
+            return [x, y]
+
+    # Find the highest-scoring move possible.
+    bestScore = -1
+    for x, y in possibleMoves:
+        boardCopy = getBoardCopy(board)
+        makeMove(boardCopy, computerTile, x, y)
+        score = getScoreOfBoard(boardCopy)[computerTile]
+        if score > bestScore:
+            bestMove = [x, y]
+            bestScore = score
+    return bestMove
+
+def printScore(board, playerTile, computerTile):
+    scores = getScoreOfBoard(board)
+    print('Ваш счет: %s. Счет компьютера: %s.' % (scores[playerTile], scores[computerTile]))
+
+def playGame(playerTile, computerTile):
+    showHints = False
+    turn = whoGoesFirst()
+    #print('The ' + turn + ' will go first.')
+
+    # Clear the board and place starting pieces.
+    board = getNewBoard()
+    board[3][3] = 'Х'
+    board[3][4] = 'О'
+    board[4][3] = 'О'
+    board[4][4] = 'Х'
+
+    while True:
+        playerValidMoves = getValidMoves(board, playerTile)
+        computerValidMoves = getValidMoves(board, computerTile)
+
+        if playerValidMoves == [] and computerValidMoves == []:
+            return board # No one can move, so end the game.
+
+        elif turn == 'player': # Player's turn
+            if playerValidMoves != []:
+                #if showHints:
+                #    validMovesBoard = getBoardWithValidMoves(board, playerTile)
+                #    drawBoard(validMovesBoard)
+                #else:
+                    #drawBoard(board)
+                #printScore(board, playerTile, computerTile)
+
+                move = getComputerMove(board, playerTile)
+                #if move == 'quit':
+                #    print('Thanks for playing!')
+                #    sys.exit() # Terminate the program.
+                #elif move == 'hints':
+                #    showHints = not showHints
+                #    continue
+                #else:
+                makeMove(board, playerTile, move[0], move[1])
+            turn = 'computer'
+
+        elif turn == 'computer': # Computer's turn
+            if computerValidMoves != []:
+                #drawBoard(board)
+                #printScore(board, playerTile, computerTile)
+
+                #input('Press Enter to see the computer\'s move.')
+                move = getComputerMove(board, computerTile)
+                makeMove(board, computerTile, move[0], move[1])
+            turn = 'player'
+
+NUM_GAMES = 250
+xWins = oWins = ties = 0
+print('Приветствуем в игре "Реверси"!')
+ans = input("Вам показывать процесс или нет? д/н     ")
+if ans == "д":
+    pokaz = True
+else:
+    pokaz = False
+
+playerTile, computerTile = ['Х', 'О'] #enterPlayerTile()
+
+for i in range(NUM_GAMES): #while True:
+    finalBoard = playGame(playerTile, computerTile)
+
+    # Display the final score.
+    #drawBoard(finalBoard)
+    scores = getScoreOfBoard(finalBoard)
+    if pokaz == True:
+        print('X набрал %s очков. O набрал %s очков.' % (scores['Х'], scores['О']))
+        if scores[playerTile] > scores[computerTile]:
+            xWins += 1 #print('You beat the computer by %s points! Congratulations!' % (scores[playerTile] - scores[computerTile]))
+        elif scores[playerTile] < scores[computerTile]:
+            oWins += 1 #print('You lost. The computer beat you by %s points.' % (scores[computerTile] - scores[playerTile]))
+        else:
+            ties += 1 #print('The game was a tie!')
+
+    else:
+        if scores[playerTile] > scores[computerTile]:
+            xWins += 1  # print('You beat the computer by %s points! Congratulations!' % (scores[playerTile] - scores[computerTile]))
+        elif scores[playerTile] < scores[computerTile]:
+            oWins += 1  # print('You lost. The computer beat you by %s points.' % (scores[computerTile] - scores[playerTile]))
+        else:
+            ties += 1  # print('The game was a tie!')
+
+
+    #print('Do you want to play again? (yes or no)')
+    #if not input().lower().startswith('y'):
+    #    break
+
+print('X победил: %s (%s%%)' % (xWins, round(xWins / NUM_GAMES * 100, 1)))
+print('O победил: %s (%s%%)' % (oWins, round(oWins / NUM_GAMES * 100, 1)))
+print('Ничьи:   %s (%s%%)' % (ties, round(ties / NUM_GAMES * 100, 1)))

reversi/playerVScomputer/reversi.py

@@ -0,0 +1,259 @@
+# "Реверси": клон "Отелло".
+import random
+import sys
+WIDTH = 8 # Игровое поле содержит 8 клеток по ширине.
+HEIGHT = 8 # Игровое поле содержит 8 клеток по высоте.
+def drawBoard(board):
+    # Вывести игровое поле, переданное этой функции. Ничего не возвращать.
+    print('  12345678')
+    print(' +--------+')
+    for y in range(HEIGHT):
+        print('%s|' % (y+1), end='')
+        for x in range(WIDTH):
+            print(board[x][y], end='')
+        print('|%s' % (y+1))
+    print(' +--------+')
+    print('  12345678')
+
+def getNewBoard():
+    # Создать структуру данных нового чистого игрового поля.
+    board = []
+    for i in range(WIDTH):
+        board.append([' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '])
+    return board
+
+def isValidMove(board, tile, xstart, ystart):
+    # Вернуть False, если ход игрока в клетку с координатами xstart, ystart — недопустимый.
+    # Если это допустимый ход, вернуть список клеток, которые "присвоил" бы игрок, если бы сделал туда ход.
+    if board[xstart][ystart] != ' ' or not isOnBoard(xstart, ystart):
+        return False
+
+    if tile == 'Х':
+        otherTile = 'О'
+    else:
+        otherTile = 'Х'
+
+    tilesToFlip = []
+    for xdirection, ydirection in [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
+        x, y = xstart, ystart
+        x += xdirection # Первый шаг в направлении x
+        y += ydirection # Первый шаг в направлении y
+        while isOnBoard(x, y) and board[x][y] == otherTile:
+            # Продолжать двигаться в этом направлении x и y.
+            x += xdirection
+            y += ydirection
+            if isOnBoard(x, y) and board[x][y] == tile:
+            #Естьфишки,которыеможноперевернуть.Двигатьсявобратномнаправлениидодостиженияисходнойклетки,отмечаявсефишкинаэтомпути.
+                while True:
+                    x -= xdirection
+                    y -= ydirection
+                    if x == xstart and y == ystart:
+                        break
+                    tilesToFlip.append([x, y])
+
+    if len(tilesToFlip) == 0: # Если ни одна из фишек не перевернулась, это недопустимый ход
+        return False
+    return tilesToFlip
+
+def isOnBoard(x, y):
+# Вернуть True, если координаты есть на игровом поле.
+    return x >= 0 and x <= WIDTH - 1 and y >= 0 and y <= HEIGHT - 1
+
+def getBoardWithValidMoves(board, tile):
+    # Вернуть новое поле с точками, обозначающими допустимые ходы, которые может сделать игрок.
+    boardCopy = getBoardCopy(board)
+
+    for x, y in getValidMoves(boardCopy, tile):
+        boardCopy[x][y] = '.'
+    return boardCopy
+
+def getValidMoves(board, tile):
+    # Вернуть список списков с координатами x и y допустимых ходов для данного игрока на данном игровом поле.
+    validMoves = []
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            if isValidMove(board, tile, x, y) != False:
+                validMoves.append([x, y])
+    return validMoves
+
+def getScoreOfBoard(board):
+# Определить количество очков, подсчитав фишки. Вернуть словарь с ключами 'Х' и 'О'.
+    xscore = 0
+    oscore = 0
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            if board[x][y] == 'Х':
+                xscore += 1
+            if board[x][y] == 'О':
+                oscore += 1
+    return {'Х':xscore, 'О':oscore}
+
+def enterPlayerTile():
+    # Позволить игроку ввести выбранную фишку.
+    # Возвращает список с фишкой игрока в качестве первого элемента и фишкой компьютера в качестве второго.
+    tile = ''
+    while not (tile == 'Х' or tile == 'О'):
+        print('Вы играете за Х или О?')
+        tile = input().upper()
+
+    # Первый элемент в списке — фишка игрока, второй элемент — фишка компьютера.
+    if tile == 'Х':
+        return ['Х', 'О']
+    else:
+        return ['О', 'Х']
+
+def whoGoesFirst():
+    # Случайно выбрать, кто ходит первым.
+    if random.randint(0, 1) == 0:
+        return 'Компьютер'
+    else:
+        return 'Человек'
+
+def makeMove(board, tile, xstart, ystart):
+    # Поместить фишку на игровое поле в позицию xstart, ystart и перевернуть какую-либо фишку противника.
+    # Вернуть False, если это недопустимый ход; вернуть True, если допустимый.
+    tilesToFlip = isValidMove(board, tile, xstart, ystart)
+
+    if tilesToFlip == False:
+        return False
+
+    board[xstart][ystart] = tile
+    for x, y in tilesToFlip:
+        board[x][y] = tile
+    return True
+
+def getBoardCopy(board):
+# Сделать копию списка board и вернуть ее.
+    boardCopy = getNewBoard()
+
+    for x in range(WIDTH):
+        for y in range(HEIGHT):
+            boardCopy[x][y] = board[x][y]
+
+    return boardCopy
+
+def isOnCorner(x, y):
+    # Вернуть True, если указанная позиция находится в одном из четырех углов.
+    return (x == 0 or x == WIDTH - 1) and (y == 0 or y == HEIGHT - 1)
+
+def getPlayerMove(board, playerTile):
+    # Позволить игроку ввести свой ход.
+    # Вернуть ход в виде [x, y] (или вернуть строки 'подсказка' или 'выход').
+    DIGITS1TO8 = '1 2 3 4 5 6 7 8'.split()
+    while True:
+        print('Укажите ход, текст "выход" для завершения игры или "подсказка" для вывода подсказки.')
+        move = input().lower()
+        if move == 'выход' or move == 'подсказка':
+            return move
+
+        if len(move) == 2 and move[0] in DIGITS1TO8 and move[1] in DIGITS1TO8:
+            x = int(move[0]) - 1
+            y = int(move[1]) - 1
+            if isValidMove(board, playerTile, x, y) == False:
+                continue
+            else:
+                break
+        else:
+            print('Это недопустимый ход. Введите номер столбца (1-8) и номер ряда (1-8).')
+            print('К примеру, значение 81 перемещает в верхний правый угол.')
+
+    return [x, y]
+
+def getComputerMove(board, computerTile):
+    # Учитывая данное игровое поле и данную фишку компьютера, определить,
+    # куда сделать ход, и вернуть этот ход в виде списка [x, y].
+    possibleMoves = getValidMoves(board, computerTile)
+    random.shuffle(possibleMoves) # Сделать случайным порядок ходов
+
+    # Всегда делать ход в угол, если это возможно.
+    for x, y in possibleMoves:
+        if isOnCorner(x, y):
+            return [x, y]
+
+    # Найти ход с наибольшим возможным количеством очков.
+    bestScore = -1
+    for x, y in possibleMoves:
+        boardCopy = getBoardCopy(board)
+        makeMove(boardCopy, computerTile, x, y)
+        score = getScoreOfBoard(boardCopy)[computerTile]
+        if score > bestScore:
+            bestMove = [x, y]
+            bestScore = score
+    return bestMove
+
+def printScore(board, playerTile, computerTile):
+    scores = getScoreOfBoard(board)
+    print('Ваш счет: %s. Счет компьютера: %s.' % (scores[playerTile], scores[computerTile]))
+
+def playGame(playerTile, computerTile):
+    showHints = False
+    turn = whoGoesFirst()
+    print(turn + ' ходит первым.')
+
+    # Очистить игровое поле и выставить стартовые фишки.
+    board = getNewBoard()
+    board[3][3] = 'Х'
+    board[3][4] = 'О'
+    board[4][3] = 'О'
+    board[4][4] = 'Х'
+
+    while True:
+        playerValidMoves = getValidMoves(board, playerTile)
+        computerValidMoves = getValidMoves(board, computerTile)
+
+        if playerValidMoves == [] and computerValidMoves == []:
+            return board # Ходов нет ни у кого, так что окончить игру.
+
+        elif turn == 'Человек': # Ход человека
+            if playerValidMoves != []:
+                if showHints:
+                    validMovesBoard = getBoardWithValidMoves(board, playerTile)
+                    drawBoard(validMovesBoard)
+                else:
+                    drawBoard(board)
+                printScore(board, playerTile, computerTile)
+
+                move = getPlayerMove(board, playerTile)
+                if move == 'выход':
+                    print('Благодарим за игру!')
+                    sys.exit() # Завершить работу программы.
+                elif move == 'подсказка':
+                    showHints = not showHints
+                    continue
+                else:
+                    makeMove(board, playerTile, move[0], move[1])
+            turn = 'Компьютер'
+
+        elif turn == 'Компьютер': # Ход компьютера
+            if computerValidMoves != []:
+                drawBoard(board)
+                printScore(board, playerTile, computerTile)
+
+                input('Нажмите клавишу Enter для просмотра хода компьютера.')
+                move = getComputerMove(board, computerTile)
+                makeMove(board, computerTile, move[0], move[1])
+            turn = 'Человек'
+
+
+
+print('Приветствуем в игре "Реверси"!')
+
+playerTile, computerTile = enterPlayerTile()
+
+while True:
+    finalBoard = playGame(playerTile, computerTile)
+
+    # Отобразить итоговый счет.
+    drawBoard(finalBoard)
+    scores = getScoreOfBoard(finalBoard)
+    print('X набрал %s очков. O набрал %s очков.' % (scores['Х'], scores['О']))
+    if scores[playerTile] > scores[computerTile]:
+        print('Вы победили компьютер, обогнав его на %s очков! Поздравления!' % (scores[playerTile] - scores[computerTile]))
+    elif scores[playerTile] < scores[computerTile]:
+        print('Вы проиграли. Компьютер победил вас, обогнав на %s очков.' % (scores[computerTile] - scores[playerTile]))
+    else:
+        print('Ничья!')
+
+    print('Хотите сыграть еще раз? (да или нет)')
+    if not input().lower().startswith('д'):
+        break

shutki/shutki.py

@@ -0,0 +1,16 @@
+print('Что получится, если скрестить снеговика с вампиром?')
+input()
+print('Обморожение!')
+print()
+print('Что дантисты называют \'черной дырой\'?')
+input()
+print('Кариес!')
+print()
+print('Тук-тук.')
+input()
+print("Кто там?")
+input()
+print('Перебивающая корова.')
+input()
+print('Перебивающая кор...', end='')
+print('-МУУУ!')

sokrovisha/ohotnikZaSokrovishami.py

@@ -0,0 +1,206 @@
+# Охотник за сокровищами
+
+import random
+import sys
+import math
+
+def getNewBoard():
+    # Создать структуру данных нового игрового поля размером 60х15.
+    board = []
+    for x in range(60): # Главный список из 60 списков.
+        board.append([])
+        for y in range(15): # Каждый список в главном списке содержит 15 односимвольных строк.
+# Для создания океана используем разные символы, чтобы сделать его реалистичнее.
+            if random.randint(0, 1) == 0:
+                board[x].append('~')
+            else:
+                board[x].append('`')
+
+    return board
+
+def drawBoard(board):
+# Изобразить структуру данных игрового поля.
+    tensDigitsLine = ' ' # Создать место для чисел вниз по левой стороне поля.
+    for i in range(1, 6):
+        tensDigitsLine += (' ' * 9) + str(i)
+    # Вывести числа в верхней части поля.
+    print(tensDigitsLine)
+    print('' + ('0123456789' * 6))
+    print()
+    # Вывести каждый из 15 рядов.
+    for row in range(15):
+        # К однозначным числам нужно добавить дополнительный пробел.
+        if row < 10:
+            extraSpace = ' '
+        else:
+            extraSpace = ''
+
+
+        # Создать строку для этого ряда на игровом поле.
+        boardRow = ''
+        for column in range(60):
+            boardRow += board[column][row]
+        print('%s%s %s %s' % (extraSpace, row, boardRow, row))
+    # Вывести числа в нижней части поля.
+    print()
+    print('' + ('0123456789' * 6))
+    print(tensDigitsLine)
+
+
+def getRandomChests(numChests):
+    # Создать список структур данных сундука (двухэлементные списки целочисленных координат x и y)).
+    chests = []
+    while len(chests) < numChests:
+        newChest = [random.randint(0, 59), random.randint(0, 14)]
+        if newChest not in chests: # Убедиться, что сундука здесь еще нет.
+            chests.append(newChest)
+    return chests
+
+
+def isOnBoard(x, y):
+    # Возвращать True, если координаты есть на поле; в противном случае возвращать False.
+    return x >= 0 and x <= 59 and y >= 0 and y <= 14
+
+def makeMove(board, chests, x, y):
+    # Изменить структуру данных поля, используя символ гидролокатора. Удалить сундуки
+    # с сокровищами из списка с сундуками, как только их нашли. Вернуть False, если это
+    # недопустимый ход. В противном случае, вернуть строку с результатом этого хода.
+    smallestDistance = 100 # Все сундуки будут расположены ближе, чем на расстоянии в 100 единиц.
+    for cx, cy in chests:
+        distance = math.sqrt((cx - x) * (cx - x) + (cy - y) * (cy - y))
+
+    if distance < smallestDistance: # Нам нужен ближайший сундук с сокровищами.
+        smallestDistance = distance
+
+    smallestDistance = round(smallestDistance)
+
+    if smallestDistance == 0:
+        # Координаты xy попали прямо в сундук с сокровищами!
+        chests.remove([x, y])
+        return 'Вы нашли сундук с сокровищами на затонувшем судне!'
+    else:
+        if smallestDistance < 10:
+            board[x][y] = str(smallestDistance)
+            return 'Сундук с сокровищами обнаружен на расстоянии %s от гидролокатора.' % (smallestDistance)
+        else:
+            board[x][y] = 'Х'
+            return 'Гидролокатор ничего не обнаружил. Все сундуки с сокровищами вне пределов досягаемости.'
+
+def enterPlayerMove(previousMoves):
+    # Позволить игроку сделать ход. Вернуть двухэлементный список с целыми координатами x и y.
+    print('Где следует опустить гидролокатор? (координаты: 0-59 0-14) (или введите "выход")')
+    while True:
+        move = input()
+        if move.lower() == 'выход':
+            print('Спасибо за игру!')
+            sys.exit()
+
+        move = move.split()
+        if len(move) == 2 and move[0].isdigit() and move[1].isdigit() and isOnBoard(int(move[0]), int(move[1])):
+            if [int(move[0]), int(move[1])] in previousMoves:
+                print('Здесь вы уже опускали гидролокатор.')
+                continue
+            return [int(move[0]), int(move[1])]
+
+        print('Введите число от 0 до 59, потом пробел, а затем число от 0 до 14.')
+
+def showInstructions():
+    print('''Инструктаж:
+Вы - капитан корабля, плывущего за сокровищами. Ваша задача - с помощью
+гидролокаторов найти три сундука с сокровищами в затонувших судах на дне океана.
+Но гидролокаторы очень просты и определяют только расстояние, но не направление.
+Введите координаты, чтобы опустить гидролокатор в воду. На карте будет показано
+число, обозначающее, на каком расстоянии находится ближайший сундук. Или будет
+показана буква Х, обозначающая, что сундук в области действия гидролокатора неИгра «Охотник за сокровищами» 225
+обнаружен. На карте ниже метки C - это сундуки.
+Цифра 3 обозначает, что ближайший сундук находится на отдалении в 3 единицы.
+
+          1         2         3
+012345678901234567890123456789012
+
+0 ~~~~`~```~`~``~~~``~`~~``~~~``~`~ 0
+1 ~`~`~``~~`~```~~~```~~`~`~~~`~~~~ 1
+2 `~`C``3`~~~~`C`~~~~`````~~``~~~`` 2
+3 ````````~~~`````~~~`~`````~`~``~` 3
+4 ~`~~~~`~~`~~`C`~``~~`~~~`~```~``~ 4
+
+012345678901234567890123456789012
+           1        2         3
+(Во время игры сундуки на карте не обозначаются!)
+
+Нажмите клавишу Enter, чтобы продолжить...''')
+    input()
+
+    print('''Если гидролокатор опущен прямо на сундук, вы сможете поднять
+сундук. Другие гидролокаторы обновят данные о расположении ближайшего сундука.
+Сундуки ниже находятся вне диапазона локатора, поэтому отображается буква X.
+
+          1         2         3
+012345678901234567890123456789012
+
+0 ~~~~`~```~`~``~~~``~`~~``~~~``~`~ 0
+1 ~`~`~``~~`~```~~~```~~`~`~~~`~~~~ 1
+2 `~`X``7`~~~~`C`~~~~`````~~``~~~`` 2
+3 ````````~~~`````~~~`~`````~`~``~` 3
+4 ~`~~~~`~~`~~`C`~``~~`~~~`~```~``~ 4
+
+012345678901234567890123456789012
+          1         2         3
+
+Сундуки с сокровищами не перемещаются. Гидролокаторы определяют сундуки
+на расстоянии до 9 единиц. Попробуйте поднять все 3 сундука до того, как все
+гидролокаторы будут опущены на дно. Удачи!
+
+Нажмите клавишу Enter, чтобы продолжить...''')
+    input()
+
+
+print('О х о т н и к  з а  с о к р о в и щ а м и !')
+print()
+print('Показать инструктаж? (да/нет)  ')
+if input().lower().startswith('д'):
+    showInstructions()
+
+while True:
+    # Настройка игры
+    sonarDevices = 20
+    theBoard = getNewBoard()
+    theChests = getRandomChests(3)
+    drawBoard(theBoard)
+    previousMoves = []
+
+
+    while sonarDevices > 0:
+    # Показать гидролокаторные устройства и сундуки с сокровищами.
+        print("Осталось гидролокаторов: %s Осталось сундуков с сокровищами: %s" % (sonarDevices, len(theChests)))
+
+        x, y = enterPlayerMove(previousMoves)
+        previousMoves.append([x, y]) # Мы должны отслеживать все ходы, чтобы гидролокаторы могли обновляться.
+
+        moveResult = makeMove(theBoard, theChests, x, y)
+        if moveResult == False:
+            continue
+        else:
+            if moveResult == 'Вы нашли сундук с сокровищами на затонувшем судне!':
+            # Обновить все гидролокаторные устройства, в настоящее время находящиеся на карте.
+                for x, y in previousMoves:
+                    makeMove(theBoard, theChests, x, y)
+            drawBoard(theBoard)
+            print(moveResult)
+
+        if len(theChests) == 0:
+            print('Вы нашли все сундуки с сокровищами на затонувших судах! Поздравляем и приятной игры!')
+            break
+
+        sonarDevices -= 1
+
+        if sonarDevices == 0:
+            print('Все гидролокаторы опущены на дно! Придется разворачивать корабль и')
+            print('отправляться домой, в порт! Игра окончена.')
+            print('Вы не нашли сундуки в следующих местах:')
+            for x, y in theChests:
+                print(' %s, %s' % (x, y))
+
+    print('Хотите сыграть еще раз? (да или нет)')
+    if not input().lower().startswith('д'):
+        sys.exit()

tests/testClassAnimals.py

@@ -0,0 +1,128 @@
+class Animal(object):
+    def __init__(self):
+        pass
+
+    def voice(self):
+        pass
+
+    def move(self):
+        pass
+    def size(self, weight, length):
+        self.weight = weight
+        self.length = length
+
+    def age(self, age):
+        self.age = age
+
+class Mammal(Animal):
+    def __init__(self):
+        pass
+    def move(self):
+        print("run")
+
+class Fish(Animal):
+    def __init__(self):
+        super(self)
+
+    def voice(self):
+        print(".......")
+
+    def move(self):
+        print("swim")
+
+class Bird(Animal):
+    def __init__(self):
+        super(self)
+
+    def move(self):
+        print("fly")
+
+
+class Cat(Mammal):
+    def __init__(self, name):
+        self.name = name
+
+    def voice(self):
+        print("meow")
+
+
+class Dog(Mammal):
+    def __init__(self, name):
+        self.name = name
+    def voice(self):
+        print("bark")
+
+
+class Platypuss(Mammal):
+    def __init__(self, name):
+        self.name = name
+    def move(self):
+        print("run, swim")
+    def voice(self):
+        print("RRRRRRRRRR")
+
+
+class Duck(Bird):
+    def __init__(self):
+        pass
+    def voice(self):
+        print("kraaaa")
+    def move(self):
+        print("fly, swim")
+
+class Penguin(Bird):
+    def __init__(self):
+        pass
+
+    def voice(self):
+        print("ar")
+
+    def move(self):
+        print("go, swim")
+
+class Shark(Fish):
+    def __init__(self):
+        pass
+
+class Flyfish(Fish):
+    def __init__(self):
+        pass
+    def move(self):
+        print("swim, fly")
+
+cat = Cat("Barsik")
+dog = Dog("Sharik")
+platypuss = Platypuss("Perry")
+duck = Duck()
+penguin = Penguin()
+shark = Shark()
+flyfish = Flyfish()
+
+print("cat")
+cat.voice()
+cat.move()
+
+print("dog")
+dog.voice()
+dog.move()
+
+print("platypuss")
+platypuss.voice()
+platypuss.move()
+
+print("duck")
+duck.voice()
+duck.move()
+
+print("penguin")
+penguin.voice()
+penguin.move()
+
+print("shark")
+shark.voice()
+shark.move()
+
+print("flyfish")
+flyfish.voice()
+flyfish.move()
+

tests/testGovnokod.py

@@ -0,0 +1,51 @@
+i = 1
+print(10-i)
+
+i = "meow"
+print(i)
+
+i = True
+print(i)
+
+i = ["meow", 1, True]
+print(i)
+
+i = {"cat": 1, "meow": 2, True: False}
+print(i)
+print(i["cat"])
+print(i[True])
+
+i = (3, 5)
+print(i)
+print(i[1], i[0])
+
+class Cat(object):
+    def __init__(self, name):
+        self.name = name
+    def voice(self):
+        print("meow")
+
+class Dog(object):
+    def __init__(self, name):
+        self.name = name
+    def voice(self):
+        print("bark")
+
+class Animal:
+    def __init__(self):
+        pass
+    def voice(self):
+        print("Abstract RRRR!")
+
+i = Cat("Barsik")
+i.voice()
+
+i = Dog("Sharik")
+i.voice()
+
+i = Animal()
+i.voice()
+
+# list = [1, 2, 3]
+# print(list)
+# i, c, f = 1, 2, 3

ugadaiChislo/ugadaiChislo.py

@@ -0,0 +1,31 @@
+ # Это игра по угадыванию чисел.
+import random
+
+guessesTaken = 0
+print('Привет! Как тебя зовут?   ')
+myName = input()
+
+number = random.randint(1, 20)
+print('Что ж, ' + myName + ', я загадываю число от 1 до 20.')
+
+for guessesTaken in range(6):
+    print('Попробуй угадать.') # Четыре пробела перед именем функции print
+    guess = input()
+    guess = int(guess)
+
+    if guess < number:
+        print('Твое число слишком маленькое.') # Восемь пробелов перед именем функции print
+
+    if guess > number:
+        print('Твое число слишком большое.')
+
+    if guess == number:
+        break
+
+if guess == number:
+    guessesTaken = str(guessesTaken + 1)
+    print('Отлично, ' + myName + '! Ты справился за ' + guessesTaken + ' попыток(у)(и)!')
+
+if guess != number:
+    number = str(number)
+    print('Увы. Я загадал число ' + number + '.')

viselitsa/viselitsa.py

@@ -0,0 +1,127 @@
+import random
+HANGMAN_PICS = ['''
+
+    |
+    |
+    |
+   ===''', '''
++---+
+    |
+    |
+    |
+   ===''', '''
++---+
+0   |
+|   |
+    |
+   ===''', '''
++---+
+ 0  |
+/|  |
+    |
+===''', '''
++---+
+ 0  |
+/|\ |
+    |
+   ===''', '''
++---+
+ 0  |
+/|\ |
+/   |
+   ===''', '''
++---+
+ 0  |
+/|\ |
+/ \ |
+   ===''']
+words = 'аист акула бабуин баран барсук барсик бобр бык верблюд волк воробей ворон выдра голубь гусь жаба зебра змея индюк кит кобра коза козел койот корова кошка кролик крыса курица лама ласка лебедь лев лиса лосось лось лягушка медведь моллюск моль мул муравей мышь норка носорог обезьяна овца окунь олень орел осел панда паук питон попугай пума семга скунс собака сова тигр тритон тюлень утка утконос форель хорек черепаха ястреб ящерица'.split()
+
+def getRandomWord(wordList):
+    # Эта функция возвращает случайную строку из переданного списка.
+    wordIndex = random.randint(0, len(wordList) - 1)
+    return wordList[wordIndex]
+
+def displayBoard(missedLetters, correctLetters, secretWord):
+    print(HANGMAN_PICS[len(missedLetters)])
+    print()
+
+    print('Ты пробовал буквы:', end=' ')
+    for letter in missedLetters:
+        print(letter, end=' ')
+    print()
+
+    blanks = '_' * len(secretWord)
+
+    for i in range(len(secretWord)): # заменяет пропуски отгаданными буквами
+        if secretWord[i] in correctLetters:
+            blanks = blanks[:i] + secretWord[i] + blanks[i+1:]
+
+    for letter in blanks: # Показывает секретное слово с пробелами между буквами
+        print(letter, end=' ')
+    print()
+
+def getGuess(alreadyGuessed):
+# Возвращает букву, введенную игроком. Эта функция проверяет, что игрок ввел только одну букву и ничего больше.
+    while True:
+        print('Введите букву из слова(подсказка: это животное).')
+        guess = input()
+        guess = guess.lower()
+        if len(guess) != 1:
+            print('Пожалуйста, введите одну букву.')
+        elif guess in alreadyGuessed:
+            print('Вы уже называли эту букву. Назовите другую.')
+        elif guess not in 'абвгдеежзийклмнопрстуфхцчшщъыьэюя':
+            print('Пожалуйста, введите БУКВУ.')
+        else:
+            return guess
+
+def playAgain():
+    # Эта функция возвращает значение True, если игрок хочет сыграть заново; в противном случае возвращает False.
+    print('Хотите сыграть еще? (да или нет)')
+    return input().lower().startswith('д')
+
+
+print('В И С Е Л И Ц А')
+missedLetters = ''
+correctLetters = ''
+secretWord = getRandomWord(words)
+gameIsDone = False
+
+while True:
+    displayBoard(missedLetters, correctLetters, secretWord)
+
+    # Позволяет игроку ввести букву.
+    guess = getGuess(missedLetters + correctLetters)
+
+    if guess in secretWord:
+        correctLetters = correctLetters + guess
+
+
+        # Проверяет, выиграл ли игрок.
+        foundAllLetters = True
+        for i in range(len(secretWord)):
+            if secretWord[i] not in correctLetters:
+                foundAllLetters = False
+                break
+        if foundAllLetters:
+            print('ДА! Секретное слово - "' + secretWord + '"! Вы угадали!')
+            gameIsDone = True
+    else:
+        missedLetters = missedLetters + guess
+
+    # Проверяет, превысил ли игрок лимит попыток и проиграл.
+    if len(missedLetters) == len(HANGMAN_PICS) - 1:
+        displayBoard(missedLetters, correctLetters, secretWord)
+        print('Вы исчерпали все попытки!\nНе угадано букв:'+str(len(missedLetters))+'и угадано букв:'+str(len(correctLetters))+'.Было загадано слово"'+secretWord+'".')
+        gameIsDone = True
+
+    # Запрашивает, хочет ли игрок сыграть заново (только если игра завершена).
+    if gameIsDone:
+        if playAgain():
+            missedLetters = ''
+            correctLetters = ''
+            gameIsDone = False
+            secretWord = getRandomWord(words)
+        else:
+            break

viselitsa/viselitsa2.py

@@ -0,0 +1,158 @@
+import random
+HANGMAN_PICS = ['''
+
+    |
+    |
+    |
+   ===''', '''
++---+
+    |
+    |
+    |
+   ===''', '''
++---+
+0   |
+|   |
+    |
+   ===''', '''
++---+
+ 0  |
+/|  |
+    |
+===''', '''
++---+
+ 0  |
+/|\ |
+    |
+   ===''', '''
++---+
+ 0  |
+/|\ |
+/   |
+   ===''', '''
++---+
+ 0  |
+/|\ |
+/ \ |
+   ===''', '''
++---+
+[O   |
+/|\  |
+/ \  |
+    ===''', '''
+ +---+
+[O]  |
+/|\  |
+/ \  |
+    ===''']
+
+#words = {'Цвета':'красный оранжевый желтый зеленый синий голубой фиолетовый белый черный коричневый'.split(),'Фигуры':'квадрат треугольник прямоугольник круг эллипс ромб трапеция пятиугольник шестиугольник восьмиугольник'.split(),'Фрукты':'яблоко апельсин лимон лайм груша мандарин виноград грейпфрут персик банан абрикос манго банан нектарин'.split(),'Животные':'аист акула бабуин баран барсук барсик бобр бык верблюд волк воробей ворон выдра голубь гусь жаба зебра змея индюк кит кобра коза козел койот корова кошка кролик крыса курица лама ласка лебедь лев лиса лосось лось лягушка медведь моллюск моль мул муравей мышь норка носорог обезьяна овца окунь олень орел осел панда паук питон попугай пума семга скунс собака сова тигр тритон тюлень утка утконос форель хорек черепаха ястреб ящерица'.split()}
+words = {'Цвета':'красный оранжевый желтый зеленый синий голубой фиолетовый белый черный коричневый'.split(),
+'Фигуры':'квадрат треугольник прямоугольник круг эллипс ромб трапеция параллелограмм пятиугольник шестиугольник восьмиугольник'.split(),
+'Фрукты':'яблоко апельсин лимон лайм груша мандарин виноград грейпфрут персик банан абрикос манго банан нектарин'.split(),
+'Животные':'аист бабуин баран барсук бык волк зебра кит коза корова кошка кролик крыса лев лиса лось медведь мул мышь норка носорог обезьяна овца олень осел панда пума скунс собака сова тигр тюлень хорек ящерица'.split()}
+
+def getRandomWord(wordDict):
+    # Эта функция возвращает случайную строку из переданного списка.
+    wordKey = random.choice(list(wordDict.keys()))
+    wordIndex = random.randint(0, len(wordDict[wordKey]) - 1)
+    return [wordDict[wordKey][wordIndex], wordKey]
+
+def displayBoard(missedLetters, correctLetters, secretWord):
+    print(HANGMAN_PICS[len(missedLetters)])
+    print()
+
+    print('Ты пробовал буквы:', end=' ')
+    for letter in missedLetters:
+        print(letter, end=' ')
+    print()
+
+    blanks = '_' * len(secretWord)
+
+    for i in range(len(secretWord)): # заменяет пропуски отгаданными буквами
+        if secretWord[i] in correctLetters:
+            blanks = blanks[:i] + secretWord[i] + blanks[i+1:]
+
+    for letter in blanks: # Показывает секретное слово с пробелами между буквами
+        print(letter, end=' ')
+    print()
+
+def getGuess(alreadyGuessed):
+# Возвращает букву, введенную игроком. Эта функция проверяет, что игрок ввел только одну букву и ничего больше.
+    while True:
+        print('Введите букву из слова.')
+        guess = input()
+        guess = guess.lower()
+        if len(guess) != 1:
+            print('Пожалуйста, введите одну букву.')
+        elif guess in alreadyGuessed:
+            print('Вы уже называли эту букву. Назовите другую.')
+        elif guess not in 'абвгдеежзийклмнопрстуфхцчшщъыьэюя':
+            print('Пожалуйста, введите БУКВУ.')
+        else:
+            return guess
+
+def playAgain():
+    # Эта функция возвращает значение True, если игрок хочет сыграть заново; в противном случае возвращает False.
+    print('Хотите сыграть еще? (да или нет)')
+    return input().lower().startswith('д')
+
+
+print('В И С Е Л И Ц А')
+
+difficulty = 'X'
+while difficulty not in 'ЛСТ':
+    print('Выберите уровень сложности: Л - Легкий, С - Средний, Т - Тяжелый')
+    difficulty = input().upper()
+if difficulty == 'С':
+    del HANGMAN_PICS[8]
+    del HANGMAN_PICS[7]
+if difficulty == 'Т':
+    del HANGMAN_PICS[8]
+    del HANGMAN_PICS[7]
+    del HANGMAN_PICS[5]
+    del HANGMAN_PICS[3]
+
+missedLetters = ''
+correctLetters = ''
+secretWord, secretSet = getRandomWord(words)
+gameIsDone = False
+
+while True:
+    print('Секретное слово из набора: ' + secretSet)
+    displayBoard(missedLetters, correctLetters, secretWord)
+
+    # Позволяет игроку ввести букву.
+    guess = getGuess(missedLetters + correctLetters)
+
+    if guess in secretWord:
+        correctLetters = correctLetters + guess
+
+
+    # Проверяет, выиграл ли игрок.
+        foundAllLetters = True
+        for i in range(len(secretWord)):
+            if secretWord[i] not in correctLetters:
+                foundAllLetters = False
+                break
+        if foundAllLetters:
+            print('ДА! Секретное слово - "' + secretWord + '"! Вы угадали!')
+            gameIsDone = True
+    else:
+        missedLetters = missedLetters + guess
+
+    # Проверяет, превысил ли игрок лимит попыток и проиграл.
+        if len(missedLetters) == len(HANGMAN_PICS) - 1:
+            displayBoard(missedLetters, correctLetters, secretWord)
+            print('Вы исчерпали все попытки!\nНе угадано букв:'+str(len(missedLetters))+'и угадано букв:'+str(len(correctLetters))+'.Было загадано слово"'+secretWord+'".')
+            gameIsDone = True
+
+    # Запрашивает, хочет ли игрок сыграть заново (только если игра завершена).
+    if gameIsDone:
+        if playAgain():
+            missedLetters = ''
+            correctLetters = ''
+            gameIsDone = False
+            secretWord, secretSet = getRandomWord(words)
+        else:
+            break