legendary/pythonCoolGames
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
BarsTigerMeowcat
2020-01-26 12:46:16 +02:00
commit b01c9d869f
24 changed files with 2054 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

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

2
.idea/.gitignore generated vendored Normal file
View File

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

4
.idea/misc.xml generated Normal file
View File

@@ -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>

8
.idea/modules.xml generated Normal file
View File

@@ -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>

10
.idea/pythonCoolGames.iml generated Normal file
View File

@@ -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>

52
cipher/cipher.py Normal file
View File

@@ -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))

52
cipher/cipher2.py Normal file
View File

@@ -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))

58
cipher/cipher2AndHack.py Normal file
View File

@@ -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))

58
cipher/cipherAndHack.py Normal file
View File

@@ -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))

20
coinFlips/flips.py Normal file
View File

@@ -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('Насколько вы близки к правильному ответу?')

42
drakoni/drakoni.py Normal file
View File

@@ -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()

72
goracho-holodno/goracho-holodno.py Normal file
View File

@@ -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

175
krestiki-noliki/krestiki-noliki.py Normal file
View File

@@ -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

2
notes Normal file
View File

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

243
reversi/computerVScomputer/AISim1.py Normal file
View File

@@ -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

278
reversi/computerVScomputer/AISim2.py Normal file
View File

@@ -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)))

259
reversi/playerVScomputer/reversi.py Normal file
View File

@@ -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

16
shutki/shutki.py Normal file
View File

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

206
sokrovisha/ohotnikZaSokrovishami.py Normal file
View File

@@ -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()

128
tests/testClassAnimals.py Normal file
View File

@@ -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()

51
tests/testGovnokod.py Normal file
View File

@@ -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

31
ugadaiChislo/ugadaiChislo.py Normal file
View File

@@ -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 + '.')

127
viselitsa/viselitsa.py Normal file
View File

@@ -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

158
viselitsa/viselitsa2.py Normal file
View File

@@ -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