static void menorTest() {
cabecalho("menorTest()");
ENSURE(menor(1, 2) == 1);
ENSURE(menor(2, 1) == 1);
ENSURE(menor(-1, 5) == -1);
ENSURE(menor(5, -1) == -1);
ENSURE(menor(5, 5) == 5);
}
void tests() {
float v1[] = {1.50, 1.55, 1.89, 2.00, 2.01, 1.72};
float v2[] = {1.56, 0.55, 2.00, 1.90, 1.91, 1.74};
float v3[] = {1.80, 0.95, 1.89, 2.00, 2.01, 2.22};
cerr << ("#open menor_preco BRONZE IF VETOR ");
cerr << (feq(menor(v1 ,6), 1.50));
cerr << (feq(menor(v2 ,6), 0.55));
cerr << (feq(menor(v3 ,6), 0.95));
}
int main(void) {
unsigned int i = 0, j, tam = 10, n, *v = (unsigned int*) malloc(
tam * sizeof(unsigned int));
freopen("e8.txt", "r", stdin);
freopen("s8.txt", "w", stdout);
if (v != NULL) {
scanf("%u", &n);
while (n) {
v[i] = n;
i++;
if (i >= tam) {
tam = tam * 2;
v = (unsigned int*) realloc(v, tam * sizeof(unsigned int));
}
scanf("%u", &n);
}
ordena(v, i);
for (j = 0; j < i; j++) {
printf("%u ", v[j]);
}
printf("\n");
printf("%.1lf\n", media(v, i));
printf("%u\n", maior(v, i));
printf("%u\n", menor(v, i));
}
free(v);
fclose(stdin);
fclose(stdout);
return 0;
}
inline int min(int x,int y)
{
if (menor(x,y))
return x;
else
return y;
}
void prim(struct ponto sardas[], float prim[])
{
int i, j, min, k;
float dist, vetor[100];
prim[0] = 0;
vetor[0] = -1;
for (i = 1; i < nroSardas; i++)
{
vetor[i] = INF;
}
k = 0;
for (i = 0; i < nroSardas - 1; i++)
{
for (j = 1; j < nroSardas; j++)
{
if (k != j)
{
dist = distancia(sardas[k], sardas[j]);
if (vetor[j] > dist)
{
vetor[j] = dist;
}
}
}
k = menor(vetor);
prim[k] = vetor[k];
vetor[k] = -1;
}
}
/* M = M+1 */
int main (int argc, char *argv[])
{
int m, *bResult, *wResult;
int root = 0;
Graph *G;
m = atoi(argv[2]);
G = read(argv[1]);
tempoInicial = clock();
bResult = malloc((m+1)*sizeof(int));
wResult = malloc((m+1)*sizeof(int));
recursao(G, root, 0, m+1, bResult, wResult);
tempoFinal = clock();
if(DEBUG)printVector(bResult, m+1);
if(DEBUG)printVector(wResult, m+1);
printf("%d\n", menor(bResult[m], wResult[m]));
freeGraph(G);
free(bResult);
free(wResult);
tempoGasto = (tempoFinal-tempoInicial)*1.0/CLOCKS_PER_SEC;
printf("TEMPO: %f seg \n", tempoGasto);
return 0;
}
int LRU (int rPage)
{
int i;
int r;
if(LRU_Door==Closed)
return 0; //Closed
LRU_Door=Closed; /* A porta deve ser fechada, LRU deve ser atomica */
r=search(fisMemPaginas,MEM_FRAMES,rPage);
if(r >= 0) //Found
{
printf("Pagina esta na memoria\n");
/* Alterar Contadores
Marcar Esta Página como Recentemente usada */
printf("Alterando contador da pagina %d, na posicao %d\n",rPage,r+1);
contadores[r]=time(NULL)-startTime; //Number of seconds since the start
}
else //Not Found
{
printf("Pagina nao esta na memoria\n");
/* Page Fault Sequence */
r=search(fisMemPaginas,MEM_FRAMES,(int)-1); //procure um espaço vazio
if(r>=0)
{
printf("Ocupando um espaço vazio\n");
fisMemPaginas[r]=rPage; //Esta Página ocupará a vazia
entradasDePagina++;
contadores[r]=contadores[r]=time(NULL)-startTime; //Number of seconds since the start
}
else //Significa que nao há espaço vazio para ocupar
{ /* Page Fault Count */
printf("Page Fault\n");
pageFaults++;
r=menor(contadores,MEM_FRAMES); //minor value =>Least Recently Used
r=search(contadores,MEM_FRAMES,r);//Ache o índice do 1º menor valor
printf("Substitui pagina %d na posicao %d por pagina %d\n",fisMemPaginas[r],r+1,rPage);
fisMemPaginas[r]=rPage; /* subistitui */
contadores[r]=contadores[r]=time(NULL)-startTime; //Update time
}
}
printf("< ");
for(i=0;i<MEM_FRAMES;i++)
{
printf("%d ",fisMemPaginas[i]);
}
printf(">\t PageFrames\n");
if(SHOW_CONTADORES)
{
printf("< ");
for(i=0;i<MEM_FRAMES;i++)
{
printf("%d ",contadores[i]);
}
printf(">\t Contadores\n");
}
LRU_Door=Open; /* Liberado */
return 1; // LRU Executed
}
void flotar(struct temp_node* heap,int pos)
{
while(pos > 0 && menor(heap[pos].val,heap[(pos-1)/2].val))
{
swapnodes(&heap[pos],&heap[(pos-1)/2]);
pos = (pos-1)/2;
}
}
ulong SSTree::lca_lookup(ulong v, ulong w){
if (v == 0 || w == 0) return 0;
if (v == w || v == root()) return v;
if (w == root()) return root();
ulong u = menor(v,w);
ulong x = maior(v,w);
if (_findclose[u] > _findclose[x]) return u;
return _enclose[rmq->lookup(u, x) + 1];
}
void hundir(struct temp_node* heap,int size, int pos)
{
int s;
while(1)
{
s=pos;
if(2*pos+1<size && menor(heap[2*pos+1].val,heap[pos].val)) s=2*pos+1;
if(2*pos+2<size && menor(heap[2*pos+2].val,heap[s].val)) s=2*pos+2;
if(s!=pos)
{
swapnodes(&heap[s],&heap[pos]);
//printf("Hundiendo %i a %i.\n",pos,s);
pos=s;
} else break;
}
}
void ListaEnc<T>::adicionaEmOrdem(const T& data) {
if (listaVazia()) {
this->adicionaNoInicio(data);
return;
}
if (menor(data, pegarCabeca()->getInfo())) {
this->adicionaNoInicio(data);
return;
}
Elemento<T> *walker = pegarCabeca();
for (int i = 0; i < size; ++i) {
if (menor(data, walker->getInfo())) {
this->adicionaNaPosicao(data, i);
return;
}
}
this->adiciona(data);
}
//Metodo principal
int ForcaBruta(int * distVet, int numPlanetas, int numAConquistar, int sumDist)
{
//Caso não haja planetas para conquistar retor o tamanho do caminho todo
if(numPlanetas == 0)
{
return sumDist;
}
//Inicializa parametros
int maxVal = Inf;
int sizeDistVet = numPlanetas+1;
int sizeVetPos = numAConquistar;
int * vetPos = malloc(sizeVetPos * sizeof(int));
//Inicializa caminho básico inicial {0,1,2,3 ,..., M}
int cont;
for(cont=0; cont < sizeVetPos; cont++)
{
vetPos[cont] = cont;
}
while( vetPos[0] < (numPlanetas-numAConquistar))
{
//Retorna maior sub-caminho da disposição atual dos planetas a conquistar
int dist = maxDistCalcFb(distVet, sizeDistVet, vetPos, sizeVetPos, numAConquistar);
maxVal = menor(maxVal, dist);//Escolhe menor maior subcaminho
CaminhaFb(vetPos,sizeVetPos,numPlanetas);//Caminha com o vetor de planetas a conquistar
}
//Ultima iteração
int dist = maxDistCalcFb(distVet, sizeDistVet, vetPos, sizeVetPos, numAConquistar);
maxVal = menor(maxVal, dist);
free(vetPos);
return maxVal;
}
main()
{
system ("color 79");
float n1,n2,r;
printf("\t\tInsira dois numeros\n\n");
scanf ("%f%f",&n1,&n2);
r=menor(n1,n2);
printf("%0.0f \n\n",r);
system("pause");
}
main() {
//Variáveis loops
int i;
//Variáveis etapa a
int a = N1,
b = N2;
//Variáveis etapa c
int diff,
vet[QTDVET];
//Variáveis etapa e
int primo;
//Etapa b
parImpar(menor(a, b));
//Etapa c
if (a > b) {
diff = a - b;
} else {
diff = b - a;
}
vet[0] = 0;
for (i = 1; i < QTDVET; i++) {
if (vet[i - 1] + diff >= 1000 || vet[i - 1] + diff <= -1000) {
vet[i] = i;
} else {
vet[i] = vet[i - 1] + diff;
}
}
//Etapa d
for (i = 0; i < QTDVET; i++) {
parImpar(vet[i]);
}
//Etapa e
for (i = 0; i < QTDVET; i++) {
primo = ehPrimo(vet[i]);
if (primo == 0) {
printf("%d eh um numero primo.\n", vet[i]);
} else {
printf("%d nao eh primo. O proximo primo depois de %d eh o %d\n", vet[i], vet[i], primo);
}
}
}
tree_node_t<T>* tree_t<T>::find(tree_node_t<T>*& root, const T& data) const
{
if (root == NULL)
return root;
else{
if (igual(root->get_data(), data))
return root;
else{
if (menor(data, root->get_data()))
return find(root->get_left(), data);
else
return find(root->get_right(), data);
}
}
}
int partition(Indice *a, int l, int r){
int i = l+1, j = r;
Indice v = a[l];
while(1) {
while(menor(v,a[i]) && i < r) i++;
while(maior(a[j],v)) j--;
if(i >= j) break;
troca(a,i,j);
i++;
j--;
}
set_M(a,l,a[j].peso,a[j].objeto_linha,a[j].objeto_coluna);
set_M(a,j,v.peso,v.objeto_linha,v.objeto_coluna);
return i;
}
int main(){
float a, b, c, m, n, p; int i;
printf("Digite os números a serem ordenados: "); scanf("%f", a); scanf("%f", b); scanf("%f", c);
printf("Digite o valor de I: "), scanf("%d", i);
m = maior(a, b, c); n = meio(a, b, c); p = menor(a, b, c);
if(i == 1){
printf("%f%f%f\n", m, n, p);
}
else if(i == 2){
printf("%f%f%f\n", p, n, m);
}
else{
printf("%f%f%f\n", n, m, p);
}
return 0;
}
void calculaBprimePrime(int m, int *lastB, int *bPrime)
{
int *newB = malloc(m*sizeof(int));
int i, l;
/* todos os m's */
for(i = 0; i<m; i++)
{
newB[i] = -1;
for(l = 1; l<=i; l++)
{
newB[i] = menor(newB[i], soma(lastB[l], bPrime[i-l+1]));
}
}
for(i = 0; i<m; i++)
lastB[i] = newB[i];
free(newB);
}
int main (void)
{
int i, n, acima, abaixo;
float *v;
float med, var, maximo, minimo;
/* leitura do número de valores */
printf("Digite a quantidade de alunos:");
scanf("%d", &n);
/* alocação dinâmica */
v = (float*) malloc(n*sizeof(float));
if (v==NULL) {
printf("Memoria insuficiente.\n");
return 1;
}
/* leitura dos valores */
for (i = 0; i < n; i++){
printf("Digite a media do %do. aluno: ", i+1);
//scanf("%f", &v[i]);
scanf("%f", v+i);
}
med = media(n,v);
var = variancia(n,v,med);
maximo = maior(n, v);
minimo = menor(n, v);
printf("Media = %f Variancia = %f \n", med, var);
/* descobre acima e abaixo da media */
acima = 0;
abaixo = 0;
for (i = 0; i < n; i++){
if(v[i]> med)
acima++;
if(v[i]< med)
abaixo++;
}
printf("A maior nota eh: %.2f\n", maximo);
printf("A menor nota eh: %.2f\n", minimo);
printf("Ha %d notas acima da media\n", acima);
printf("Ha %d notas abaixo da media\n", abaixo);
/* libera memória */
free(v);
getch();
return 0;
}
void calculaWprimePrime(int m, int *lastW, int *wPrime)
{
int *newW = malloc(m*sizeof(int));
int i, l;
/* todos os m's */
for(i = 0; i<m; i++)
{
newW[i] = soma(lastW[0], wPrime[i]);
for(l = 1; l<=i; l++)
{
newW[i] = menor(newW[i], soma(lastW[l], wPrime[i-l]));
}
}
for(i = 0; i<m; i++)
lastW[i] = newW[i];
free(newW);
}
int main(){
int n1, n2, n3, n4, i=1;
printf("Informe o 1º numero: ");
scanf("%i", &n1);
printf("Informe o 2º numero: ");
scanf("%i", &n2);
while(i < menor(n1, n2)){
if((n1%i == 0) && (n2%i == 0)){
n3 = n1/i;
n4 = n2/i;
}
i++;
}
printf("O irredutivel de %i/%i é: %i/%i\n", n1, n2, n3, n4);
return 0;
}
int* nearestNeighbor(int primeira_cidade, int n, float** matriz, int* valor){
float** matriz_aux;
float* vetor;
int* caminho = (int*)malloc(n*sizeof(int));
int i, j, indice_menor = primeira_cidade-1; //esse -1 serve para "adequar" a leitura de vetores/matrizes
float soma = 0, aux;
matriz_aux = alocarMatriz(n);
matriz_aux = copiarMatriz(n, matriz);
for (i=0;i<n-1;i++){
//inicia construindo o caminho, gravando a primeira cidade
caminho[i]=indice_menor;
for (j=0;j<n;j++){
matriz_aux[j][indice_menor] = FLT_MAX;
}
vetor = matriz_aux[indice_menor];
aux = menor(vetor, n, &indice_menor); //acha o menor valor da linha da matriz
soma = soma + aux; // soma esses valores
}
//recebe o ultimo indice, ou seja, a ultima cidade do caminho antes de voltar para o ciclo
caminho[i]=indice_menor;
//soma a volta para a primeira cidade
soma = soma + matriz[indice_menor][primeira_cidade-1];
if(valor != NULL)
(*valor) = soma;
//libera vetores temporariamente alocados para calculo
liberarMatriz(n, matriz_aux);
return caminho;
}
int main()
{
int base = 4;
int rquad = quadrado(base);
printf("Quadrado de %d = %d\n", base, rquad);
int n = 3;
int rsomat = somatorio_n(n);
printf("Somatorio ate %d = %d\n", n, rsomat);
int menora = 15;
int menorb = 98;
int menorc = 145;
int rmenor = menor(menora, menorb, menorc);
printf("Menor numero: %d\n", rmenor);
int num1 = 2;
int num2 = 3;
int posmaior = 0;
int * maior = & posmaior;
int rdsem = devolve_soma_e_maior(num1, num2, maior);
printf("Resultado da soma: %d, maior numero dos dois: %d\n", rdsem, posmaior);
int n1 = 4;
int n2 = 5;
int *p1 = &n1;
int *p2 = &n2;
/*troca(p1,p2);*/
char ig1[] = "trinta";
char ig2[] = "trinta";
char * pig1 = ig1;
char * pig2 = ig2;
int igual = 1;
igual = testaiguais(pig1, pig2);
printf("Igual? : %d\n", igual);
return 0;
}
int main(void)
{
nodo_t *arbol;
arbol = malloc(sizeof arbol);
arbol = NULL;
insertar(&arbol, 4);
insertar(&arbol, 2);
insertar(&arbol, 1);
insertar(&arbol, 3);
insertar(&arbol, 5);
insertar(&arbol, 12);
insertar(&arbol, -1);
int e;
menor(arbol, &e);
printf("menor %d\n", e);
mayor(arbol, &e);
printf("mayor %d\n", e);
return 0;
}
int main(int argc, char **argv)
{
int n, i;
int inicio, fim;
int resultado;
int *A, *B;
if(argc<2){
printf("uso ./comparacao <numero natural maior do que zero>\n");
exit(1);
}
n = atoi(argv[1]);
if(n <= 0){
printf("Erro! Numero de entrada nao e' grande o bastante\n");
exit(1);
}
A = (int *) malloc(n*sizeof(int));
B = (int *) malloc(n*sizeof(int));
srand(MAGICNUMBER);
for(i = 0; i < n; i++){
A[i] = rand()%100;
B[i] = rand()%100;
}
printf("Comparando os vetores A e B sem OpenMP\n");
omp_set_num_threads(NTHREADS);
resultado = 0;
int mod = n % NTHREADS;
int divisao = n / NTHREADS;
#pragma omp parallel shared (mod, divisao) private (inicio, fim) reduction(+:resultado)
{
int tid = omp_get_thread_num();
inicio = tid * divisao;
if (tid == NTHREADS - 1)
fim = n;
else
fim = inicio + divisao;
resultado = menor(A,B,inicio,fim);
printf("Thread %d enxerga %d threads \n com inicio em %d, fim %d e resultado %d \n", tid, NTHREADS, inicio, fim, resultado);
}
/* handle mod
if (0 < mod) {
inicio = n - mod;
fim = n;
for (i = NTHREADS * divisao; i < n; i++) {
resultado = resultado + menor(A,B,inicio,fim);
printf("Thread RESTO enxerga %d threads \n com inicio em %d, fim %d e resultado %d \n", NTHREADS, inicio, fim, resultado);
}
}
*/
printf("A[i] é menor do que B[i] %d vezes\n", resultado);
return 0;
}
int find_paths(int** costs,int start, int cant_nodos,int end) //-1 representa a infinito
{
struct temp_node nodes[cant_nodos];
int act; // nodo activo (ultimo nodo correcto)
// el heap es [0..act-1]
// nodos correctos [act..cant_nodos-1]
int i;
//los nodos correctos van al final
for(i=0;i<cant_nodos;++i)
{
nodes[i].nodenum = i;
nodes[i].val = INF;
}
nodes[start].val = 0;
swapnodes(&nodes[start],&nodes[cant_nodos-1]);
act=cant_nodos-1;
while((act>0) && (nodes[act].nodenum != end) && (nodes[act].val != INF))
{
for(i=0;i<act;++i)
{
//esta comparacion se hace cant_nodos^2 veces
if(costs[nodes[act].nodenum][nodes[i].nodenum] == INF)
{
continue;
}
if(menor(nodes[act].val + costs[nodes[act].nodenum][nodes[i].nodenum],nodes[i].val))
{
//actualizo distancia
nodes[i].val = nodes[act].val + costs[nodes[act].nodenum][nodes[i].nodenum];
//mantengo el heap (floto)
flotar(nodes,i);
}
}
swapnodes(&nodes[0],&nodes[act-1]); //extraigo el minimo
act--;
//hundo
hundir(nodes,act,0);
}
return nodes[act].val; // si el bucle termino por nodes[act].nodenum==end tenemos el costo
// si termino por llegar a un valor INF debe ser el costo tambien INF
// ya que solo pueden quedar vertices con valor INF
}
