private void btnIgual_Click(object sender, EventArgs e) //quando a pessoa aperta '=', o evento é disparado para se calcular a expressão
{
if (txtVisor.Text != "")
{
erro = false;
string infixa = ""; //string da sequência infixa que será mostrada no lblInfixa
FilaLista <char> seqInfixa = CriarInfixa(ref infixa); //fila que armazena sequência infixa (com as letras nos lugares dos números), que será convertida para posfixa
seqPosfixa = new FilaLista <char>(); // instanciação da fila de sequência posfixa
string posfixa = "";
ConverterParaPosfixa(seqInfixa, ref posfixa); //chama método que converte a infixa para posfixa
if (!erro)
{
lblPosfixa.Text = posfixa; //exibe sequência posfixa formada no lblPosfixa
Calcular(); //chama método que calcula a posfixa
}
else
{
txtResultado.Text = "Verifique sua expressão";
}
}
}
private void btnIgual_Click(object sender, EventArgs e)
{
//Reinicia as filas e pilhas, para elas não continuarem com o que estavam antes
infixa = new FilaLista <string>();
posfixa = new FilaLista <string>();
pilOps = new PilhaLista <string>();
string inf = txtVisor.Text; //Lê os números do visor
double res = 0;
Converter(inf); //Gera as sequências
lbSequencias.Text = "Infixa: ";
EscreverSequencia(infixa); //Escreve a sequência infixa
lbSequencias.Text += "\nPosfixa: ";
EscreverSequencia(posfixa); //Escreve a sequência posfixa
try
{
res = Calcular(); //Calcula o resultado
txtResultado.Text = res.ToString(); //Exibe-o no visor de resultado
}
catch (DivideByZeroException erro) //Se ocorrer um erro de divisão por zero
{
MessageBox.Show(erro.Message); //Exibe um messageBox avisando o erro
txtResultado.Text = "Erro"; //Não é possível gerar resultado, por isso só exibe "Erro"
}
}
private void ConverterParaPosfixa(FilaLista <char> seqInfixa, ref string posfixa)
{
char operadorComMaiorPrecedencia;
PilhaLista <char> pilha = new PilhaLista <char>(); //pilha que será usada para empilhar operadores
do
{
char simboloLido = seqInfixa.Retirar(); //simbolo lido é retirado da fila de sequencia infixa
if (!(simboloLido <= 'Z' && simboloLido >= 'A')) //se o simbolo lido não estiver entre A e Z, ou seja, for um operador
{
if (pilha.EstaVazia()) //se a pilha estiver vazia, empilha-se simbolo lido
{
pilha.Empilhar(simboloLido);
}
else //se não estiver vazia
{
while (!pilha.EstaVazia() && DeveDesempilhar(pilha.OTopo(), simboloLido)) //enquanto a pilha não estiver vazia e deve desempilhar, ou seja, o topo da pilha tem precedencia sobre o simbolo lido
{
operadorComMaiorPrecedencia = pilha.Desempilhar(); //armazena-se operador com maior precedencia, tirando-o do topo
if (operadorComMaiorPrecedencia != '(') //caso não seja '(', pois não se coloca parêntesis em sequências posfixas
{
seqPosfixa.Enfileirar(operadorComMaiorPrecedencia); //enfileira-se na seqPosfixa
posfixa += operadorComMaiorPrecedencia; //concatena-se na string de posfixa
}
}
if (simboloLido != ')') // empilha-se o simbolo lido, a menos que ele seja um ')'
{
pilha.Empilhar(simboloLido);
}
else
{
if (!pilha.EstaVazia() && pilha.OTopo() == '(') //se o simbolo lido for ')' e já foi feito o método acima sobre as precedencias, restará um parentesis aberto no topo da pilha, a menos que a sequência não esteja balanceada
{
operadorComMaiorPrecedencia = pilha.Desempilhar();
}
else
{
erro = true;
}
}
}
}
else // se for letra
{
seqPosfixa.Enfileirar(simboloLido); //enfileira-se letra na sequência
posfixa += simboloLido; //concatena-se a letra na string posfixa
}
}while (!seqInfixa.EstaVazia() && !erro); //enquando não estiver vazia e não houver nenhum erro, continua-se a expressão
while (!pilha.EstaVazia() && !erro) // se a fila de sequência ja estiver acabado mas houver operandos na pilha e não tiver dado erro
{
operadorComMaiorPrecedencia = pilha.Desempilhar(); //desempilha-se elemento da pilha
if (operadorComMaiorPrecedencia != '(') //se não for '('
{
seqPosfixa.Enfileirar(operadorComMaiorPrecedencia); //enfileira elemento
posfixa += operadorComMaiorPrecedencia; //concatena à string posfixa
}
}
}
private void EscreverSequencia(FilaLista <string> fil)
{
char letra = 'A';
string[] vet = fil.ToArray();
foreach (string s in vet)
{
if (ops.Contains(s))
{
lbSequencias.Text += s;
}
else
{
lbSequencias.Text += letra++;
}
}
}
private void EscreverSequencia(FilaLista <string> fil)
{
char letra = 'A';
string[] vet = fil.ToArray(); //Passa a fila para vetor
foreach (string s in vet)
{
if (ops.Contains(s)) //Se for um operador
{
lbSequencias.Text += s; //Exibe o operador
}
else //Se for um número
{
lbSequencias.Text += letra++; //Exibe uma letra correspondente
}
}
}
void Enfileirar()
{
fila = new FilaLista <Naufrago> [5];
for (int i = 0; i < 5; i++)
{
fila[i] = new FilaLista <Naufrago>();
}
var arquivo = new StreamReader(dlgAbrir.FileName);
int qualFila = 0;
while (!arquivo.EndOfStream)
{
var linha = arquivo.ReadLine();
var naufrago = new Naufrago(linha.Substring(0, 30),
int.Parse(linha.Substring(30, 3)),
linha.Substring(33, 1)[0]);
if (naufrago.Sexo == 'F')
{
if (naufrago.Idade < 16)
{
qualFila = 0;
}
else
if (naufrago.Idade < 36)
{
qualFila = 2;
}
else
{
qualFila = 3;
}
}
else // sexo masculino
if (naufrago.Idade < 16)
{
qualFila = 1;
}
else
{
qualFila = 4;
}
fila[qualFila].Enfileirar(naufrago);
}
ExibirFilas();
}
private FilaLista <char> CriarInfixa(ref string infixa)
{
FilaLista <char> seqInfixa = new FilaLista <char>();
char letra = 'A'; //char que irá de A a Z para "substituir" os números
valores = new double[26]; //instanciação do vetor de valores
string numero = ""; //string que armazenará um valor lido, caracter por caracter
for (int i = 0; i < txtVisor.Text.Length && !erro; i++) //percorre string do txtVisor, indexando-o como um vetor, até acabar as posições
{
char caracterAtual = (txtVisor.Text)[i]; //pega o caracter atual pelo index do for
int num; //variável apenas com fim de ser usada no tryParse
if (int.TryParse(caracterAtual.ToString(), out num) || caracterAtual.Equals('.') || caracterAtual.Equals(',')) //se o valor for um número inteiro(como se está analisando apenas um caracter isolado, não se precisa usar double.TryParse)
{ // ou se for um '.', ou seja, uma vírgula do double, ele faz parte de um número
if (caracterAtual.Equals('.'))
{
caracterAtual = ',';
}
numero += caracterAtual; //concatena caracter do número em formação
}
else if (numero != "") //se caracter lido não fizer mais parte de um número e a variável numero não for vazia
{
valores[letra - 'A'] = double.Parse(numero); //armazena-se valor do número formado, convertendo-o para double
infixa += letra + "" + caracterAtual; //concatena-se o número e o caracter lido na string infixa
seqInfixa.Enfileirar(letra); //enfileira letra referente a posição do número no vetor de valores
seqInfixa.Enfileirar(caracterAtual); //enfileira caracter de operação
numero = ""; //esvazia string de número para que comece a formação de um novo caso haja
letra++; //vai para a próxima letra
}
else //se o caracter lido for referente a uma operação mas não houver um número na variável numero (está vazia)
{
if (caracterAtual.Equals('-') || caracterAtual.Equals('+')) //o caracter pode fazer parte do número, como "-1", mas daí o '+'/'-' tem que
{ //estar logo no começo da sequência, ou estar precedido de '('
if (seqInfixa.EstaVazia() || seqInfixa.OFim().Equals('('))
{
numero += caracterAtual;
}
else
{
seqInfixa.Enfileirar(caracterAtual); //enfileira-se caracter atual
infixa += caracterAtual; //concatena-se caracter atual em infixa
}
}
else
{
seqInfixa.Enfileirar(caracterAtual); //enfileira-se caracter atual
infixa += caracterAtual; //concatena-se caracter atual em infixa
}
}
if (i + 1 == txtVisor.Text.Length && (numero != "") && !erro) // se o próximo index do vetor for o fim da operação mas o número não estiver vazio
{
valores[letra - 'A'] = double.Parse(numero); //armazena valor no vetor de valores
seqInfixa.Enfileirar(letra); //enfileira letra correspondente a valor
infixa += letra + ""; //concatena letra à sequencia infixa
numero = ""; //esvazia número
letra++; //vai à próxima letra
}
}
lblInfixa.Text = infixa; //exibe sequência infixa formada no lblInfixa
return(seqInfixa);
}
public Rota()
{
Caminhos = new FilaLista <Caminho>();
}
void Simular()
{
FilaLista <SerDaFila>[] caixas = new FilaLista <SerDaFila> [5];
int CaixaMaisVazio()
{
int indiceDoCaixaMaisVazio = 0;
for (int indice = 1; indice < caixas.Length; indice++)
{
if (caixas[indice].Tamanho() < caixas[indiceDoCaixaMaisVazio].Tamanho())
{
indiceDoCaixaMaisVazio = indice;
}
}
return(indiceDoCaixaMaisVazio);
}
void ExibirFilas()
{
for (int qualFila = 0; qualFila < 5; qualFila++)
{
for (int linhas = 0; linhas < dgvFilas.RowCount; linhas++)
{
for (int col = 0; col < 5; col++)
{
dgvFilas.Rows[linhas].Cells[col].Value = "";
}
}
SerDaFila[] pessoasNaFila = caixas[qualFila].ToArray();
if (dgvFilas.RowCount < pessoasNaFila.Length)
{
dgvFilas.RowCount = pessoasNaFila.Length;
}
for (int linha = 0; linha < pessoasNaFila.Length; linha++)
{
dgvFilas.Rows[linha].Cells[qualFila].Value = pessoasNaFila[linha].numero;
Application.DoEvents();
System.Threading.Thread.Sleep(500);
}
}
}
int clienteAtual = 0,
rodadasSemCliente = 0;
Random valorAleatorio = new Random();
for (int indice = 0; indice < caixas.Length; indice++)
{
caixas[indice] = new FilaLista <SerDaFila>();
}
do
{
// verificar se um cliente apareceu:
// aparece cliente quando random < 0.08
if (valorAleatorio.NextDouble() < 0.8) // apareceu cliente
{
rodadasSemCliente = 0; //zerou contador de rodadas consecutivas sem cliente
clienteAtual++;
int qualCaixa = CaixaMaisVazio();
caixas[qualCaixa].Enfileirar(new SerDaFila(clienteAtual));
txtEventos.AppendText($"Na fila {qualCaixa} entrou o cliente {clienteAtual}" +
Environment.NewLine);
}
else
{
++rodadasSemCliente;
txtEventos.AppendText($"Não chegou cliente por {rodadasSemCliente} rodadas."
+ Environment.NewLine);
}
//ExibirFilas();
if (valorAleatorio.NextDouble() < 0.82) // cliente será atendido
{
int qualCaixaAtende = valorAleatorio.Next(5); // sorteia 0 a 4
if (!caixas[qualCaixaAtende].EstaVazia())
{
SerDaFila pessoaAtendida = caixas[qualCaixaAtende].Retirar();
txtEventos.AppendText($"Da fila {qualCaixaAtende} saiu o cliente {pessoaAtendida.numero}"
+ Environment.NewLine);
}
}
ExibirFilas();
}while (rodadasSemCliente < 5);
}
