Esempio n. 1
0
    def __init__(self, cores=4, processos_aptos=10, tamanho_ram=4):
        self.memoria = MemoriaVirtual(self, tamanho_ram)
        self.cores = Cores(self.memoria, cores)

        self.aptos = []
        self.executando = self.cores.cores
        self.quantum = 0
        self.algoritimo = ""

        for i in range(processos_aptos):
            try:
                self.add_processo(Processo(i))
            except AttributeError:
                pass
Esempio n. 2
0
from cores import Cores

cores = Cores()


class Timer:
    def __init__(self, start):
        self.hours = start  #Em horas absolutas
        self.minutes = 0
        self.days = 1

    def adicionar_tempo(self, time_passed):
        self.minutes += time_passed  #SEMPRE EM MINUTOS! MUITO IMPORTANTE.
        while self.minutes >= 60:
            self.hours += 1
            self.minutes -= 60
            while self.hours >= 24:
                self.days += 1
                self.hours -= 24

    def __str__(self):
        return f'AGORA SÃO {cores.redON}{self.hours:02d}:{self.minutes:02d}{cores.redOFF} DO {cores.redON}{self.days}°{cores.redOFF} DIA\n'
Esempio n. 3
0
'''
Escreva um programa que faça o computador "pensar" em um número inteiro entre 0 e 5
e peça para o usuário tentar descobrir qual foi o número escolhido pelo computador.
O programa deverá escrever na tela se o usuário venceu ou perdeu.
'''

from cores import Cores  # necessário o arquivo cores.py
from random import randint
import time

cor = Cores()

print('-*' * 27)
print('Vou pensar em um número entre 0 e 5. Tente adivinhar...')
print('-*' * 27)

num = int(input('Em que número eu pensei? '))
numEscolhido = randint(0, 5)
print('PROCESSANDO...')
time.sleep(1)

if num == numEscolhido:
    print(
        f'{cor.font("verde")}PARABÉNS! Você conseguiu me vencer!{cor.limpar()}'
    )
else:
    print(
        f'{cor.font("vermelho")}Ganhei! Eu pensei no número {numEscolhido} e não no {num}!{cor.limpar()}'
    )
Esempio n. 4
0
class Escalonador():
    
    def __init__(self, cores=4, processos_aptos=10, tamanho_ram=4):
        self.memoria = MemoriaVirtual(self, tamanho_ram)
        self.cores = Cores(self.memoria, cores)

        self.aptos = []
        self.executando = self.cores.cores
        self.quantum = 0
        self.algoritimo = ""

        for i in range(processos_aptos):
            try:
                self.add_processo(Processo(i))
            except AttributeError:
                pass
    
    def add_processo(self, processo):
        self.aptos.append(processo)
    
    def draw_img(self):
        #fila = self.aptos if self.algoritimo != "Fila de Prioridade com RoundRobin" else self.filas
        #desenho = Desenho(cores=self.cores, algoritimo=self.algoritimo, fila_aptos=fila)
        desenho = Desenho(self)
        return desenho.draw()
    
    def executa(self):
        p = None
        if self.cores.is_empty() and len(self.aptos) == 0:
            return False #Encerra o programa...
        
        while not self.cores.is_full(): #Enquanto tiver espaco em branco nos cores
            p = self.get_prox()
            if p == None:
                break

            if not self.memoria.is_in_memory(p):
                if not self.memoria.has_memory_for(p):
                    #Tenta o Swap:
                    self.memoria.swap()
                    break #Se não tiver memória alocavel(mesmo fazendo merge), sai do looping
                self.alloc_process(p) #Aloca na memória, podendo fazer o Merge ou não

            self.cores.add_process(p) #Adiciona o processo nos cores
            del self.aptos[0]
        self.quantum += 1
        return self.cores.processa()
    
    def get_prox(self):
        if len(self.aptos) > 0:
            p = self.aptos[0]
            return p
        return None

    def alloc_process(self, processo):
        if self.memoria.malloc(processo):
            return True
        return False

    def is_finished(self):
        if self.cores.is_empty() and len(self.aptos) == 0:
            return True
        return False

    def fill_memory(self):
        '''
        Aloca todos os processos dos cores na memória, fazendo swap se necessário.
        :return:
        '''
        def get_old_process():
            for i in self.cores.cores:
                pass

        return None

    #Somente testes
    def exibe(self):
        for i in range(self.cores):
            print self.executando[i]
Esempio n. 5
0
 def tarefa_cores(self):
     self.cor = Cores()
     self.setCentralWidget(self.cor)
Esempio n. 6
0
from cores import Cores  # necessário o arquivo cores.py
'''
Escreva um programa que pergunte o salário de um funcionário e calcule o valor do seu aumento.
- Para salários superiores a R$1250,00, calcule um aumento de 10%.
- Para os inferiores ou iguais, o aumento é de 15%.
'''

cor = Cores()

salario = float(input('Qual é o salário do funcionário? R$'))

if salario > 1250:
    salarioReajustado = salario * (1 + 0.10)
else:
    salarioReajustado = salario * (1 + 0.15)

print('Quem ganhava {}R${:.2f}{} passa a ganhar {}R${:.2f}{} agora.'.format(
    cor.font('azul'), salario, cor.limpar(), cor.font('verde'),
    salarioReajustado, cor.limpar()))