Add partial exercise 10

This commit is contained in:
h7x4 2020-11-10 23:56:21 +01:00
parent 1c10a0fd83
commit 4335edea97
6 changed files with 264 additions and 1 deletions

3
.gitignore vendored
View File

@ -1,3 +1,4 @@
__pycache__
.vscode
.vscode
.vim

17
Exercise 10/1.py Normal file
View File

@ -0,0 +1,17 @@
from math import floor
recursive_sum = lambda n: 1 if n == 1 else n + recursive_sum(n - 1)
merge_sum = lambda lst: lst[0] if len(lst) == 1 else merge_sum(lst[0:floor(len(
lst) / 2)]) + merge_sum(lst[floor(len(lst) / 2):len(lst)])
def find_smallest_element(lst):
if len(lst) == 1: return lst[0]
smallest_element = find_smallest_element(lst[1:])
return lst[0] if lst[0] < smallest_element else smallest_element
def binary_search(numbers, element):
return -float('inf')

7
Exercise 10/2.py Normal file
View File

@ -0,0 +1,7 @@
from math import sin
import matplotlib.pyplot as plt
x_verdier = [x/10 for x in range(301)]
y_verdier = [sin(x) for x in x_verdier]
plt.plot(x_verdier, y_verdier, c='r')
plt.show()

131
Exercise 10/chess/board.py Normal file
View File

@ -0,0 +1,131 @@
from os import system
from piece import Piece
class Board:
def __init__(self):
self.boardArray = [
# [],
[Piece('p', 'black') for _ in range(8)],
[Piece('p', 'black') for _ in range(8)],
*[[None for _ in range(8)] for _ in range(4)],
[Piece('p', 'white') for _ in range(8)],
[Piece('p', 'white') for _ in range(8)],
# [],
]
def draw(
self,
config={
'highlightedContent': [],
'highlightEscapeCodes': ('\033[32;5;7m', '\033[0m'),
'highlightedBoxes': [],
'center': False
}
) -> str:
"""Returns a string representing the board
config options:
highlightedContent: [(x,y)] - Pieces to color
highlightEscapeCodes: (str, str) - Terminal escape codes to color highlightedContent with
highlightedBoxes: [(x,y)] - Boxes to make bold
center: Bool - Whether or not to indent the board into the center
"""
def fillConfigDefaultValue(key, defaultValue):
if key not in config:
config[key] = defaultValue
fillConfigDefaultValue('highlightedContent', [])
fillConfigDefaultValue('highlightedBoxes', [])
fillConfigDefaultValue('highlightEscapeCodes', ('\033[32;5;7m', '\033[0m'))
fillConfigDefaultValue('center', False)
# Draw general outline
stringArray = [list('' + '───┼' * 8)] + [[None] for _ in range(8 * 2)]
for y, row in enumerate(self.boardArray):
for x, column in enumerate(row):
stringArray[2 * y + 1][4 * x] = ''
stringArray[2 * y + 2][4 * x] = ''
stringArray[2 * y + 1] += list(
' {}'.format(str(self.boardArray[y][x]) if self.boardArray[y][x] != None else ' '))
stringArray[2 * y + 2] += list('───┼')
# Overwrite corners
stringArray[0][0] = ''
stringArray[0][-1] = ''
stringArray[-1][0] = ''
stringArray[-1][-1] = ''
# Overwrite T-junctions
for i in range(int(len(stringArray[0]) / 4) - 1):
stringArray[0][i * 4 + 4] = ''
stringArray[-1][i * 4 + 4] = ''
for i in range(int(len(stringArray) / 2) - 1):
stringArray[i * 2 + 2][0] = ''
stringArray[i * 2 + 2][-1] = ''
def highlightContent(x, y):
"""highlight contents of a piece with xterm-256colors modifiers"""
stringArray[y * 2 +
1][x * 4 +
1] = config['highlightEscapeCodes'][0] + stringArray[y * 2 + 1][x * 4 + 1]
stringArray[y * 2 + 1][x * 4 + 3] += config['highlightEscapeCodes'][1]
def highlightBox(x, y):
"""Make box around a piece bold"""
characterMap = {
'': '',
'': '',
'': '',
'': '',
'': '',
'': '',
'': '',
'': '',
'': '',
'': '',
'': '',
}
pointsToChange = \
[(x * 4 + 0, y * 2 + i) for i in range(3)] + \
[(x * 4 + 4, y * 2 + i) for i in range(3)] + \
[(x * 4 + i, y * 2 + 0) for i in range(1,4)] + \
[(x * 4 + i, y * 2 + 2) for i in range(1,4)]
for x, y in pointsToChange:
stringArray[y][x] = characterMap[
stringArray[y][x]] if stringArray[y][x] in characterMap else stringArray[y][x]
for x, y in config['highlightedBoxes']:
highlightBox(x, y)
for x, y in config['highlightedContent']:
highlightContent(x, y)
# TODO: Center board
return '\n'.join([''.join(line) for line in stringArray])
def selectPiece(self, player) -> tuple:
"""Lets the user select a piece from a graphic board"""
x, y = 0, 0
while True:
system('clear')
print(player.name, '\n')
print(self.draw({'highlightedBoxes': [(x, y)]}), '\n')
key = input(f" W E\n A S D <- Enter : ")[0]
if key in ['s', 'j'] and y != 7: y += 1
elif key in ['w', 'k'] and y != 0: y -= 1
elif key in ['d', 'l'] and x != 7: x += 1
elif key in ['a', 'h'] and x != 0: x -= 1
elif key == 'e': return (x, y)
def getPieceAt(self, x, y) -> Piece:
return self.boardArray[y][x]

View File

@ -0,0 +1,33 @@
from board import Board
from os import system
from dataclasses import dataclass
@dataclass
class Player:
name: str
color: str
class Chess:
def __init__(self, players):
self.players = players
def update(self):
system('clear')
def loop(self):
while True:
self.update()
if __name__ == "__main__":
players = (
Player('Spiller 1', 'white'),
Player('Spiller 2', 'black'),
)
# game = Chess(('Spiller 1', 'Spiller 2'))
# game.loop()
board = Board()
print(board.selectPiece(players[0]))

View File

@ -0,0 +1,74 @@
from typing import Iterable, Callable
from itertools import product
class Piece:
def __init__(self, type, color):
self.type = type
self.color = color
def __str__(self):
return self.type.upper() if self.color == 'white' else self.type
@staticmethod
def possibleMoves(x, y, board) -> Callable[[int, int], Iterable[tuple]]:
piece = board.getPieceAt(x, y)
moves = []
pieceIsEnemyColor = lambda pieceToCheck: pieceToCheck != None and pieceToCheck.color != piece.color
pieceIsEmpty = lambda pieceToCheck: pieceToCheck == None
pieceIsEmptyOrEnemyColor = lambda pieceToCheck: pieceToCheck == None or pieceToCheck.color != piece.color
def addMoveIfTrue(xOffset, yOffset, condition):
if condition(board.getPieceAt(x + xOffset, y + yOffset)):
moves.append((x + xOffset, y + yOffset))
return True
return False
def addWhileInsideBoard(direction):
localX = x
localY = y
while localX not in [0, 7] and localY not in [0, 7]:
localX += direction[0]
localY += direction[1]
if board.getPieceAt(localX, localY) == None:
moves.append((localX, localY))
else:
if board.getPieceAt(localX, localY).color != piece.color:
moves.append((localX, localY))
return
if piece.type == 'p':
addMoveIfTrue(1, 1, pieceIsEnemyColor)
addMoveIfTrue(-1, 1, pieceIsEnemyColor)
if addMoveIfTrue(0, 1, pieceIsEmpty):
addMoveIfTrue(0, 2, lambda pieceToCheck: pieceToCheck == None and piece.moves == 0)
elif piece.type == 'n':
positions = [(-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)]
for position in positions:
addMoveIfTrue(*position, pieceIsEmptyOrEnemyColor)
elif piece.type == 'k':
positions = list(product([-1, 0, 1], repeat=2))
positions.remove((0, 0))
for position in positions:
addMoveIfTrue(*position, pieceIsEmptyOrEnemyColor)
# TODO: Check moves for check and remove the bad ones
elif piece.type == 'r':
for direction in product([0, 1], repeat=2):
addWhileInsideBoard(direction)
elif piece.type == 'b':
for direction in product([-1, 1], repeat=2):
addWhileInsideBoard(direction)
elif piece.type == 'q':
directions = list(product([-1, 0, 1], repeat=2))
directions.remove((0, 0))
for direction in directions:
addWhileInsideBoard(direction)
return moves