import pygame
import numpy as np
ALIVE = True
DEATH = False
LIVE_COLOR = (255, 255, 255)
DEATH_COLOR = (50, 50, 50)
OFFSET = 1

class GameofLife:
    def __init__(self, surface, width=1920, height=1080, scale=10):
        self.surface = surface
        self.width = width
        self.height = height
        self.scale = scale
        self.columns = int(height / scale)
        self.rows = int(width / scale)
        # The universe is a two-dimensional grid of cells, each of which is in one of two possible states: alive or dead.
        self.grid = np.random.randint(0, 2, size=(self.rows, self.columns), dtype=bool) # It generates a self.rows x self.columns two-dimensional array of booleans. 
        self.grid = np.where(self.grid==False, DEATH, ALIVE) # This line's purpose is to make the code easy to read.

    def draw_grid(self):
        """It draws the grid"""
        for row in range(self.rows):
            for col in range(self.columns):
                if self.grid[row, col]==ALIVE:
                    pygame.draw.rect(self.surface, LIVE_COLOR, [row * self.scale, col * self.scale, self.scale - OFFSET, self.scale - OFFSET])
                else:
                    pygame.draw.rect(self.surface, DEATH_COLOR, [row * self.scale, col * self.scale, self.scale - OFFSET, self.scale - OFFSET])
    
    def update_grid(self):
        """ It updates the grid using Conway's game of life rules."""
        updated_grid = copy.deepcopy(self.grid)
        for row in range(self.rows):
            for col in range(self.columns):
                updated_grid[row, col] = self.update_cell(row, col)

        self.grid = updated_grid

    def num_alive_neighbors(self, x, y):
        """ It returns the number of the cell's (self.grid[x, y]) neighbors that are alive."""
        alive_neighbors = 0
        for i in range(-1, 2):
            for j in range(-1, 2):
                if i == 0 and j == 0: # The cell does not count itself as a neighbour. I am not my neighbour!
                    continue
                elif (x+i)<0 or (x+i)>=self.rows or (y+j)<0 or (y+j)>=self.columns: # The "neighbour" cell needs to be on the grid.
                    continue
                elif self.grid[x + i, y + j]==ALIVE: # The "neighbour" cell needs to be alive.
                    alive_neighbors += 1
                
        return alive_neighbors

    def update_cell(self, x, y):
        """ It updates the cell based on Conway's game of life rules."""
        current_state = self.grid[x, y]
        alive_neighbors = self.num_alive_neighbors(x, y)
        
        # Any alive cell with fewer than 2 alive neighbor cells dies as if caused by solitude or isolation.
        if current_state==ALIVE and alive_neighbors < 2:                                       
            return False
        # Any alive cell with 2 or 3 alive neighbor cells survives, so it lives on to the next generation.
        elif current_state==ALIVE and (alive_neighbors == 2 or alive_neighbors == 3):        
            return True
        # Any alive cell with more than three alive neighbor cells dies, as if caused by overpopulation.
        elif current_state==ALIVE and alive_neighbors > 3:                                     
            return False
        # Any death cell with three alive neighbor cells becomes alive, as if caused by reproduction.
        elif current_state==DEATH and alive_neighbors == 3:                                  
            return True
        else:
            return current_state

import sys
import pygame
from pygame.locals import *
from game_of_life import GameofLife
WIDTH = 1280
HEIGHT = 1024

class Game: # It represents the game itself
    def __init__(self):
        pygame.init()  # It initializes all imported pygame modules.
        pygame.display.set_caption("Conway's Game of Life") # It sets the current window tittle.
         # It sets the display mode and creates an instance of the pygame.Surface class.
        self.screen = pygame.display.set_mode((WIDTH, HEIGHT)) 
        self.conway = GameofLife(self.screen, scale=13)
        self.clock = pygame.time.Clock()  # A pygame.time.Clock object helps us to make sure our program runs at a certain FPS.
        self.fps = 60 # This is our frame rate. It is expressed in frames per second or FPS. It is the frequency or rate at which consecutive images or frames are captured or displayed in the game.
        self.running = True # It indicates that the game is still running.

    def gameLoop(self):
        self.clock.tick(self.fps) # It keeps the game running at a constant FPS. 
        self.screen.fill((0, 0, 0)) # It fills the whole screen with black.
        self.checkEvents() # It checks all the events.
        self.conway.draw_grid() # It draws our grid or universe.
        self.conway.update_grid() # It updates our grid or universe.
        pygame.display.update() # It updates the full display surface to the screen.

    def checkEvents(self): # Pygame handles all its event messaging through an event queue. This method checks all these events.
        for event in pygame.event.get(): # It gets events from the queue.
            if event.type == pygame.QUIT:
                self.running = False

            if event.type == KEYDOWN: # A key is physically pressed on.
                    if event.key == K_ESCAPE: # The ESC key was pressed.
                        self.running = False

if __name__ == '__main__':
    game = Game() # The main function is quite simple. We create an instance of our Game class.
    while game.running: # It loops while the game is still running.
        game.gameLoop() # We call the game's game_loop function.

    pygame.quit()
    sys.exit()

import pygame
import numpy as np
import random
import copy
ALIVE = True
DEATH = False
OFFSET = 1

class Cell:
    def __init__(self, id):  
        self.status = ALIVE
        self.changeId(id)
        
    def changeId(self, newId = None):
        if newId==None:
            self.id = random.randint(0, 2)
        else:
            self.id = newId

        self.color = [(255,0,0), (0,0,255), (255,255,0)][self.id]
        
    def isAlive(self):
        return self.status == ALIVE

    def __str__(self) -> str:
        return str(self.status) + "," + str(self.id)

    def copy(self, status):
        myCopy = Cell(self.id)
        myCopy.status = status
        return myCopy

    def isPredator(self, neighbor):
        return neighbor.id==(self.id + 1) % 3

    def isPrey(self, neighbor):
        return neighbor.id==(self.id + 2) % 3

    def turnPrey(self):
        myCopy = Cell( (self.id + 2) % 3 )
        myCopy.status = self.status
        return myCopy

    def turnPredator(self):
        myCopy = Cell( (self.id + 1) % 3 )
        myCopy.status = self.status
        return myCopy

class GameofLife:
    def __init__(self, surface, width=1920, height=1080, scale=10):
        self.surface = surface
        self.width = width
        self.height = height
        self.scale = scale
        self.columns = int(height / scale)
        self.rows = int(width / scale)
        # The _universe is a two-dimensional grid of cells_, each of which is in one of two possible states: alive or dead.
        self.grid = [[Cell((c+r)%3) for c in range(self.columns)] for r in range(self.rows)]
        
    def draw_grid(self):
        """ It draws the grid."""
        for row in range(self.rows):
            for col in range(self.columns):
                if self.grid[row][col].isAlive():
                    pygame.draw.rect(self.surface, self.grid[row][col].color, [row * self.scale, col * self.scale, self.scale - OFFSET, self.scale - OFFSET])
                else: # It is not really necessary, all cells on the grid are alive.
                    pygame.draw.rect(self.surface, DEATH_COLOR, [row * self.scale, col * self.scale, self.scale - OFFSET, self.scale - OFFSET])
    
    def update_grid(self):
        """ It updates the grid based on Rock Paper and Scissors rules."""
        updated_grid = copy.deepcopy(self.grid)
        for row in range(self.rows):
            for col in range(self.columns):
               updated_grid[row][col] = self.update_cell(row, col)

        self.grid = updated_grid

    def cell_neighbors(self, x, y):
        """ It returns the number of the current or active cell's (self.grid[x, y]) neighbors that are predators and the number of its neighbors that are prey."""
        predators_neighbors = 0
        prey_neighbors = 0

        for i in range(-1, 2):
            for j in range(-1, 2):
                if i == 0 and j == 0: # The cell does not count itself as a neighbour. I am not my neighbour!
                    continue
                elif (x+i)<0 or (x+i)>=self.rows or (y+j)<0 or (y+j)>=self.columns: # The neighbour cell needs to be on the grid.
                    continue
                elif self.grid[x + i][y + j].isAlive() and self.grid[x][y].isPredator(self.grid[x + i][y + j]): # If the neighbour cell is alive and it is one of the current cell predators, we increase the variable predators_neighbors by 1.
                    predators_neighbors += 1
                elif self.grid[x + i][y + j].isAlive() and self.grid[x][y].isPrey(self.grid[x + i][y + j]): # If the neighbour cell is alive and it is one of the current cell preys, we increase the variable prey_neighbors by 1.
                    prey_neighbors += 1
        
        return predators_neighbors, prey_neighbors

    def update_cell(self, x, y):
        """ It updates the current or active cell based on Rock Paper and Scissors rules."""
        predators_neighbors, prey_neighbors = self.cell_neighbors(x, y)
        current_state = self.grid[x][y].status

        threshold = 3 + random.randint(0, 2)

        if current_state==ALIVE and predators_neighbors >= threshold:
            return self.grid[x][y].turnPredator()
        elif current_state==ALIVE and prey_neighbors >= threshold:
            return self.grid[x][y].turnPrey()
        else:
            return self.grid[x][y].copy(current_state)

import pygame
import numpy as np
import random
import copy
ALIVE = True
DEATH = False
DEATH_COLOR = (50, 50, 50)
OFFSET = 1

class Cell:
    def __init__(self, id):
        self.status = ALIVE
        self.changeId(id)
        
    def changeId(self, newId = None):
        if newId==None:
            self.id = random.randint(0, 4)
        else:
            self.id = newId

        self.color = [(255,0,0), (0,0,255), (255,255,0), (0,255,0), (255,192, 203)][self.id]
        
    def isAlive(self):
        return self.status == ALIVE

    def __str__(self) -> str:
        return str(self.status) + "," + str(self.id)

    def copy(self, status):
        myCopy = Cell(self.id)
        myCopy.status = status
        return myCopy

    def isPredator(self, neighbor):
        return neighbor.id==(self.id + 1) % 5 or neighbor.id==(self.id + 2) % 5

    def isPrey(self, neighbor):
        return neighbor.id==(self.id + 3) % 5 or neighbor.id==(self.id + 4) % 5

    def turnPrey(self):
        myCopy = Cell( (self.id + random.randint(3, 4)) % 5 )
        myCopy.status = self.status
        return myCopy

    def turnPredator(self):
        myCopy = Cell( (self.id + random.randint(1, 2)) % 5 )
        myCopy.status = self.status
        return myCopy

class GameofLife:
    def __init__(self, surface, width=1920, height=1080, scale=10):
        self.surface = surface
        self.width = width
        self.height = height
        self.scale = scale
        self.columns = int(height / scale)
        self.rows = int(width / scale)
        # The _universe is a two-dimensional grid of cells_, each of which is in one of two possible states: alive or dead.
        self.grid = [[Cell((c+r)%5) for c in range(self.columns)] for r in range(self.rows)]
        
    def draw_grid(self):
        """ It draws the grid."""
        for row in range(self.rows):
            for col in range(self.columns):
                if self.grid[row][col].isAlive():
                    pygame.draw.rect(self.surface, self.grid[row][col].color, [row * self.scale, col * self.scale, self.scale - OFFSET, self.scale - OFFSET])
                else: # It is not really necessary, all cells on the grid are alive.
                    pygame.draw.rect(self.surface, DEATH_COLOR, [row * self.scale, col * self.scale, self.scale - OFFSET, self.scale - OFFSET])
    
    def update_grid(self):
        """ It updates the grid based on Rock Paper Scissors Lizard and Spock rules."""
        updated_grid = copy.deepcopy(self.grid)
        for row in range(self.rows):
            for col in range(self.columns):
                updated_grid[row][col] = self.update_cell(row, col)

        self.grid = updated_grid

    
    def cell_neighbors(self, x, y):
        """ It returns the number of the current or active cell's (self.grid[x, y]) neighbors that are predators and the number of its neighbors that are prey."""
        predators_neighbors = 0
        prey_neighbors = 0

        for i in range(-1, 2):
            for j in range(-1, 2):
                if i == 0 and j == 0: # The cell does not count itself as a neighbour. I am not my neighbour!
                    continue
                elif (x+i)<0 or (x+i)>=self.rows or (y+j)<0 or (y+j)>=self.columns: # The neighbour cell needs to be on the grid.
                    continue
                elif self.grid[x + i][y + j].isAlive() and self.grid[x][y].isPredator(self.grid[x + i][y + j]): # If the neighbour cell is alive and it is one of the current cell predators, we increase the variable predators_neighbors by 1.
                    predators_neighbors += 1
                elif self.grid[x + i][y + j].isAlive() and self.grid[x][y].isPrey(self.grid[x + i][y + j]): # If the neighbour cell is alive and it is one of the current cell preys, we increase the variable prey_neighbors by 1.
                    prey_neighbors += 1
        
        return predators_neighbors, prey_neighbors

    def update_cell(self, x, y):
        """ It updates the cell based on Rock Paper Scissors Lizard and Spock rules."""
        predators_neighbors, pray_neighbors = self.cell_neighbors(x, y)
        current_state = self.grid[x][y].status
        threshold = 3 + random.randint(0, 2)
        # Rather than checking if the winning neighbor count (the number of the current cell neighbors that are predators) is greater than a specified threshold, we are going to check if it is greater than a threshold plus a small random amount (random.randint(0, 2)).
        
        if current_state==ALIVE and predators_neighbors >= threshold:
            return self.grid[x][y].turnPredator()
        # We can also check if the losing neighbor count is greater than a threshold plus a small random amount, and if this is the case, turn the current or active cell into prey. However, these are different ways of designing our simulation. It is up to you to evaluate and decide which is the best model or rules to be chosen. 
        # elif current_state==ALIVE and pray_neighbors >= threshold:
        #    return self.grid[x][y].turnPrey()
        else:
            return self.grid[x][y].copy(current_state)

def accepts(transitions, initialState, acceptingStates, entryString, alphabet):
    state =  initialState
    for c in entryString:
        if int(c) not in alphabet:
            print("Input error: " + str(c) + " is not in the alphabet.")
            return False

        state = transitions[state][c]
    return state in acceptingStates

if __name__ == '__main__':
    print(accepts(dfa, 0, {0}, '1211101', {0, 1})) # Input error: 2 is not in the alphabet. False.
    print(accepts(dfa, 0, {0}, '1000010', {0, 1})) # True (66 is a multiple of 3)
    print(accepts(dfa, 0, {0}, '1000001', {0, 1})) # False (65 is not a multiple of 3).

dfa = {0: {'b': 1},
       1:{'a': 1, 'b': 2},
       2: None}

def accepts(transitions, initialState, acceptingStates, entryString, alphabet):
    state =  initialState
    for c in entryString:
        if c not in alphabet:
            print("Input error: " + str(c) + " is not in the alphabet.")
            return False

        # If there are still characters to be processed by the automaton and there is no dictionary for the current state or there is no key in the dictionary that has "c" as a key, the input string is not valid.
        if transitions[state] is not None and transitions[state].get(c) is not None:
            state = transitions[state][c]
        else:
            print("The input string " + entryString + " is not valid.")
            return False

    return state in acceptingStates

if __name__ == '__main__':
    print(accepts(dfa, 0, {2}, 'b1a', {"a", "b"})) # Input error: 1 is not in the alphabet.
    print(accepts(dfa, 0, {2}, 'baab', {"a", "b"})) # True
    print(accepts(dfa, 0, {2}, 'bbaab', {"a", "b"})) # The input string bbaab is not valid. False.
    print(accepts(dfa, 0, {2}, 'abbaab', {"a", "b"})) # The input string abbaab is not valid. False.

from automata.fa.dfa import DFA
# DFA which matches all binary strings ending in an odd number of '1's
dfa = DFA(
    states={'q0', 'q1', 'q2'}, # This is a set of the DFA's valid states.
    input_symbols={'0', '1'}, # This is a set of the DFA's valid input symbols.
    transitions={ # This is a dict consisting of the transitions for each state.
        'q0': {'0': 'q0', '1': 'q1'},
        'q1': {'0': 'q0', '1': 'q2'},
        'q2': {'0': 'q2', '1': 'q1'}
    },
    initial_state='q0', # The name of the initial state for this DFA.
    final_states={'q1'} # A set of final states for this DFA.
)

dfa.show_diagram(path='./dfa1.png') # Fig A, dfa1.png. 

if dfa.accepts_input("00111"): # If the input is accepted, it returns True. Otherwise, it returns False.
    print('accepted')
else:
    print('rejected')

from automata.fa.dfa import DFA
# DFA that accepts or recognizes the regular expression: a(bc)* (Fig A, dfa2.png)
dfa = DFA(
    states={'q0', 'q1', 'q2'},
    input_symbols={'a', 'b', 'c'},
    transitions={
        'q0': {'a': 'q1'},
        'q1': {'b': 'q2'},
        'q2': {'c': 'q1'}
    },
    initial_state='q0',
    final_states={'q1'},
    allow_partial=True
)

dfa.show_diagram(path='./dfa2.png')

if dfa.accepts_input("abcbc"): # abcbc is accepted, but abcbca and abacbc are rejected.
    print('accepted')
else:
    print('rejected')

from automata.fa.dfa import DFA
# DFA that accepts or recognizes the regular expression: (a+b)c* (Fig. A, dfa3.png)
dfa = DFA(
    states={'q0', 'q1', 'q2'},
    input_symbols={'a', 'b', 'c'},
    transitions={
        'q0': {'a': 'q1', 'b': 'q1'},
        'q1': {'c': 'q2'},
        'q2': {'c': 'q2'}
    },
    initial_state='q0',
    final_states={'q2'},
    allow_partial=True
)

dfa.show_diagram(path='./dfa3.png')

if dfa.accepts_input("acccc"): # accc and bc are accepted, but cadb and abc are rejected.
    print('accepted')
else:
    print('rejected')

class State:
    def __init__(self, id):
        self.id = id
        self.links = []

    def add_link(self, symbol, newState):
        # It adds a new link or transition to the state.
        self.links.append( (symbol, newState) )

    def __eq__(self, otherState):
        # It overloads the == operator.
        if otherState==None: return False
        return self.id == otherState.id
    
    def __str__(self):
        state = "(%s):\n" % self.id
        for (symbol, newState) in self.links:
            state += str(symbol) + " : " + str(newState.id) + "\n"
        return state

class Automata:
    def __init__(self, initial_state, states, terminal_state):
        self.initial_state = initial_state
        self.states = states
        self.terminal_state = terminal_state

    def get_next_state(self, current_state, character):
        for (symbol, newState) in current_state.links:
            if symbol == character:
                return newState
        return None
    
    def accepts(self, string):
        currentState = self.initial_state
        for character in string:
            currentState = self.get_next_state(currentState, character)
        return self.terminal_state == currentState

    def __str__(self):
        automata = "Initial state: %s\nTerminal state: %s\n" % (self.initial_state.id, self.terminal_state.id)"
        for state in self.states:
            automata += str(state) + "\n"
        return automata
# We are going to define a deterministic finite automaton that accepts only binary numbers that are multiples of 3. 
if __name__ == '__main__':
    s0 = State("s0")
    s1 = State("s1")
    s2 = State("s2")

    s0.add_link('0', s0)
    s0.add_link('1', s1)
    s1.add_link('0', s2)
    s1.add_link('1', s0)
    s2.add_link('0', s1)
    s2.add_link('1', s2)

    a = Automata(s0, [s0, s1, s2], s0)
    print(a)
    print("1011101 is " + ("accepted." if a.accepts('1011101') else "rejected.")) 
    print("10111011 is " + ("accepted." if a.accepts('10111011') else "rejected."))

Initial state: s0 Terminal state: s0 (s0): 0 : s0 1 : s1  
(s1): 0 : s2 1 : s0  
(s2): 0 : s1 1 : s2  
1011101 is accepted. 10111011 is rejected.

class State:
    def __init__(self, id):
        self.id = id
        self.links = []

    def add_link(self, symbol, newState):
        self.links.append( (symbol, newState) )

    def __eq__(self, otherState):
        if otherState==None: return False
        return self.id == otherState.id
    
    def __str__(self):
        state = "(%s):\n" % self.id
        for (symbol, newState) in self.links:
            state += str(symbol) + " : " + str(newState.id) + "\n"
        return state

class Automata:
    def __init__(self, initial_state, states, terminal_state):
        self.initial_state = initial_state
        self.states = states
        self.terminal_state = terminal_state

    def get_next_state(self, current_state, character):
        # get_next_state will return None if the current state is None or the current character from the input has no transition from the current state. 
        if current_state==None or len(current_state.links)==0: 
            return None

        for (symbol, newState) in current_state.links:
            if symbol == character:
                return newState
        return None
    
    def accepts(self, string):
        currentState = self.initial_state
        for character in string:
            currentState = self.get_next_state(currentState, character)
            if currentState==None: # This is the only difference with the previous code!!! 
                return False
                
        return self.terminal_state == currentState

    def __str__(self):
        automata = "Initial state: %s\nTerminal state: %s\n" % (self.initial_state.id, self.terminal_state.id)
        for state in self.states:
            automata += str(state) + "\n"
        return automata
    
# We are going to define a deterministic finite automaton that accepts or recognizes the regular expression: ba*b
if __name__ == '__main__':
    s0 = State("s0")
    s1 = State("s1")
    s2 = State("s2")

    s0.add_link('b', s1)
    s1.add_link('a', s1)
    s1.add_link('b', s2)
    
    a = Automata(s0, [s0, s1, s2], s2)
    print(a)
    print("baab is " + ("accepted" if a.accepts('baab') else "rejected")) 
    print("abaaba is " + ("accepted" if a.accepts('abaaba') else "rejected"))
    print("cbaaba is " + ("accepted" if a.accepts('abaaba') else "rejected"))
    print("baaba is " + ("accepted" if a.accepts('abaaba') else "rejected"))