Gerador de Números Primos – C

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

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

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

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

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: %d\n", 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: %d\n", n);
    printf("Total de tentativas: %d\n", tentativas);

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

Fórmula de Bháskara – Ruby

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