Bubble-sort-dance

Algoritmos de ordenação demonstrados com dança folclórica

Deixe um comentário

Você já imaginou aprender algoritmos dançando? Pois foi isso que fizeram na Sapientia University, Romania. 

Em uma série de vídeos foi demonstrado como diferentes algoritmos de ordenação funcionam por meio de pessoas numeradas dançando umas em volta das outras e se rearranjando do menor para o maior número.

Os algoritmos apresentados foram: Quick-sort, Merge-sort, Shell-sort, Select-sort, Bubble-sort e Insert-sort.

Veja todos eles abaixo.

Quick sort

Merge-sort

Shell-sort

Select-sort

Bubble-sort

Insert-sort

 

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;
  	}
}

Gerador de Números Primos – C

1 resposta 
primos

/*
 * Gera números primos a partir de um limite superior estabelecido.
 *
 */
#include <stdio.h>
#include <stdlib.h>

int main() {
    int n, nMax, i, j, totalDivisores;

    // Recebe o limite para exibição dos números primos
    printf("Digite o limite superior para os numeros primos(Minimo 2): ");
    scanf("%d", &nMax);

    // Verifica se o limite superior é um número válido
    // O menor número primo é 2
    while(nMax < 2) {
        system("cls");
        printf("Digite o limite superior para os numeros primos(Minimo 2): ");
        scanf("%d", &nMax);
    }

    // Verifica se o número é primo e imprime o valor na tela
    for(i = 0; i <= nMax; i++) {
        totalDivisores = 0;
        // Conta os divisores para verificar se o valor é primo
        for(j = 1; j <= i; j++) {
            if(i % j == 0) {
                totalDivisores++;
            }
        }
        // Se o total de divisores é dois, imprime o primo com formatação de 4 casas
        if(totalDivisores == 2) {
            printf("%4d ", i);
        }
    }

    printf("n");
    system("pause");
    return 0;
}

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.

Substring – Ruby

Deixe um comentário 
substring

#================================================================
# Descrição: O programa retorna uma string a partir de um dado
#            intervalo: [start, end[
#================================================================

# Lê a url e remove o "enter" do fim da string com o método chomp
print "Digite a string: "
str = gets().chomp
# Lê a posição inicial
print "Digite a posicao inicial: "
start = gets().to_i
# Lê a posição final
print "Digite a posicao final: "
ended = gets().to_i

# Gera substring
sub = str[start...ended]

# Imprime a substring
print "A substring: " + sub + "n"

system("pause");

String Reverse – Ruby

Deixe um comentário 
String Reverse

#================================================================
# Descrição: O programa inverte uma url e mostra o resultado.
#================================================================

# Lê a url e remove o "enter" do fim da string com o método chomp
print "Digite a url: "
str = gets().chomp

# Inverte a url
str.reverse!

# Imprime a url invertida
print "A url resultante: " + str + "n"

system("pause")

Jogo Adivinhe o Número

Deixe um comentário 
CUsersClaudionorDesktopgnumber.exe

//================================================================
// Descrição: Jogo "Adivinhe o número"
//================================================================

// Libs
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// Função main
int main(int argc, char** argv)
{
    int n, x,  limite_inferior, limite_superior, acertou, tentativas;

    // Inicia o gerador de números aleatórios
    srand(time(NULL));

    // Inicaliza as variáveis
    acertou = 0;            // Verifica se o jogador acertou o número
    tentativas = 0;         // Total de tentativas
    limite_inferior = 0;    // Limite inferior
    limite_superior = 101;  // Limite superior
    n = (rand() % 100) + 1; // Número gerado aleatoriamente

    // Loop principal
    do {
        // Limpa a tela
        system("cls");

        // Imprime o total de tentativas e pede um número ao jogador
        printf("Total de tentativas: %dn", tentativas);
        printf("Digite um numero(Esta entre %d e %d): ", limite_inferior, limite_superior);
        scanf("%d", &x);

        // Aumenta em 1 o número de tentativas
        tentativas++;

        // Verifica se o jogador ganhou ou diminui os limites ao redor do número
        if(x > n) {
            limite_superior = x;
        } else if(x < n) {
            limite_inferior = x;
        } else {
            acertou = 1;
        }
    }while(!acertou);

    // Imprime o resultado após o jogador ganhar o jogo
    system("cls");
    printf("Parabens, o numero e: %dn", n);
    printf("Total de tentativas: %dn", tentativas);

    // Pausa o programa até alguma tecla ser pressionada
    system("pause");
    return 0;
}

Fórmula de Bháskara – Ruby

Deixe um comentário

bhask

#================================================================
# Descricao: O programa calcula e mostra o resultado de uma
# 			 equação do segundo grau.
#================================================================

# Lê os termos da equação e os converte em número reais
puts "Digite o valor do termo a: "
a = gets.to_f()
puts "Digite o valor do termo b: "
b = gets.to_f()
puts "Digite o valor do termo c: "
c = gets.to_f()

# Calcula e verifica se delta possui raíz real
delta = b*b - 4*a*c
if(delta < 0)
	puts "A equacao nao possui raizes reais"
else
	# Calcula o valor de x1 e x2
	x1 = (-b + Math.sqrt(delta)) / (2*a)
	x2 = (-b - Math.sqrt(delta)) / (2*a)

	# Imprime os restultados
	puts "O valor de x1: " + x1.to_s
	puts "O valor de x2: " + x2.to_s
end

Enésimo termo da sequência Fibonacci – Ruby

Deixe um comentário 
fibrec
#================================================================
# Descrição: O programa calcula e imprime o enésimo termo
#            da sequência Fibonacci, de forma recursiva
#================================================================

# Função recursiva do fibonacci
def fibonacci(n)
	if(n == 1)
		return 0
	elsif(n == 2)
		return 1
	else
		return fibonacci(n-1) + fibonacci(n-2)
	end
end

# Lê um valor e converte em um número inteiro
puts "Digite a posicao: "
n = gets.to_i()

# Gera o termo da sequência
fib = fibonacci(n)

#Converte os números em texto e imprime o termo
puts "O termo: " + fib.to_s