Arquivo da tag: Algoritmo

Enésimo termo da sequência Fibonacci sem recursividade em C

Deixe um comentário

O programa a seguir calcula e exibe um elemento da sequência Fibonacci. O programa foi construído sem o uso de recursividade.
O que deixa o código um pouco menos elegante, mas evita certas limitações da recursão frente à valores muito altos.

fib

//================================================================
// Descricao: O programa calcula e mostra o enésimo termo
//            da sequência Fibonacci sem uso de recursividade.
//================================================================

// Bibliotecas
#include <stdio.h>
#include <stdlib.h>

// Protótipo da função fibonacci
int fibonacci(int n);

// Função Principal
int main(int argc, char** argv) {
	int n;

    // Lê a posição do termo
    printf("Digite a posicao: ");
    scanf("%d", &n);

    // Imprime o termo
    printf("O termo: %d\n", fibonacci(n));

    system("pause");
    return 0;
}

// Função Fibonacci
int fibonacci(int n) {
	int anterior = 0,
		proximo = 1,
		aux,
  		i;

	// Se for o primeiro número da lista
	if(n == 1) {
		return 0;
	// Se for o segundo número da lista
 	} else if(n == 2) {
 		return 1;
	// Se for um número a partir da terceira posição
  	} else {
  		// Calcula os valores dois a dois até chegar na posição requerida
		for(i = 3; i <= n; i++) {
			aux = proximo;
			proximo = anterior + proximo;
			anterior = aux;
		}
		return proximo;
  	}
}

Algoritmo de Ordenação Bolha (Bubblesort) – Pascal

3 respostas 
CUsersClaudionorDesktopBuble.exe

//==============================================================================
// Implementação do algoritmo de ordenação bubblesort em pascal
//==============================================================================
program Bubble;
uses crt;

var
   v: array [1..10] of integer;
   I: integer;

// Procedimento para ordenação utilizando o método bolha
procedure bubble_sort();
var
   I, J, troca: integer;
begin
     for I := 1 to 10 do
     begin
          for J := I+1 to 10 do
          begin
               if v[J] < v[I] then
               begin
                    troca := v[I];
                    v[I] := v[J];
                    v[J] := troca;
               end;
          end;
     end;
end;

begin
     // Lê 10 valores
     for I := 1 to 10 do
     begin
          write('Digite um valor: ');
          read(v[I]);
     end;

     // Ordenação
     bubble_sort();

     // Impressão dos valores.
     writeln('');
     writeln('* Resultado *');
     for I := 1 to 10 do
     begin
          writeln('Valor ', I, ': ', v[I]);
     end;
     readkey;
end.