Máquina de Mealy

A Máquina de Mealy é um Autômato Finito modificado de tal forma que gere uma palavra de saída para cada transição, baseando-se no estado em que se encontra e na entrada de dados. Assim o diagrama de estados irá incluir tanto o sinal de entrada como o de saída para cada vértice de transição.
Leia o restante deste artigo »

O que é Pesquisa Operacional

A Pesquisa Operacional (PO) é uma ciência que objetiva fornecer ferramentas quantitativas ao processo de tomada de decisões. É constituída por um conjunto de disciplinas isoladas, tais como Programação Linear, Teoria das Filas, Simulação, Programação Dinâmica, Teoria dos Jogos, etc.
Leia o restante deste artigo »

Teoria dos jogos

Um  jogo   representa   uma   situação   ou   conflito   entre   dois   ou  mais   oponentes.   Estes oponentes são usualmente chamados de jogadores (um jogador pode ser um time composto de mais   de   uma   pessoa).  Cada   jogador   tem  um  certo   número   de   escolhas,   finito   ou   infinito, chamadas de estratégias.
Leia o restante deste artigo »

Algoritmo Quadrado Mágico em Assembler

Algoritmo em Assembler para determinar se uma matriz é ou não quadrado mágico, ou seja, a soma de cada linha, coluna e diagonal deve ser a mesma.
Leia o restante deste artigo »

Matriz Simétrica em Assembler

Algoritmo em Assembler para verificar se matriz é ou não simétrica.

Leia o restante deste artigo »

Vantagens e os desafios de sistemas de comunicações via satélite Low Earth Orbit (LEO)

Os satélites LEO (Low Earth Orbit) são satélites que surgem como uma alternativa eficaz para os satélites GEO (Geostationnary Earth Orbit). Ficam a uma altitude de 800 km, cobrindo apenas uma pequena área da terra, precisando de vários satélites em órbita para dar continuidade e ter uma ampla área de abrangência.
Leia o restante deste artigo »

Algoritmo: Boliche

Algoritmo de Maratona de Programação simples:

#include <stdio.h>
#include <string.h>

int main(void){
	int n,i,j,k,pontos,jogo=1,nJogadas;
	char jogador[15];
	int jogada[20];
	int segunda;
	while(scanf("%d",&n) && n){
		printf("JOGO #%d\n",jogo++);
		for(i=0;i<n;i++){
			pontos=nJogadas=segunda=0;
			memset(jogada,0,20*sizeof(int));
			scanf("%s",jogador);
			printf("%s ",jogador);
			for(k=0;nJogadas<10;k++){
				scanf("%d",&jogada[k]);
				if(jogada[k]==10 && !segunda){
					nJogadas++;
					segunda=1;
				}else if(segunda) nJogadas++;
				segunda=!segunda;
			}
			if(jogada[k-1]==10) scanf("%d %d",&jogada[k],&jogada[k+1]);
			else if(jogada[k-2]+jogada[k-1] >=10) scanf ("%d",&jogada[k]);
			pontos=0;
			segunda=0;
			for(j=0;j<k;j++){
				pontos+=jogada[j];
				if(jogada[j]==10 && !segunda){
					pontos+=jogada[j+1]+jogada[j+2];
					segunda=1;
				}else if(segunda)
					if(jogada[j]+jogada[j-1]>=10) pontos +=jogada[j+1];
				segunda=!segunda;
			}
			printf("fez %d pontos\n",pontos);
		}
		printf("\n");
	}
	return 0;
}

Algoritmo: Números de Ka Fu

Algoritmo de Maratona de Programação simples

#include<iostream>
using namespace std;
int main(){
	int n,k,t=1;
	while((cin >> n >> k)and(n!=0)and(n!=0))
		cout << "Instancia "<<t++<<"\n"<<(((((n - ((k*k+k))/2)) %(k+1)) == 0)? "sim":"nao")<<"\n\n";
	return 0;//((k*(k-1))/2)+k
}

Algoritmo: O imperador Lu Zhin Du

Algoritmo de Maratona de Programação utilizando recursão:

#include<iostream>
using namespace std;
int m,n,k,mat[100][100],vis[100][100];
bool recursao(int i, int j){
	if(j==n-1) return true;
	vis[i][j]=1;
	bool parcial=false;
	if((j<n-1)&&(!vis[i][j+1])&&(abs(mat[i][j+1]-mat[i][j])==k)) parcial=recursao(i,j+1);
	if((!parcial)&&(i>0)&&(!vis[i-1][j])&&(abs(mat[i-1][j]-mat[i][j])==k)) parcial=recursao(i-1,j);
	if((!parcial)&&(j>0)&&(!vis[i][j-1])&&(abs(mat[i][j-1]-mat[i][j])==k)) parcial=recursao(i,j-1);
	if((!parcial)&&(i<m-1)&&(!vis[i+1][j])&&(abs(mat[i+1][j]-mat[i][j])==k)) parcial=recursao(i+1,j);
	return parcial;
}
int main(){
	int t=1;
	while((cin >> m >> n >> k)&&(m!=0)&&(n!=0)){
		memset(vis,0,sizeof(vis));
		for(int i=0;i<m;i++)
			for(int j=0;j<n;j++)
				cin >> mat[i][j];
		bool resposta=false;
		for(int i=0;((i<m)&&(!resposta));i++) resposta=recursao(i,0);
		cout << "Instancia " << t++ << endl << ((resposta)?"sim":"nao") << endl << endl;
	}
	return 0;
}

Algoritmo: Ajudando a prefeitura

Algoritmo de Maratona de Programção utilizando Grafo

#include<iostream>
const int INF = 100;
using namespace std;
int main(){
  int n,m,q,t=1;
  cout.setf(ios::fixed);
  cout.precision(3);
  while((cin>>n>>m)&&(n!=0)&&(m!=0)){
   double M[n][n];
   memset(M,INF,sizeof(M));
   for(int i=0;i<n;i++)M[i][i]=0;
   for(int i=0;i<m;i++){
     int u,v;
     double p;
     cin >> u >> v >> p;
     M[u][v]=p;
     M[v][u]=p;
   }
  for(int k=0; k<n; k++)
    for(int i=0; i<n; i++)
      if( i!=k && M[i][k]<INF )
        for(int j=0; j<n; j++)
          if(M[i][j] > M[i][k]+(100-M[i][k])*(M[k][j]/100))
            M[i][j] = M[i][k]+(100-M[i][k])*(M[k][j]/100);
    cin >> q;
    cout << "Instancia " << t++ << endl;
    for(int i=0;i<q;i++){
      int a,b;
      cin >> a >> b;
      cout << ((double)((int)(M[a][b]*1000)))/1000 << endl;
    }
    cout << endl;
  }
  return 0;
}
« Artigos Anteriores
Próximos Artigos »